refactor: 优化代码结构

2025-05-09 17:49:37 +08:00
parent 21e71857e1
commit 36afe3d5c2
10 changed files with 894 additions and 833 deletions
@@ -0,0 +1,15 @@
+// packages/frontend/src/stores/session/actions/commandInputActions.ts
+
+import { sessions } from '../state';
+
+/**
+ * 更新指定会话的命令输入框内容
+ */
+export const updateSessionCommandInput = (sessionId: string, content: string) => {
+    const session = sessions.value.get(sessionId);
+    if (session) {
+        session.commandInputContent.value = content;
+    } else {
+        console.warn(`[CommandInputActions] 尝试更新不存在的会话 ${sessionId} 的命令输入内容`);
+    }
+};
@@ -0,0 +1,310 @@
+// packages/frontend/src/stores/session/actions/editorActions.ts
+
+import { sessions } from '../state';
+import { getLanguageFromFilename, decodeRawContent } from '../utils';
+import type { FileTab, SftpManagerInstance } from '../types';
+import type { FileInfo } from '../../fileEditor.store'; // 路径: packages/frontend/src/stores/fileEditor.store.ts
+import type { SftpReadFileSuccessPayload } from '../../../types/sftp.types'; // 路径: packages/frontend/src/types/sftp.types.ts
+import type { useI18n } from 'vue-i18n';
+
+// --- Editor Actions ---
+export const openFileInSession = (
+    sessionId: string,
+    fileInfo: FileInfo,
+    dependencies: {
+        getOrCreateSftpManager: (sessionId: string, instanceId: string) => SftpManagerInstance | null;
+        t: ReturnType<typeof useI18n>['t'];
+    }
+) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[EditorActions] 尝试在不存在的会话 ${sessionId} 中打开文件`);
+        return;
+    }
+    const { getOrCreateSftpManager, t } = dependencies;
+
+    const existingTab = session.editorTabs.value.find(tab => tab.filePath === fileInfo.fullPath);
+    if (existingTab) {
+        session.activeEditorTabId.value = existingTab.id;
+        console.log(`[EditorActions] 会话 ${sessionId} 中已存在文件 ${fileInfo.fullPath} 的标签页，已激活: ${existingTab.id}`);
+    } else {
+        const newTabId = `${sessionId}:${fileInfo.fullPath}`; // 保证唯一性
+        const newTab: FileTab = {
+            id: newTabId,
+            sessionId: sessionId,
+            filePath: fileInfo.fullPath,
+            filename: fileInfo.name,
+            content: '',
+            originalContent: '',
+            rawContentBase64: 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);
+        session.activeEditorTabId.value = newTab.id;
+        console.log(`[EditorActions] 已在会话 ${sessionId} 中为文件 ${fileInfo.fullPath} 创建新标签页: ${newTab.id}`);
+
+        const loadContent = async () => {
+            const tabRef = session.editorTabs.value.find(t => t.id === newTab.id);
+            if (!tabRef) return;
+
+            // 使用 tabRef 更新，确保操作的是响应式对象内的属性
+            tabRef.isLoading = true;
+            tabRef.loadingError = null;
+
+            try {
+                const sftpManager = getOrCreateSftpManager(sessionId, 'primary-editor'); // 使用特定实例 ID
+                if (!sftpManager) {
+                    throw new Error(t('fileManager.errors.sftpManagerNotFound'));
+                }
+                console.log(`[EditorActions ${sessionId}] 使用 primary-editor sftpManager 读取文件 ${fileInfo.fullPath}`);
+
+                const fileData: SftpReadFileSuccessPayload = await sftpManager.readFile(fileInfo.fullPath);
+                console.log(`[EditorActions ${sessionId}] 文件 ${fileInfo.fullPath} 读取成功。后端使用编码: ${fileData.encodingUsed}`);
+
+                // 再次查找 tab，因为它可能在异步操作期间被关闭
+                const currentTabState = session.editorTabs.value.find(t => t.id === newTab.id);
+                if (!currentTabState) return;
+
+                const initialContent = decodeRawContent(fileData.rawContentBase64, fileData.encodingUsed);
+                currentTabState.content = initialContent;
+                currentTabState.originalContent = initialContent;
+                currentTabState.rawContentBase64 = fileData.rawContentBase64;
+                currentTabState.selectedEncoding = fileData.encodingUsed;
+                currentTabState.isLoading = false;
+                currentTabState.isModified = false;
+                currentTabState.loadingError = null;
+                console.log(`[EditorActions ${sessionId}] 文件 ${fileInfo.fullPath} 内容已加载并设置到标签页 ${newTab.id}。`);
+
+            } catch (err: any) {
+                console.error(`[EditorActions ${sessionId}] 读取文件 ${fileInfo.fullPath} 失败:`, err);
+                const errorTabRef = session.editorTabs.value.find(t => t.id === newTab.id);
+                if (errorTabRef) {
+                    errorTabRef.isLoading = false;
+                    errorTabRef.loadingError = `${t('fileManager.errors.readFileFailed')}: ${err.message || err}`;
+                    errorTabRef.content = `// 加载错误: ${err.message || err}`;
+                }
+            }
+        };
+        loadContent();
+    }
+};
+
+export const closeEditorTabInSession = (sessionId: string, tabId: string) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[EditorActions] 尝试在不存在的会话 ${sessionId} 中关闭标签页 ${tabId}`);
+        return;
+    }
+
+    const tabIndex = session.editorTabs.value.findIndex(tab => tab.id === tabId);
+    if (tabIndex === -1) {
+        console.warn(`[EditorActions] 尝试关闭会话 ${sessionId} 中不存在的标签页 ID: ${tabId}`);
+        return;
+    }
+
+    // TODO: 检查 isDirty 状态，提示保存？
+
+    session.editorTabs.value.splice(tabIndex, 1);
+    console.log(`[EditorActions] 已从会话 ${sessionId} 中移除标签页: ${tabId}`);
+
+    if (session.activeEditorTabId.value === tabId) {
+        const remainingTabs = session.editorTabs.value;
+        const nextActiveTabId = remainingTabs.length > 0
+            ? remainingTabs[Math.max(0, tabIndex > 0 ? tabIndex -1 : 0 )].id // 激活前一个或第一个
+            : null;
+        session.activeEditorTabId.value = nextActiveTabId;
+        console.log(`[EditorActions] 会话 ${sessionId} 关闭活动标签页后，切换到: ${nextActiveTabId}`);
+    }
+};
+
+export const setActiveEditorTabInSession = (sessionId: string, tabId: string) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[EditorActions] 尝试在不存在的会话 ${sessionId} 中激活标签页 ${tabId}`);
+        return;
+    }
+
+    if (session.editorTabs.value.some(tab => tab.id === tabId)) {
+        if (session.activeEditorTabId.value !== tabId) {
+            session.activeEditorTabId.value = tabId;
+            console.log(`[EditorActions] 已在会话 ${sessionId} 中激活标签页: ${tabId}`);
+        }
+    } else {
+        console.warn(`[EditorActions] 尝试激活会话 ${sessionId} 中不存在的标签页 ID: ${tabId}`);
+    }
+};
+
+export const updateFileContentInSession = (sessionId: string, tabId: string, newContent: string) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[EditorActions] 尝试在不存在的会话 ${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(`[EditorActions] 尝试更新正在加载的标签页 ${tabId} 的内容`);
+    } else {
+        console.warn(`[EditorActions] 尝试更新会话 ${sessionId} 中不存在的标签页 ${tabId} 的内容`);
+    }
+};
+
+export const saveFileInSession = async (
+    sessionId: string,
+    tabId: string,
+    dependencies: {
+        getOrCreateSftpManager: (sessionId: string, instanceId: string) => SftpManagerInstance | null;
+        t: ReturnType<typeof useI18n>['t'];
+    }
+) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[EditorActions] 尝试在不存在的会话 ${sessionId} 中保存标签页 ${tabId}`);
+        return;
+    }
+    const tab = session.editorTabs.value.find(t => t.id === tabId);
+    if (!tab) {
+        console.warn(`[EditorActions] 尝试保存在会话 ${sessionId} 中不存在的标签页 ${tabId}`);
+        return;
+    }
+    const { getOrCreateSftpManager, t } = dependencies;
+
+    if (tab.isSaving || tab.isLoading || tab.loadingError || !tab.isModified) {
+        console.warn(`[EditorActions] 保存条件不满足 for ${tab.filePath} (会话 ${sessionId})，无法保存。`, { tab });
+        return;
+    }
+
+    if (!session.wsManager.isConnected.value || !session.wsManager.isSftpReady.value) {
+        console.error(`[EditorActions] 保存失败：会话 ${sessionId} 无效或未连接/SFTP 未就绪。`);
+        tab.saveStatus = 'error';
+        tab.saveError = t('fileManager.errors.sessionInvalidOrNotReady');
+        setTimeout(() => { if (tab.saveStatus === 'error') { tab.saveStatus = 'idle'; tab.saveError = null; } }, 5000);
+        return;
+    }
+
+    const sftpManager = getOrCreateSftpManager(sessionId, 'primary-editor');
+    if (!sftpManager) {
+        console.error(`[EditorActions] 保存失败：无法获取会话 ${sessionId} 的 primary-editor 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(`[EditorActions] 开始保存文件: ${tab.filePath} (会话 ${sessionId}, Tab ID: ${tab.id}) using primary-editor sftpManager`);
+    tab.isSaving = true;
+    tab.saveStatus = 'saving';
+    tab.saveError = null;
+
+    const contentToSave = tab.content;
+    const encodingToUse = tab.selectedEncoding;
+
+    try {
+        await sftpManager.writeFile(tab.filePath, contentToSave, encodingToUse);
+        console.log(`[EditorActions] 文件 ${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(`[EditorActions] 保存文件 ${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);
+    }
+};
+
+export const changeEncodingInSession = (sessionId: string, tabId: string, newEncoding: string) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.warn(`[EditorActions] 尝试更改不存在的会话 ${sessionId} 中标签页 ${tabId} 的编码。`);
+        return;
+    }
+    const tab = session.editorTabs.value.find(t => t.id === tabId);
+    if (!tab) {
+        console.warn(`[EditorActions] 尝试更改会话 ${sessionId} 中不存在的标签页 ${tabId} 的编码。`);
+        return;
+    }
+
+    if (!tab.rawContentBase64) {
+        console.error(`[EditorActions] 无法更改编码：会话 ${sessionId} 标签页 ${tabId} 没有原始文件数据。`);
+        tab.isLoading = false; // 应该已经是 false，但确保
+        tab.loadingError = '缺少原始文件数据，无法更改编码';
+        return;
+    }
+    if (tab.selectedEncoding === newEncoding) {
+        console.log(`[EditorActions] 会话 ${sessionId} 标签页 ${tabId} 编码已经是 ${newEncoding}，无需更改。`);
+        return;
+    }
+
+    console.log(`[EditorActions] 使用新编码 "${newEncoding}" 在前端重新解码文件: ${tab.filePath} (会话 ${sessionId}, Tab ID: ${tabId})`);
+
+    try {
+        const newContent = decodeRawContent(tab.rawContentBase64, newEncoding);
+        tab.content = newContent;
+        tab.selectedEncoding = newEncoding;
+        // tab.isModified 状态取决于新内容是否与 originalContent 不同，或者用户可能希望将更改编码视为“修改”
+        // 这里我们假设仅更改编码预览不直接标记为 isModified，除非内容实际变化
+        // 如果 newContent === tab.originalContent，isModified 可以保持不变或设为 false
+        // 如果 newContent !== tab.originalContent，isModified 应该为 true
+        // 为了简单起见，这里不改变 isModified，由后续的 content 比较来决定
+        tab.loadingError = null; // 清除可能存在的旧错误
+        console.log(`[EditorActions] 文件 ${tab.filePath} (会话 ${sessionId}) 使用新编码 "${newEncoding}" 解码完成。`);
+    } catch (err: any) {
+        console.error(`[EditorActions] 使用编码 "${newEncoding}" 在前端解码文件 ${tab.filePath} (会话 ${sessionId}) 失败:`, err);
+        tab.loadingError = `前端解码失败 (编码: ${newEncoding}): ${err.message || err}`;
+    }
+};
+
+export const closeOtherTabsInSession = (sessionId: string, targetTabId: string) => {
+    const session = sessions.value.get(sessionId);
+    if (!session) return;
+    const targetTab = session.editorTabs.value.find(tab => tab.id === targetTabId);
+    if (!targetTab) return;
+
+    console.log(`[EditorActions ${sessionId}] 关闭除 ${targetTabId} 之外的所有标签页...`);
+    const tabsToClose = session.editorTabs.value.filter(tab => tab.id !== targetTabId);
+    // 为了避免在迭代中修改数组导致的问题，先收集 ID
+    const idsToClose = tabsToClose.map(t => t.id);
+    idsToClose.forEach(id => closeEditorTabInSession(sessionId, id));
+};
+
+export 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(`[EditorActions ${sessionId}] 关闭 ${targetTabId} 右侧的所有标签页...`);
+    const tabsToClose = session.editorTabs.value.slice(targetIndex + 1);
+    const idsToClose = tabsToClose.map(t => t.id);
+    idsToClose.forEach(id => closeEditorTabInSession(sessionId, id));
+};
+
+export 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(`[EditorActions ${sessionId}] 关闭 ${targetTabId} 左侧的所有标签页...`);
+    const tabsToClose = session.editorTabs.value.slice(0, targetIndex);
+    const idsToClose = tabsToClose.map(t => t.id);
+    idsToClose.forEach(id => closeEditorTabInSession(sessionId, id));
+};
@@ -0,0 +1,30 @@
+// packages/frontend/src/stores/session/actions/modalActions.ts
+
+import { isRdpModalOpen, rdpConnectionInfo, isVncModalOpen, vncConnectionInfo } from '../state';
+import type { ConnectionInfo } from '../../connections.store'; // 路径: packages/frontend/src/stores/connections.store.ts
+
+// --- RDP Modal Actions ---
+export const openRdpModal = (connection: ConnectionInfo) => {
+  // console.log(`[ModalActions] Opening RDP modal for connection: ${connection.name} (ID: ${connection.id})`);
+  rdpConnectionInfo.value = connection;
+  isRdpModalOpen.value = true;
+};
+
+export const closeRdpModal = () => {
+  // console.log('[ModalActions] Closing RDP modal.');
+  isRdpModalOpen.value = false;
+  rdpConnectionInfo.value = null; // 清除连接信息
+};
+
+// --- VNC Modal Actions ---
+export const openVncModal = (connection: ConnectionInfo) => {
+  // console.log(`[ModalActions] Opening VNC modal for connection: ${connection.name} (ID: ${connection.id})`);
+  vncConnectionInfo.value = connection;
+  isVncModalOpen.value = true;
+};
+
+export const closeVncModal = () => {
+  // console.log('[ModalActions] Closing VNC modal.');
+  isVncModalOpen.value = false;
+  vncConnectionInfo.value = null; // 清除连接信息
+};
@@ -0,0 +1,215 @@
+// packages/frontend/src/stores/session/actions/sessionActions.ts
+
+import { ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useConnectionsStore, type ConnectionInfo } from '../../connections.store'; // 路径: packages/frontend/src/stores/connections.store.ts
+import { sessions, activeSessionId } from '../state';
+import { generateSessionId } from '../utils';
+import type { SessionState, SshTerminalInstance, StatusMonitorInstance, DockerManagerInstance, SftpManagerInstance } from '../types';
+
+// Composables for manager creation - 路径相对于此文件
+import { createWebSocketConnectionManager } from '../../../composables/useWebSocketConnection';
+import { createSshTerminalManager, type SshTerminalDependencies } from '../../../composables/useSshTerminal';
+import { createStatusMonitorManager, type StatusMonitorDependencies } from '../../../composables/useStatusMonitor';
+import { createDockerManager, type DockerManagerDependencies } from '../../../composables/useDockerManager';
+// getOrCreateSftpManager 将在 sftpManagerActions.ts 中定义，并在主 store 中协调
+
+// --- 辅助函数 (特定于此模块的 actions) ---
+const findConnectionInfo = (connectionId: number | string, connectionsStore: ReturnType<typeof useConnectionsStore>): ConnectionInfo | undefined => {
+  return connectionsStore.connections.find(c => c.id === Number(connectionId));
+};
+
+// --- Actions ---
+export const openNewSession = (
+    connectionId: number | string,
+    dependencies: {
+        connectionsStore: ReturnType<typeof useConnectionsStore>;
+        t: ReturnType<typeof useI18n>['t'];
+    }
+) => {
+  const { connectionsStore, t } = dependencies;
+  console.log(`[SessionActions] 请求打开新会话: ${connectionId}`);
+  const connInfo = findConnectionInfo(connectionId, connectionsStore);
+  if (!connInfo) {
+    console.error(`[SessionActions] 无法打开新会话：找不到 ID 为 ${connectionId} 的连接信息。`);
+    // TODO: 向用户显示错误
+    return;
+  }
+
+  const newSessionId = generateSessionId();
+  const dbConnId = String(connInfo.id);
+
+  // 1. 创建管理器实例
+  const wsManager = createWebSocketConnectionManager(newSessionId, dbConnId, t);
+  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);
+  const dockerManagerDeps: DockerManagerDependencies = {
+      sendMessage: wsManager.sendMessage,
+      onMessage: wsManager.onMessage,
+      isConnected: wsManager.isConnected,
+  };
+  const dockerManager = createDockerManager(newSessionId, dockerManagerDeps, { t });
+
+  // 2. 创建 SessionState 对象
+  const newSession: SessionState = {
+      sessionId: newSessionId,
+      connectionId: dbConnId,
+      connectionName: connInfo.name || connInfo.host,
+      wsManager: wsManager,
+      sftpManagers: new Map<string, SftpManagerInstance>(), // 初始化 Map
+      terminalManager: terminalManager,
+      statusMonitorManager: statusMonitorManager,
+      dockerManager: dockerManager,
+      editorTabs: ref([]),
+      activeEditorTabId: ref(null),
+      commandInputContent: ref(''),
+  };
+
+  // 3. 添加到 Map 并激活
+  const newSessionsMap = new Map(sessions.value);
+  newSessionsMap.set(newSessionId, newSession);
+  sessions.value = newSessionsMap;
+  activeSessionId.value = newSessionId;
+  console.log(`[SessionActions] 已创建新会话实例: ${newSessionId} for connection ${dbConnId}`);
+
+  // 4. 启动 WebSocket 连接
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const wsHostAndPort = window.location.host;
+  const wsUrl = `${protocol}//${wsHostAndPort}/ws/`;
+  console.log(`[SessionActions] Generated WebSocket URL: ${wsUrl}`);
+  wsManager.connect(wsUrl);
+  console.log(`[SessionActions] 已为会话 ${newSessionId} 启动 WebSocket 连接。`);
+};
+
+export const activateSession = (sessionId: string) => {
+  if (sessions.value.has(sessionId)) {
+    if (activeSessionId.value !== sessionId) {
+      activeSessionId.value = sessionId;
+      console.log(`[SessionActions] 已激活会话: ${sessionId}`);
+    } else {
+      console.log(`[SessionActions] 会话 ${sessionId} 已经是活动状态。`);
+    }
+  } else {
+    console.warn(`[SessionActions] 尝试激活不存在的会话 ID: ${sessionId}`);
+  }
+};
+
+export const closeSession = (sessionId: string) => {
+  console.log(`[SessionActions] 请求关闭会话 ID: ${sessionId}`);
+  const sessionToClose = sessions.value.get(sessionId);
+  if (!sessionToClose) {
+    console.warn(`[SessionActions] 尝试关闭不存在的会话 ID: ${sessionId}`);
+    return;
+  }
+
+  // 1. 调用实例上的清理和断开方法
+  sessionToClose.wsManager.disconnect();
+  console.log(`[SessionActions] 已为会话 ${sessionId} 调用 wsManager.disconnect()`);
+  sessionToClose.sftpManagers.forEach((manager, instanceId) => {
+      manager.cleanup();
+      console.log(`[SessionActions] 已为会话 ${sessionId} 的 sftpManager (实例 ${instanceId}) 调用 cleanup()`);
+  });
+  sessionToClose.sftpManagers.clear();
+  sessionToClose.terminalManager.cleanup();
+  console.log(`[SessionActions] 已为会话 ${sessionId} 调用 terminalManager.cleanup()`);
+  sessionToClose.statusMonitorManager.cleanup();
+  console.log(`[SessionActions] 已为会话 ${sessionId} 调用 statusMonitorManager.cleanup()`);
+  sessionToClose.dockerManager.cleanup();
+  console.log(`[SessionActions] 已为会话 ${sessionId} 调用 dockerManager.cleanup()`);
+
+  // 2. 从 Map 中移除会话
+  const newSessionsMap = new Map(sessions.value);
+  newSessionsMap.delete(sessionId);
+  sessions.value = newSessionsMap;
+  console.log(`[SessionActions] 已从 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(`[SessionActions] 关闭活动会话后，切换到: ${nextActiveId}`);
+  }
+};
+
+export const handleConnectRequest = (
+    connection: ConnectionInfo,
+    dependencies: {
+        connectionsStore: ReturnType<typeof useConnectionsStore>;
+        router: ReturnType<typeof useRouter>;
+        openRdpModalAction: (connection: ConnectionInfo) => void; // 来自 modalActions
+        openVncModalAction: (connection: ConnectionInfo) => void; // 来自 modalActions
+        t: ReturnType<typeof useI18n>['t'];
+    }
+) => {
+  const { connectionsStore, router, openRdpModalAction, openVncModalAction, t } = dependencies;
+
+  if (connection.type === 'RDP') {
+    openRdpModalAction(connection);
+  } else if (connection.type === 'VNC') {
+    openVncModalAction(connection);
+  } else {
+    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(`[SessionActions] 点击的是当前活动会话 ${activeSessionId.value}，状态: ${currentStatus}`);
+        if (currentStatus === 'disconnected' || currentStatus === 'error') {
+          activeAndDisconnected = true;
+          console.log(`[SessionActions] 活动会话 ${activeSessionId.value} 已断开或出错，尝试重连...`);
+          const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+          const wsHostAndPort = window.location.host;
+          const wsUrl = `${protocol}//${wsHostAndPort}/ws/`;
+          console.log(`[SessionActions handleConnectRequest] Generated WebSocket URL for reconnect: ${wsUrl}`);
+          currentActiveSession.wsManager.connect(wsUrl);
+          activateSession(activeSessionId.value);
+          router.push({ name: 'Workspace' });
+        }
+      }
+    }
+
+    if (!activeAndDisconnected) {
+      console.log(`[SessionActions] 不满足重连条件或点击了其他连接，将打开新会话 for ID: ${connIdStr}`);
+      openNewSession(connIdStr, { connectionsStore, t });
+      router.push({ name: 'Workspace' });
+    }
+  }
+};
+
+export const handleOpenNewSession = (
+    connectionId: number | string,
+    dependencies: {
+        connectionsStore: ReturnType<typeof useConnectionsStore>;
+        t: ReturnType<typeof useI18n>['t'];
+    }
+) => {
+  console.log(`[SessionActions] handleOpenNewSession called for ID: ${connectionId}`);
+  openNewSession(connectionId, dependencies);
+};
+
+export const cleanupAllSessions = () => {
+  console.log('[SessionActions] 清理所有会话...');
+  sessions.value.forEach((_session, sessionId) => {
+    closeSession(sessionId);
+  });
+  // sessions.value.clear(); // closeSession 内部会逐个删除，这里不需要重复clear，但确认Map为空
+  if (sessions.value.size > 0) { // 以防万一
+    const newSessionsMap = new Map(sessions.value);
+    newSessionsMap.clear();
+    sessions.value = newSessionsMap;
+  }
+  activeSessionId.value = null;
+};
@@ -0,0 +1,49 @@
+// packages/frontend/src/stores/session/actions/sftpManagerActions.ts
+
+import { ref } from 'vue';
+import { sessions } from '../state';
+import type { SftpManagerInstance } from '../types';
+import { createSftpActionsManager, type WebSocketDependencies } from '../../../composables/useSftpActions'; // 路径: packages/frontend/src/composables/useSftpActions.ts
+import type { useI18n } from 'vue-i18n';
+
+export const getOrCreateSftpManager = (
+    sessionId: string,
+    instanceId: string,
+    dependencies: {
+        t: ReturnType<typeof useI18n>['t'];
+    }
+): SftpManagerInstance | null => {
+    const session = sessions.value.get(sessionId);
+    if (!session) {
+        console.error(`[SftpManagerActions] 尝试为不存在的会话 ${sessionId} 获取 SFTP 管理器`);
+        return null;
+    }
+    const { t } = dependencies;
+
+    let manager = session.sftpManagers.get(instanceId);
+    if (!manager) {
+        console.log(`[SftpManagerActions] 为会话 ${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;
+};
+
+export 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(`[SftpManagerActions] 已移除并清理会话 ${sessionId} 的 SFTP 管理器实例: ${instanceId}`);
+        }
+    }
+};
@@ -0,0 +1,26 @@
+// packages/frontend/src/stores/session/getters.ts
+
+import { computed } from 'vue';
+import { sessions, activeSessionId } from './state';
+import type { SessionState, SessionTabInfoWithStatus } from './types';
+
+export const sessionTabs = computed(() => {
+  return Array.from(sessions.value.values()).map(session => ({
+    sessionId: session.sessionId,
+    connectionName: session.connectionName,
+  }));
+});
+
+// 包含状态的标签页信息
+export const sessionTabsWithStatus = computed((): SessionTabInfoWithStatus[] => {
+  return Array.from(sessions.value.values()).map(session => ({
+    sessionId: session.sessionId,
+    connectionName: session.connectionName,
+    status: session.wsManager.connectionStatus.value, // 从 wsManager 获取状态
+  }));
+});
+
+export const activeSession = computed((): SessionState | null => {
+  if (!activeSessionId.value) return null;
+  return sessions.value.get(activeSessionId.value) || null;
+});
@@ -0,0 +1,18 @@
+// packages/frontend/src/stores/session/state.ts
+
+import { ref, shallowRef } from 'vue';
+import type { SessionState } from './types';
+// 修正导入路径
+import type { ConnectionInfo } from '../connections.store'; // 路径: packages/frontend/src/stores/connections.store.ts
+
+// 使用 shallowRef 避免深度响应性问题，保留管理器实例内部的响应性
+export const sessions = shallowRef<Map<string, SessionState>>(new Map());
+export const activeSessionId = ref<string | null>(null);
+
+// --- RDP Modal State ---
+export const isRdpModalOpen = ref(false);
+export const rdpConnectionInfo = ref<ConnectionInfo | null>(null);
+
+// --- VNC Modal State ---
+export const isVncModalOpen = ref(false);
+export const vncConnectionInfo = ref<ConnectionInfo | null>(null);
@@ -0,0 +1,51 @@
+// packages/frontend/src/stores/session/types.ts
+
+import type { Ref } from 'vue';
+import type { FileTab as OriginalFileTab } from '../fileEditor.store'; // 路径: packages/frontend/src/stores/fileEditor.store.ts
+import type { WsConnectionStatus } from '../../composables/useWebSocketConnection'; // 路径: packages/frontend/src/composables/useWebSocketConnection.ts
+
+// 从源模块导入 DockerManagerInstance 类型并使用别名
+import type { DockerManagerInstance as OriginalDockerManagerInstance } from '../../composables/useDockerManager'; // 路径: packages/frontend/src/composables/useDockerManager.ts
+
+// 导入工厂函数仅用于通过 ReturnType 推导实例类型
+// 这些导入仅用于类型推断，不在运行时使用
+import type { createWebSocketConnectionManager } from '../../composables/useWebSocketConnection';
+import type { createSftpActionsManager } from '../../composables/useSftpActions';
+import type { createSshTerminalManager } from '../../composables/useSshTerminal';
+import type { createStatusMonitorManager } from '../../composables/useStatusMonitor';
+
+
+// 使用 ReturnType 定义其他管理器实例类型
+export type WsManagerInstance = ReturnType<typeof createWebSocketConnectionManager>;
+export type SftpManagerInstance = ReturnType<typeof createSftpActionsManager>;
+export type SshTerminalInstance = ReturnType<typeof createSshTerminalManager>;
+export type StatusMonitorInstance = ReturnType<typeof createStatusMonitorManager>;
+
+// 为 DockerManagerInstance 创建一个本地类型别名，并导出它
+export type DockerManagerInstance = OriginalDockerManagerInstance;
+
+// 重新导出 FileTab 类型，使其可用于其他模块
+export type FileTab = OriginalFileTab;
+
+export interface SessionState {
+  sessionId: string;
+  connectionId: string; // 数据库中的连接 ID
+  connectionName: string; // 用于显示
+  wsManager: WsManagerInstance;
+  sftpManagers: Map<string, SftpManagerInstance>; // 使用 Map 管理多个实例
+  terminalManager: SshTerminalInstance;
+  statusMonitorManager: StatusMonitorInstance;
+  dockerManager: DockerManagerInstance; // 现在应该可以找到 DockerManagerInstance
+  // --- 新增：独立编辑器状态 ---
+  editorTabs: Ref<FileTab[]>; // 编辑器标签页列表
+  activeEditorTabId: Ref<string | null>; // 当前活动的编辑器标签页 ID
+  // --- 新增：命令输入框内容 ---
+  commandInputContent: Ref<string>; // 当前会话的命令输入框内容
+}
+
+// 为标签栏定义包含状态的类型
+export interface SessionTabInfoWithStatus {
+  sessionId: string;
+  connectionName: string;
+  status: WsConnectionStatus; // 添加状态字段
+}
@@ -0,0 +1,80 @@
+// packages/frontend/src/stores/session/utils.ts
+
+import * as iconv from '@vscode/iconv-lite-umd';
+import { Buffer } from 'buffer/';
+
+/**
+ * 生成唯一的会话 ID。
+ * @returns {string} 新的会话 ID。
+ */
+export function generateSessionId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+
+/**
+ * 根据文件名获取 Monaco Editor 对应的语言标识符。
+ * @param {string} filename - 文件名。
+ * @returns {string} 语言标识符，默认为 'plaintext'。
+ */
+export 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';
+    }
+};
+
+/**
+ * 使用指定的编码解码 Base64 编码的原始文件内容。
+ * @param {string} rawContentBase64 - Base64 编码的原始文件内容。
+ * @param {string} encoding - 用于解码的字符编码。
+ * @returns {string} 解码后的文件内容。如果解码失败，则返回错误信息。
+ */
+export const decodeRawContent = (rawContentBase64: string, encoding: string): string => {
+    try {
+        const buffer = Buffer.from(rawContentBase64, 'base64');
+        const normalizedEncoding = encoding.toLowerCase().replace(/[^a-z0-9]/g, ''); // 标准化编码名称
+
+        // 优先使用 TextDecoder 处理标准编码
+        if (['utf8', 'utf16le', 'utf16be'].includes(normalizedEncoding)) {
+            const decoder = new TextDecoder(encoding); // TextDecoder 使用原始编码名称
+            return decoder.decode(buffer);
+        }
+        // 使用 iconv-lite 处理其他编码
+        else if (iconv.encodingExists(normalizedEncoding)) {
+            return iconv.decode(buffer, normalizedEncoding);
+        }
+        // 如果 iconv-lite 也不支持，回退到 UTF-8 并警告
+        else {
+            console.warn(`[SessionUtils 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(`[SessionUtils decodeRawContent] Error decoding content with encoding "${encoding}":`, error);
+        return `// Error decoding content: ${error.message}`; // 返回错误信息
+    }
+};