Baobhan Sith
848 lines
38 KiB
TypeScript
848 lines
38 KiB
TypeScript
import { ref, computed, shallowRef, type Ref } from 'vue'; // 导入 shallowRef
|
|
import { defineStore } from 'pinia';
|
|
import { useI18n } from 'vue-i18n';
|
|
import { useRouter } from 'vue-router'; // +++ 导入 useRouter +++
|
|
import { useConnectionsStore, type ConnectionInfo } from './connections.store';
|
|
// 导入文件编辑器相关的类型
|
|
import type { FileTab, FileInfo } from './fileEditor.store'; // 导入 FileTab 和 FileInfo (确保 FileTab 已在 fileEditor.store.ts 中简化)
|
|
import type { SftpReadFileSuccessPayload } from '../types/sftp.types'; // 导入更新后的类型
|
|
// --- 修复：添加 iconv-lite 和 buffer 导入 ---
|
|
import * as iconv from '@vscode/iconv-lite-umd';
|
|
import { Buffer } from 'buffer/';
|
|
|
|
// 导入管理器工厂函数 (用于创建实例)
|
|
// 导入 WsConnectionStatus 类型
|
|
import { createWebSocketConnectionManager, type WsConnectionStatus } from '../composables/useWebSocketConnection';
|
|
import { createSftpActionsManager, type WebSocketDependencies } from '../composables/useSftpActions';
|
|
import { createSshTerminalManager, type SshTerminalDependencies } from '../composables/useSshTerminal';
|
|
import { createStatusMonitorManager, type StatusMonitorDependencies } from '../composables/useStatusMonitor';
|
|
import { createDockerManager, type DockerManagerInstance, type DockerManagerDependencies } from '../composables/useDockerManager'; // +++ Import Docker Manager +++
|
|
|
|
// --- 辅助函数 ---
|
|
function generateSessionId(): string {
|
|
return Date.now().toString(36) + Math.random().toString(36).substring(2);
|
|
}
|
|
|
|
// 辅助函数：根据文件名获取语言 (从 fileEditor.store 迁移过来)
|
|
const getLanguageFromFilename = (filename: string): string => {
|
|
const extension = filename.split('.').pop()?.toLowerCase();
|
|
switch (extension) {
|
|
case 'js': return 'javascript';
|
|
case 'ts': return 'typescript';
|
|
case 'json': return 'json';
|
|
case 'html': return 'html';
|
|
case 'css': return 'css';
|
|
case 'scss': return 'scss';
|
|
case 'less': return 'less';
|
|
case 'py': return 'python';
|
|
case 'java': return 'java';
|
|
case 'c': return 'c';
|
|
case 'cpp': return 'cpp';
|
|
case 'cs': return 'csharp';
|
|
case 'go': return 'go';
|
|
case 'php': return 'php';
|
|
case 'rb': return 'ruby';
|
|
case 'rs': return 'rust';
|
|
case 'sql': return 'sql';
|
|
case 'sh': return 'shell';
|
|
case 'yaml': case 'yml': return 'yaml';
|
|
case 'md': return 'markdown';
|
|
case 'xml': return 'xml';
|
|
case 'ini': return 'ini';
|
|
case 'bat': return 'bat';
|
|
case 'dockerfile': return 'dockerfile';
|
|
default: return 'plaintext';
|
|
}
|
|
};
|
|
|
|
// --- 修复：添加 decodeRawContent 辅助函数 ---
|
|
const decodeRawContent = (rawContentBase64: string, encoding: string): string => {
|
|
try {
|
|
const buffer = Buffer.from(rawContentBase64, 'base64');
|
|
const normalizedEncoding = encoding.toLowerCase().replace(/[^a-z0-9]/g, ''); // Normalize encoding name
|
|
|
|
// 优先使用 TextDecoder 处理标准编码
|
|
if (['utf8', 'utf16le', 'utf16be'].includes(normalizedEncoding)) {
|
|
const decoder = new TextDecoder(encoding); // Use original encoding name for TextDecoder
|
|
return decoder.decode(buffer);
|
|
}
|
|
// 使用 iconv-lite 处理其他编码
|
|
else if (iconv.encodingExists(normalizedEncoding)) {
|
|
return iconv.decode(buffer, normalizedEncoding);
|
|
}
|
|
// 如果 iconv-lite 也不支持，回退到 UTF-8 并警告
|
|
else {
|
|
console.warn(`[SessionStore decodeRawContent] Unsupported encoding "${encoding}" requested. Falling back to UTF-8.`);
|
|
const decoder = new TextDecoder('utf-8');
|
|
return decoder.decode(buffer);
|
|
}
|
|
} catch (error: any) {
|
|
console.error(`[SessionStore decodeRawContent] Error decoding content with encoding "${encoding}":`, error);
|
|
return `// Error decoding content: ${error.message}`; // 返回错误信息
|
|
}
|
|
};
|
|
// --- 结束修复 ---
|
|
|
|
// --- 类型定义 (导出以便其他模块使用) ---
|
|
export type WsManagerInstance = ReturnType<typeof createWebSocketConnectionManager>;
|
|
export type SftpManagerInstance = ReturnType<typeof createSftpActionsManager>;
|
|
export type SshTerminalInstance = ReturnType<typeof createSshTerminalManager>;
|
|
export type StatusMonitorInstance = ReturnType<typeof createStatusMonitorManager>;
|
|
// Removed conflicting local declaration of DockerManagerInstance, it's imported above.
|
|
|
|
export interface SessionState {
|
|
sessionId: string;
|
|
connectionId: string; // 数据库中的连接 ID
|
|
connectionName: string; // 用于显示
|
|
wsManager: WsManagerInstance;
|
|
// sftpManager: SftpManagerInstance; // 移除单个实例
|
|
sftpManagers: Map<string, SftpManagerInstance>; // 使用 Map 管理多个实例
|
|
terminalManager: SshTerminalInstance;
|
|
statusMonitorManager: StatusMonitorInstance;
|
|
dockerManager: DockerManagerInstance; // +++ Add Docker Manager Instance +++
|
|
// currentSftpPath: Ref<string>; // 移除，由每个 sftpManager 内部管理
|
|
// --- 新增：独立编辑器状态 ---
|
|
editorTabs: Ref<FileTab[]>; // 编辑器标签页列表
|
|
activeEditorTabId: Ref<string | null>; // 当前活动的编辑器标签页 ID
|
|
// --- 新增：命令输入框内容 ---
|
|
commandInputContent: Ref<string>; // 当前会话的命令输入框内容
|
|
}
|
|
|
|
// 为标签栏定义包含状态的类型
|
|
export interface SessionTabInfoWithStatus {
|
|
sessionId: string;
|
|
connectionName: string;
|
|
status: WsConnectionStatus; // 添加状态字段
|
|
}
|
|
|
|
|
|
export const useSessionStore = defineStore('session', () => {
|
|
// --- 依赖 ---
|
|
const { t } = useI18n();
|
|
const connectionsStore = useConnectionsStore();
|
|
const router = useRouter(); // +++ 获取 router 实例 +++
|
|
|
|
// --- 移除 decodeBase64Content 辅助方法 ---
|
|
|
|
|
|
// --- State ---
|
|
// 使用 shallowRef 避免深度响应性问题，保留管理器实例内部的响应性
|
|
const sessions = shallowRef<Map<string, SessionState>>(new Map());
|
|
const activeSessionId = ref<string | null>(null);
|
|
|
|
// --- RDP Modal State ---
|
|
const isRdpModalOpen = ref(false);
|
|
const rdpConnectionInfo = ref<ConnectionInfo | null>(null);
|
|
|
|
// --- Getters ---
|
|
const sessionTabs = computed(() => {
|
|
return Array.from(sessions.value.values()).map(session => ({
|
|
sessionId: session.sessionId,
|
|
connectionName: session.connectionName,
|
|
}));
|
|
});
|
|
|
|
// 新增：包含状态的标签页信息
|
|
const sessionTabsWithStatus = computed((): SessionTabInfoWithStatus[] => {
|
|
return Array.from(sessions.value.values()).map(session => ({
|
|
sessionId: session.sessionId,
|
|
connectionName: session.connectionName,
|
|
status: session.wsManager.connectionStatus.value, // 从 wsManager 获取状态
|
|
}));
|
|
});
|
|
|
|
|
|
const activeSession = computed((): SessionState | null => {
|
|
if (!activeSessionId.value) return null;
|
|
return sessions.value.get(activeSessionId.value) || null;
|
|
});
|
|
|
|
// --- Actions ---
|
|
|
|
/**
|
|
* 根据连接 ID 查找连接信息
|
|
*/
|
|
const findConnectionInfo = (connectionId: number | string): ConnectionInfo | undefined => {
|
|
return connectionsStore.connections.find(c => c.id === Number(connectionId));
|
|
};
|
|
|
|
/**
|
|
* 打开一个新的会话标签页
|
|
*/
|
|
const openNewSession = (connectionId: number | string) => {
|
|
console.log(`[SessionStore] 请求打开新会话: ${connectionId}`);
|
|
const connInfo = findConnectionInfo(connectionId);
|
|
if (!connInfo) {
|
|
console.error(`[SessionStore] 无法打开新会话：找不到 ID 为 ${connectionId} 的连接信息。`);
|
|
// TODO: 向用户显示错误
|
|
return;
|
|
}
|
|
|
|
const newSessionId = generateSessionId();
|
|
const dbConnId = String(connInfo.id);
|
|
|
|
// 1. 创建管理器实例 (从 WorkspaceView 迁移)
|
|
const wsManager = createWebSocketConnectionManager(newSessionId, dbConnId, t);
|
|
// const currentSftpPath = ref<string>('.'); // 移除单个 SFTP 路径状态
|
|
// const wsDeps: WebSocketDependencies = { ... }; // wsDeps 将在 getOrCreateSftpManager 中创建
|
|
// const sftpManager = createSftpActionsManager(newSessionId, currentSftpPath, wsDeps, t); // 移除单个 sftpManager 创建
|
|
const sshTerminalDeps: SshTerminalDependencies = {
|
|
sendMessage: wsManager.sendMessage,
|
|
onMessage: wsManager.onMessage,
|
|
isConnected: wsManager.isConnected,
|
|
};
|
|
const terminalManager = createSshTerminalManager(newSessionId, sshTerminalDeps, t);
|
|
const statusMonitorDeps: StatusMonitorDependencies = {
|
|
onMessage: wsManager.onMessage,
|
|
isConnected: wsManager.isConnected,
|
|
};
|
|
const statusMonitorManager = createStatusMonitorManager(newSessionId, statusMonitorDeps);
|
|
// +++ Create Docker Manager Dependencies +++
|
|
const dockerManagerDeps: DockerManagerDependencies = {
|
|
sendMessage: wsManager.sendMessage,
|
|
onMessage: wsManager.onMessage,
|
|
isConnected: wsManager.isConnected,
|
|
};
|
|
// +++ Create Docker Manager Instance +++
|
|
const dockerManager = createDockerManager(newSessionId, dockerManagerDeps, { t });
|
|
|
|
// 2. 创建 SessionState 对象
|
|
const newSession: SessionState = {
|
|
sessionId: newSessionId,
|
|
connectionId: dbConnId,
|
|
connectionName: connInfo.name || connInfo.host,
|
|
wsManager: wsManager,
|
|
// sftpManager: sftpManager, // 移除
|
|
sftpManagers: new Map<string, SftpManagerInstance>(), // 初始化 Map
|
|
terminalManager: terminalManager,
|
|
statusMonitorManager: statusMonitorManager,
|
|
dockerManager: dockerManager, // +++ Add Docker Manager to Session State +++
|
|
// currentSftpPath: currentSftpPath, // 移除
|
|
// --- 初始化编辑器状态 ---
|
|
editorTabs: ref([]), // 初始化为空数组
|
|
activeEditorTabId: ref(null), // 初始化为 null
|
|
// --- 初始化命令输入框内容 ---
|
|
commandInputContent: ref(''), // 初始化为空字符串
|
|
};
|
|
|
|
// 3. 添加到 Map 并激活 (需要创建 Map 的新实例以触发 shallowRef 更新)
|
|
const newSessionsMap = new Map(sessions.value);
|
|
newSessionsMap.set(newSessionId, newSession);
|
|
sessions.value = newSessionsMap; // 触发 shallowRef 更新
|
|
activeSessionId.value = newSessionId;
|
|
console.log(`[SessionStore] 已创建新会话实例: ${newSessionId} for connection ${dbConnId}`);
|
|
|
|
// 4. 启动 WebSocket 连接
|
|
// 根据当前页面协议动态生成 WebSocket URL，并移除硬编码的端口
|
|
// 假设 WebSocket 服务与 Web 服务在同一主机和端口上提供（通过反向代理）
|
|
const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
|
|
// 使用 window.location.host，它包含主机名和端口（如果非默认）
|
|
const wsHostAndPort = window.location.host;
|
|
// 假设 WebSocket 路径固定为 /ws/
|
|
const wsUrl = `${protocol}//${wsHostAndPort}/ws/`;
|
|
console.log(`[SessionStore] Generated WebSocket URL: ${wsUrl}`); // 添加日志记录生成的 URL
|
|
wsManager.connect(wsUrl);
|
|
console.log(`[SessionStore] 已为会话 ${newSessionId} 启动 WebSocket 连接。`);
|
|
};
|
|
|
|
/**
|
|
* 激活指定 ID 的会话标签页
|
|
*/
|
|
const activateSession = (sessionId: string) => {
|
|
if (sessions.value.has(sessionId)) {
|
|
if (activeSessionId.value !== sessionId) {
|
|
activeSessionId.value = sessionId;
|
|
console.log(`[SessionStore] 已激活会话: ${sessionId}`);
|
|
// TODO: 可能需要 nextTick 来聚焦终端?
|
|
} else {
|
|
console.log(`[SessionStore] 会话 ${sessionId} 已经是活动状态。`);
|
|
}
|
|
} else {
|
|
console.warn(`[SessionStore] 尝试激活不存在的会话 ID: ${sessionId}`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 更新指定会话中编辑器标签页的内容
|
|
*/
|
|
const updateFileContentInSession = (sessionId: string, tabId: string, newContent: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试在不存在的会话 ${sessionId} 中更新标签页 ${tabId} 内容`);
|
|
return;
|
|
}
|
|
const tab = session.editorTabs.value.find(t => t.id === tabId);
|
|
if (tab && !tab.isLoading) {
|
|
tab.content = newContent;
|
|
// 检查是否修改
|
|
tab.isModified = tab.content !== tab.originalContent;
|
|
// 当用户编辑时，重置保存状态
|
|
if (tab.saveStatus === 'success' || tab.saveStatus === 'error') {
|
|
tab.saveStatus = 'idle';
|
|
tab.saveError = null;
|
|
}
|
|
} else if (tab) {
|
|
console.warn(`[SessionStore] 尝试更新正在加载的标签页 ${tabId} 的内容`);
|
|
} else {
|
|
console.warn(`[SessionStore] 尝试更新会话 ${sessionId} 中不存在的标签页 ${tabId} 的内容`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 保存指定会话中的编辑器标签页
|
|
*/
|
|
const saveFileInSession = async (sessionId: string, tabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试在不存在的会话 ${sessionId} 中保存标签页 ${tabId}`);
|
|
return;
|
|
}
|
|
const tab = session.editorTabs.value.find(t => t.id === tabId);
|
|
if (!tab) {
|
|
console.warn(`[SessionStore] 尝试保存在会话 ${sessionId} 中不存在的标签页 ${tabId}`);
|
|
return;
|
|
}
|
|
|
|
if (tab.isSaving || tab.isLoading || tab.loadingError || !tab.isModified) {
|
|
console.warn(`[SessionStore] 保存条件不满足 for ${tab.filePath} (会话 ${sessionId})，无法保存。`, { tab });
|
|
return;
|
|
}
|
|
|
|
// 检查会话连接状态
|
|
if (!session.wsManager.isConnected.value || !session.wsManager.isSftpReady.value) {
|
|
console.error(`[SessionStore] 保存失败：会话 ${sessionId} 无效或未连接/SFTP 未就绪。`);
|
|
tab.saveStatus = 'error';
|
|
tab.saveError = t('fileManager.errors.sessionInvalidOrNotReady');
|
|
setTimeout(() => { if (tab.saveStatus === 'error') { tab.saveStatus = 'idle'; tab.saveError = null; } }, 5000);
|
|
return;
|
|
}
|
|
|
|
// 获取默认的 sftpManager 实例来执行保存操作
|
|
const sftpManager = getOrCreateSftpManager(sessionId, 'primary');
|
|
if (!sftpManager) {
|
|
console.error(`[SessionStore] 保存失败：无法获取会话 ${sessionId} 的 primary sftpManager。`);
|
|
tab.saveStatus = 'error';
|
|
tab.saveError = t('fileManager.errors.sftpManagerNotFound');
|
|
setTimeout(() => { if (tab.saveStatus === 'error') { tab.saveStatus = 'idle'; tab.saveError = null; } }, 5000);
|
|
return;
|
|
}
|
|
|
|
console.log(`[SessionStore] 开始保存文件: ${tab.filePath} (会话 ${sessionId}, Tab ID: ${tab.id}) using primary sftpManager`);
|
|
tab.isSaving = true;
|
|
tab.saveStatus = 'saving';
|
|
tab.saveError = null;
|
|
|
|
const contentToSave = tab.content;
|
|
const encodingToUse = tab.selectedEncoding; // 获取选定的编码
|
|
|
|
try {
|
|
// --- 修改：传递 selectedEncoding 给 writeFile ---
|
|
await sftpManager.writeFile(tab.filePath, contentToSave, encodingToUse);
|
|
console.log(`[SessionStore] 文件 ${tab.filePath} (会话 ${sessionId}) 使用编码 ${encodingToUse} 保存成功。`);
|
|
tab.isSaving = false;
|
|
tab.saveStatus = 'success';
|
|
tab.saveError = null;
|
|
tab.originalContent = contentToSave; // 更新原始内容
|
|
tab.isModified = false; // 重置修改状态
|
|
setTimeout(() => { if (tab.saveStatus === 'success') { tab.saveStatus = 'idle'; } }, 2000);
|
|
} catch (err: any) {
|
|
console.error(`[SessionStore] 保存文件 ${tab.filePath} (会话 ${sessionId}) 失败:`, err);
|
|
tab.isSaving = false;
|
|
tab.saveStatus = 'error';
|
|
tab.saveError = `${t('fileManager.errors.saveFailed')}: ${err.message || err}`;
|
|
setTimeout(() => { if (tab.saveStatus === 'error') { tab.saveStatus = 'idle'; tab.saveError = null; } }, 5000);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* 关闭指定 ID 的会话标签页
|
|
*/
|
|
const closeSession = (sessionId: string) => {
|
|
console.log(`[SessionStore] 请求关闭会话 ID: ${sessionId}`);
|
|
const sessionToClose = sessions.value.get(sessionId);
|
|
if (!sessionToClose) {
|
|
console.warn(`[SessionStore] 尝试关闭不存在的会话 ID: ${sessionId}`);
|
|
return;
|
|
}
|
|
|
|
// 1. 调用实例上的清理和断开方法 (从 WorkspaceView 迁移)
|
|
sessionToClose.wsManager.disconnect();
|
|
console.log(`[SessionStore] 已为会话 ${sessionId} 调用 wsManager.disconnect()`);
|
|
// 清理该会话下的所有 sftpManager 实例
|
|
sessionToClose.sftpManagers.forEach((manager, instanceId) => {
|
|
manager.cleanup();
|
|
console.log(`[SessionStore] 已为会话 ${sessionId} 的 sftpManager (实例 ${instanceId}) 调用 cleanup()`);
|
|
});
|
|
sessionToClose.sftpManagers.clear();
|
|
// sessionToClose.sftpManager.cleanup(); // 移除旧的调用
|
|
// console.log(`[SessionStore] 已为会话 ${sessionId} 调用 sftpManager.cleanup()`); // 移除旧的日志
|
|
sessionToClose.terminalManager.cleanup();
|
|
console.log(`[SessionStore] 已为会话 ${sessionId} 调用 terminalManager.cleanup()`);
|
|
sessionToClose.statusMonitorManager.cleanup();
|
|
console.log(`[SessionStore] 已为会话 ${sessionId} 调用 statusMonitorManager.cleanup()`);
|
|
sessionToClose.dockerManager.cleanup(); // +++ Call Docker Manager cleanup +++
|
|
console.log(`[SessionStore] 已为会话 ${sessionId} 调用 dockerManager.cleanup()`); // +++ Add log +++
|
|
// TODO: 清理编辑器相关资源？例如提示保存未保存的文件
|
|
|
|
// 2. 从 Map 中移除会话 (需要创建 Map 的新实例以触发 shallowRef 更新)
|
|
const newSessionsMap = new Map(sessions.value);
|
|
newSessionsMap.delete(sessionId);
|
|
sessions.value = newSessionsMap; // 触发 shallowRef 更新
|
|
console.log(`[SessionStore] 已从 Map 中移除会话: ${sessionId}`);
|
|
|
|
// 3. 切换活动标签页
|
|
if (activeSessionId.value === sessionId) {
|
|
const remainingSessions = Array.from(sessions.value.keys());
|
|
const nextActiveId = remainingSessions.length > 0 ? remainingSessions[remainingSessions.length - 1] : null;
|
|
activeSessionId.value = nextActiveId;
|
|
console.log(`[SessionStore] 关闭活动会话后，切换到: ${nextActiveId}`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 处理连接列表的左键点击
|
|
* 处理来自 UI 的连接请求（例如点击连接列表或仪表盘）。
|
|
* - 如果是 RDP 连接，直接打开 RDP 模态框。
|
|
* - 如果是非 RDP 连接：
|
|
* - 如果点击的是当前活动且断开的会话，则尝试重连。
|
|
* - 否则，打开一个新的会话标签页并导航到 Workspace。
|
|
*/
|
|
const handleConnectRequest = (connection: ConnectionInfo) => {
|
|
console.log(`[SessionStore] handleConnectRequest called for connection: ${connection.name} (ID: ${connection.id}, Type: ${connection.type})`);
|
|
|
|
if (connection.type === 'RDP') {
|
|
// RDP: 直接打开模态框
|
|
openRdpModal(connection);
|
|
} else {
|
|
// 非 RDP (e.g., SSH): 处理会话和导航
|
|
const connIdStr = String(connection.id);
|
|
let activeAndDisconnected = false;
|
|
|
|
// 检查是否点击了当前活动且断开的会话
|
|
if (activeSessionId.value) {
|
|
const currentActiveSession = sessions.value.get(activeSessionId.value);
|
|
if (currentActiveSession && currentActiveSession.connectionId === connIdStr) {
|
|
const currentStatus = currentActiveSession.wsManager.connectionStatus.value;
|
|
console.log(`[SessionStore] 点击的是当前活动会话 ${activeSessionId.value}，状态: ${currentStatus}`);
|
|
if (currentStatus === 'disconnected' || currentStatus === 'error') {
|
|
activeAndDisconnected = true;
|
|
// 满足最高优先级：重连当前活动会话
|
|
console.log(`[SessionStore] 活动会话 ${activeSessionId.value} 已断开或出错，尝试重连...`);
|
|
const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
|
|
// 使用 window.location.host
|
|
const wsHostAndPort = window.location.host;
|
|
const wsUrl = `${protocol}//${wsHostAndPort}/ws/`;
|
|
console.log(`[SessionStore handleConnectRequest] Generated WebSocket URL for reconnect: ${wsUrl}`);
|
|
currentActiveSession.wsManager.connect(wsUrl);
|
|
// 重连后，确保激活该会话（如果它不是活动会话）并导航
|
|
activateSession(activeSessionId.value); // 确保激活
|
|
router.push({ name: 'Workspace' });
|
|
}
|
|
}
|
|
}
|
|
|
|
// 如果不满足重连条件，则总是打开新会话并导航
|
|
if (!activeAndDisconnected) {
|
|
console.log(`[SessionStore] 不满足重连条件或点击了其他连接，将打开新会话 for ID: ${connIdStr}`);
|
|
openNewSession(connIdStr); // openNewSession 会自动激活新会话
|
|
// 导航到 Workspace，让 WorkspaceView 处理新激活的会话
|
|
router.push({ name: 'Workspace' }); // +++ 添加跳转 +++
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 处理连接列表的中键点击（总是打开新会话）
|
|
*/
|
|
const handleOpenNewSession = (connectionId: number | string) => {
|
|
console.log(`[SessionStore] handleOpenNewSession called for ID: ${connectionId}`);
|
|
openNewSession(connectionId);
|
|
};
|
|
|
|
/**
|
|
* 清理所有会话（例如在应用卸载时）
|
|
*/
|
|
const cleanupAllSessions = () => {
|
|
console.log('[SessionStore] 清理所有会话...');
|
|
sessions.value.forEach((session, sessionId) => {
|
|
closeSession(sessionId); // 调用单个会话的关闭逻辑
|
|
});
|
|
sessions.value.clear();
|
|
activeSessionId.value = null;
|
|
};
|
|
|
|
// --- 新增：编辑器相关 Actions ---
|
|
|
|
/**
|
|
* 在指定会话中打开文件
|
|
*/
|
|
const openFileInSession = (sessionId: string, fileInfo: FileInfo) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试在不存在的会话 ${sessionId} 中打开文件`);
|
|
return;
|
|
}
|
|
|
|
// 检查标签页是否已存在 (使用 filePath)
|
|
const existingTab = session.editorTabs.value.find(tab => tab.filePath === fileInfo.fullPath);
|
|
if (existingTab) {
|
|
// 如果标签页已存在，则激活它
|
|
session.activeEditorTabId.value = existingTab.id;
|
|
console.log(`[SessionStore] 会话 ${sessionId} 中已存在文件 ${fileInfo.fullPath} 的标签页，已激活: ${existingTab.id}`);
|
|
} else {
|
|
// 创建新标签页
|
|
// 创建新标签页 (使用简化后的 FileTab 接口)
|
|
// --- 修复：初始化 rawContentBase64 ---
|
|
const newTab: FileTab = {
|
|
id: `${sessionId}:${fileInfo.fullPath}`, // <-- 修复：使用 sessionId:filePath 作为 ID
|
|
sessionId: sessionId,
|
|
filePath: fileInfo.fullPath,
|
|
filename: fileInfo.name,
|
|
content: '', // 将由后端填充
|
|
originalContent: '', // 将由后端填充
|
|
rawContentBase64: null, // 初始化为 null
|
|
language: getLanguageFromFilename(fileInfo.name),
|
|
selectedEncoding: 'utf-8', // 初始默认，将由后端更新
|
|
isLoading: true,
|
|
loadingError: null,
|
|
isSaving: false,
|
|
saveStatus: 'idle',
|
|
saveError: null,
|
|
isModified: false,
|
|
};
|
|
// session.editorTabs.value.push(newTab); // 移除重复的 push
|
|
session.editorTabs.value.push(newTab);
|
|
session.activeEditorTabId.value = newTab.id;
|
|
console.log(`[SessionStore] 已在会话 ${sessionId} 中为文件 ${fileInfo.fullPath} 创建新标签页: ${newTab.id}`);
|
|
|
|
// --- 新增：异步加载文件内容 ---
|
|
// --- 修改：异步加载文件内容 (处理后端解码后的内容) ---
|
|
const loadContent = async () => {
|
|
const tabIndex = session.editorTabs.value.findIndex(t => t.id === newTab.id);
|
|
if (tabIndex === -1) return; // Tab might have been closed quickly
|
|
|
|
// 更新加载状态 (使用 splice 保证响应性)
|
|
const loadingTab = { ...session.editorTabs.value[tabIndex], isLoading: true, loadingError: null };
|
|
session.editorTabs.value.splice(tabIndex, 1, loadingTab);
|
|
|
|
try {
|
|
// 获取默认的 sftpManager 实例来执行读取操作
|
|
const sftpManager = getOrCreateSftpManager(sessionId, 'primary');
|
|
if (!sftpManager) {
|
|
throw new Error(t('fileManager.errors.sftpManagerNotFound'));
|
|
}
|
|
console.log(`[SessionStore ${sessionId}] 使用 primary sftpManager 读取文件 ${fileInfo.fullPath}`);
|
|
|
|
// 调用 sftpManager.readFile (不带编码参数，让后端自动检测)
|
|
// 后端现在返回 { content: string, encodingUsed: string }
|
|
const fileData: SftpReadFileSuccessPayload = await sftpManager.readFile(fileInfo.fullPath);
|
|
console.log(`[SessionStore ${sessionId}] 文件 ${fileInfo.fullPath} 读取成功。后端使用编码: ${fileData.encodingUsed}`);
|
|
|
|
// 更新标签页状态 (使用 splice 保证响应性)
|
|
const currentTabState = session.editorTabs.value.find(t => t.id === newTab.id); // 获取最新状态
|
|
if (!currentTabState) return; // 可能在请求期间关闭了
|
|
|
|
// --- 修复：使用 decodeRawContent 解码并存储原始数据 ---
|
|
const initialContent = decodeRawContent(fileData.rawContentBase64, fileData.encodingUsed);
|
|
const updatedTab: FileTab = {
|
|
...currentTabState,
|
|
content: initialContent,
|
|
originalContent: initialContent, // 初始原始内容
|
|
rawContentBase64: fileData.rawContentBase64, // 存储原始 Base64 数据
|
|
selectedEncoding: fileData.encodingUsed, // 存储后端实际使用的编码
|
|
isLoading: false,
|
|
isModified: false,
|
|
loadingError: null,
|
|
};
|
|
const finalTabIndex = session.editorTabs.value.findIndex(t => t.id === newTab.id); // 重新获取索引
|
|
if (finalTabIndex !== -1) {
|
|
session.editorTabs.value.splice(finalTabIndex, 1, updatedTab);
|
|
console.log(`[SessionStore ${sessionId}] 文件 ${fileInfo.fullPath} 内容已加载并设置到标签页 ${newTab.id}。`);
|
|
} else {
|
|
console.warn(`[SessionStore ${sessionId}] 尝试更新标签页 ${newTab.id} 时未找到索引。`);
|
|
}
|
|
|
|
} catch (err: any) {
|
|
console.error(`[SessionStore ${sessionId}] 读取文件 ${fileInfo.fullPath} 失败:`, err);
|
|
// 更新错误状态 (使用 splice 保证响应性)
|
|
const errorTabIndex = session.editorTabs.value.findIndex(t => t.id === newTab.id);
|
|
if (errorTabIndex !== -1) {
|
|
const errorTab = {
|
|
...session.editorTabs.value[errorTabIndex],
|
|
isLoading: false,
|
|
loadingError: `${t('fileManager.errors.readFileFailed')}: ${err.message || err}`,
|
|
content: `// 加载错误: ${err.message || err}`
|
|
};
|
|
session.editorTabs.value.splice(errorTabIndex, 1, errorTab);
|
|
}
|
|
}
|
|
};
|
|
|
|
loadContent(); // 启动内容加载
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 关闭指定会话中的编辑器标签页
|
|
*/
|
|
const closeEditorTabInSession = (sessionId: string, tabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试在不存在的会话 ${sessionId} 中关闭标签页 ${tabId}`);
|
|
return;
|
|
}
|
|
|
|
const tabIndex = session.editorTabs.value.findIndex(tab => tab.id === tabId);
|
|
if (tabIndex === -1) {
|
|
console.warn(`[SessionStore] 尝试关闭会话 ${sessionId} 中不存在的标签页 ID: ${tabId}`);
|
|
return;
|
|
}
|
|
|
|
// TODO: 检查 isDirty 状态，提示保存？
|
|
|
|
session.editorTabs.value.splice(tabIndex, 1);
|
|
console.log(`[SessionStore] 已从会话 ${sessionId} 中移除标签页: ${tabId}`);
|
|
|
|
// 如果关闭的是当前活动标签页，则切换到前一个或 null
|
|
if (session.activeEditorTabId.value === tabId) {
|
|
const remainingTabs = session.editorTabs.value;
|
|
const nextActiveTabId = remainingTabs.length > 0
|
|
? remainingTabs[Math.max(0, tabIndex - 1)].id // 尝试激活前一个，或第一个
|
|
: null;
|
|
session.activeEditorTabId.value = nextActiveTabId;
|
|
console.log(`[SessionStore] 会话 ${sessionId} 关闭活动标签页后，切换到: ${nextActiveTabId}`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 激活指定会话中的编辑器标签页
|
|
*/
|
|
const setActiveEditorTabInSession = (sessionId: string, tabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试在不存在的会话 ${sessionId} 中激活标签页 ${tabId}`);
|
|
return;
|
|
}
|
|
|
|
if (session.editorTabs.value.some(tab => tab.id === tabId)) {
|
|
if (session.activeEditorTabId.value !== tabId) {
|
|
session.activeEditorTabId.value = tabId;
|
|
console.log(`[SessionStore] 已在会话 ${sessionId} 中激活标签页: ${tabId}`);
|
|
}
|
|
} else {
|
|
console.warn(`[SessionStore] 尝试激活会话 ${sessionId} 中不存在的标签页 ID: ${tabId}`);
|
|
}
|
|
};
|
|
|
|
// +++ 新增：关闭指定会话中的其他编辑器标签页 +++
|
|
const closeOtherTabsInSession = (sessionId: string, targetTabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) return;
|
|
const targetIndex = session.editorTabs.value.findIndex(tab => tab.id === targetTabId);
|
|
if (targetIndex === -1) return;
|
|
console.log(`[SessionStore ${sessionId}] 关闭除 ${targetTabId} 之外的所有标签页...`);
|
|
const tabsToClose = session.editorTabs.value
|
|
.filter(tab => tab.id !== targetTabId)
|
|
.map(tab => tab.id);
|
|
tabsToClose.forEach(id => closeEditorTabInSession(sessionId, id)); // 复用单个关闭逻辑
|
|
};
|
|
|
|
// +++ 新增：关闭指定会话中右侧的编辑器标签页 +++
|
|
const closeTabsToTheRightInSession = (sessionId: string, targetTabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) return;
|
|
const targetIndex = session.editorTabs.value.findIndex(tab => tab.id === targetTabId);
|
|
if (targetIndex === -1) return;
|
|
console.log(`[SessionStore ${sessionId}] 关闭 ${targetTabId} 右侧的所有标签页...`);
|
|
const tabsToClose = session.editorTabs.value
|
|
.slice(targetIndex + 1)
|
|
.map(tab => tab.id);
|
|
tabsToClose.forEach(id => closeEditorTabInSession(sessionId, id));
|
|
};
|
|
|
|
// +++ 新增：关闭指定会话中左侧的编辑器标签页 +++
|
|
const closeTabsToTheLeftInSession = (sessionId: string, targetTabId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) return;
|
|
const targetIndex = session.editorTabs.value.findIndex(tab => tab.id === targetTabId);
|
|
if (targetIndex === -1) return;
|
|
console.log(`[SessionStore ${sessionId}] 关闭 ${targetTabId} 左侧的所有标签页...`);
|
|
const tabsToClose = session.editorTabs.value
|
|
.slice(0, targetIndex)
|
|
.map(tab => tab.id);
|
|
tabsToClose.forEach(id => closeEditorTabInSession(sessionId, id));
|
|
};
|
|
|
|
|
|
/**
|
|
* 在指定会话中更改文件编码并重新解码
|
|
*/
|
|
// --- 修改：更改文件编码（通过请求后端重新读取） ---
|
|
const changeEncodingInSession = (sessionId: string, tabId: string, newEncoding: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.warn(`[SessionStore] 尝试更改不存在的会话 ${sessionId} 中标签页 ${tabId} 的编码。`);
|
|
return;
|
|
}
|
|
const tabIndex = session.editorTabs.value.findIndex(t => t.id === tabId);
|
|
if (tabIndex === -1) {
|
|
console.warn(`[SessionStore] 尝试更改会话 ${sessionId} 中不存在的标签页 ${tabId} 的编码。`);
|
|
return;
|
|
}
|
|
|
|
const tab = session.editorTabs.value[tabIndex];
|
|
|
|
if (!tab.rawContentBase64) {
|
|
console.error(`[SessionStore] 无法更改编码：会话 ${sessionId} 标签页 ${tabId} 没有原始文件数据。`);
|
|
// 更新错误状态
|
|
const errorTab = { ...tab, isLoading: false, loadingError: '缺少原始文件数据，无法更改编码' };
|
|
session.editorTabs.value.splice(tabIndex, 1, errorTab);
|
|
return;
|
|
}
|
|
if (tab.selectedEncoding === newEncoding) {
|
|
console.log(`[SessionStore] 会话 ${sessionId} 标签页 ${tabId} 编码已经是 ${newEncoding}，无需更改。`);
|
|
return;
|
|
}
|
|
|
|
console.log(`[SessionStore] 使用新编码 "${newEncoding}" 在前端重新解码文件: ${tab.filePath} (会话 ${sessionId}, Tab ID: ${tabId})`);
|
|
|
|
try {
|
|
// 使用新编码解码存储的原始数据
|
|
const newContent = decodeRawContent(tab.rawContentBase64, newEncoding);
|
|
|
|
// 更新标签页状态 (使用 splice 保证响应性)
|
|
const updatedTab: FileTab = {
|
|
...tab,
|
|
content: newContent,
|
|
selectedEncoding: newEncoding, // 更新选择的编码
|
|
isLoading: false, // 解码完成 (移除加载状态)
|
|
loadingError: null,
|
|
// isModified 状态保持不变
|
|
};
|
|
session.editorTabs.value.splice(tabIndex, 1, updatedTab);
|
|
console.log(`[SessionStore] 文件 ${tab.filePath} (会话 ${sessionId}) 使用新编码 "${newEncoding}" 解码完成。`);
|
|
|
|
} catch (err: any) { // catch 应该在 decodeRawContent 内部处理了，但以防万一
|
|
console.error(`[SessionStore] 使用编码 "${newEncoding}" 在前端解码文件 ${tab.filePath} (会话 ${sessionId}) 失败:`, err);
|
|
const errorMsg = `前端解码失败 (编码: ${newEncoding}): ${err.message || err}`;
|
|
// 更新错误状态 (使用 splice)
|
|
const errorTab: FileTab = {
|
|
...tab,
|
|
isLoading: false,
|
|
loadingError: errorMsg,
|
|
};
|
|
session.editorTabs.value.splice(tabIndex, 1, errorTab);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* 获取或创建指定会话和实例 ID 的 SFTP 管理器。
|
|
* @param sessionId 会话 ID
|
|
* @param instanceId 文件管理器实例 ID (e.g., 'sidebar', 'panel-xyz')
|
|
* @returns SftpManagerInstance 或 null (如果会话不存在)
|
|
*/
|
|
const getOrCreateSftpManager = (sessionId: string, instanceId: string): SftpManagerInstance | null => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (!session) {
|
|
console.error(`[SessionStore] 尝试为不存在的会话 ${sessionId} 获取 SFTP 管理器`);
|
|
return null;
|
|
}
|
|
|
|
let manager = session.sftpManagers.get(instanceId);
|
|
if (!manager) {
|
|
console.log(`[SessionStore] 为会话 ${sessionId} 创建新的 SFTP 管理器实例: ${instanceId}`);
|
|
const currentSftpPath = ref<string>('.'); // 每个实例有自己的路径
|
|
const wsDeps: WebSocketDependencies = {
|
|
sendMessage: session.wsManager.sendMessage,
|
|
onMessage: session.wsManager.onMessage,
|
|
isConnected: session.wsManager.isConnected,
|
|
isSftpReady: session.wsManager.isSftpReady,
|
|
};
|
|
manager = createSftpActionsManager(sessionId, currentSftpPath, wsDeps, t);
|
|
session.sftpManagers.set(instanceId, manager);
|
|
}
|
|
return manager;
|
|
};
|
|
|
|
/**
|
|
* 移除并清理指定会话和实例 ID 的 SFTP 管理器。
|
|
* @param sessionId 会话 ID
|
|
* @param instanceId 文件管理器实例 ID
|
|
*/
|
|
const removeSftpManager = (sessionId: string, instanceId: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (session) {
|
|
const manager = session.sftpManagers.get(instanceId);
|
|
if (manager) {
|
|
manager.cleanup();
|
|
session.sftpManagers.delete(instanceId);
|
|
console.log(`[SessionStore] 已移除并清理会话 ${sessionId} 的 SFTP 管理器实例: ${instanceId}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
// --- RDP Modal Actions ---
|
|
const openRdpModal = (connection: ConnectionInfo) => {
|
|
console.log(`[SessionStore] Opening RDP modal for connection: ${connection.name} (ID: ${connection.id})`);
|
|
rdpConnectionInfo.value = connection;
|
|
isRdpModalOpen.value = true;
|
|
};
|
|
|
|
const closeRdpModal = () => {
|
|
console.log('[SessionStore] Closing RDP modal.');
|
|
isRdpModalOpen.value = false;
|
|
rdpConnectionInfo.value = null; // 清除连接信息
|
|
};
|
|
|
|
/**
|
|
* 更新指定会话的命令输入框内容
|
|
*/
|
|
const updateSessionCommandInput = (sessionId: string, content: string) => {
|
|
const session = sessions.value.get(sessionId);
|
|
if (session) {
|
|
session.commandInputContent.value = content;
|
|
} else {
|
|
console.warn(`[SessionStore] 尝试更新不存在的会话 ${sessionId} 的命令输入内容`);
|
|
}
|
|
};
|
|
|
|
|
|
return {
|
|
// State
|
|
sessions,
|
|
activeSessionId,
|
|
isRdpModalOpen, // 导出 RDP 模态框状态
|
|
rdpConnectionInfo, // 导出 RDP 连接信息
|
|
// Getters
|
|
sessionTabs,
|
|
sessionTabsWithStatus, // 导出新的 getter
|
|
activeSession,
|
|
// Actions
|
|
openNewSession,
|
|
activateSession,
|
|
closeSession,
|
|
handleConnectRequest,
|
|
handleOpenNewSession,
|
|
cleanupAllSessions,
|
|
getOrCreateSftpManager, // 导出新的 Action
|
|
removeSftpManager, // 导出新的 Action
|
|
// --- 新增：导出编辑器相关 Actions ---
|
|
openFileInSession,
|
|
closeEditorTabInSession,
|
|
setActiveEditorTabInSession,
|
|
updateFileContentInSession, // 导出更新内容 Action
|
|
saveFileInSession, // 导出保存文件 Action
|
|
changeEncodingInSession, // 导出更改编码 Action
|
|
closeOtherTabsInSession, // +++ 导出新 action +++
|
|
closeTabsToTheRightInSession, // +++ 导出新 action +++
|
|
closeTabsToTheLeftInSession, // +++ 导出新 action +++
|
|
// --- RDP Modal Actions ---
|
|
openRdpModal, // 导出打开 RDP 模态框 Action
|
|
closeRdpModal, // 导出关闭 RDP 模态框 Action
|
|
// --- 命令输入框 Action ---
|
|
updateSessionCommandInput, // 导出更新命令输入 Action
|
|
};
|
|
});
|