admin/nexus-terminal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 完成修改挂起会话名称的功能

Browse Source
This commit is contained in:
Baobhan Sith
2025-05-10 09:44:53 +08:00
parent bf8124bb35
commit 05747a46e1
7 changed files with 192 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/backend/src/services/ssh-suspend.service.ts
+40 -14
View File
@@ -62,12 +62,14 @@ export class SshSuspendService extends EventEmitter {
logIdentifier,
customSuspendName,
} = details;
console.log(`[SshSuspendService DEBUG] takeOverMarkedSession: Called for userId=${userId}, originalSessionId=${originalSessionId}`);
// 检查 SSH client 和 channel 是否仍然可用
// ClientChannel 有 readable 和 writable, Client 本身没有直接的此类属性
// 如果 channel 不可读写，通常意味着底层连接有问题。
console.log(`[SshSuspendService DEBUG] takeOverMarkedSession: Checking channel for originalSessionId=${originalSessionId}. Readable: ${channel?.readable}, Writable: ${channel?.writable}`);
if (!channel || !channel.readable || !channel.writable) {
console.warn(`[用户: ${userId}] 尝试接管会话 ${originalSessionId} 时，SSH channel 已不可用 (readable: ${channel?.readable}, writable: ${channel?.writable})。将标记为已断开。`);
console.warn(`[SshSuspendService WARN] takeOverMarkedSession: userId=${userId}, originalSessionId=${originalSessionId}. SSH channel is not usable. readable=${channel?.readable}, writable=${channel?.writable}. Cannot take over.`);
// 确保如果 SSH 连接已经关闭，日志文件仍然保留，但不创建挂起条目。
// SshSuspendService 不会管理这个“已经断开”的会话，但日志保留供用户清理。
try { channel?.end(); } catch (e) { /* ignore */ }
@@ -101,50 +103,72 @@ export class SshSuspendService extends EventEmitter {
};
userSessions.set(suspendSessionId, sessionDetails);
console.log(`[用户: ${userId}] SSH会话 ${originalSessionId} 已被 SshSuspendService 接管 (新挂起ID: ${suspendSessionId})。日志文件标识: ${logIdentifier}`);
console.log(`[SshSuspendService INFO] takeOverMarkedSession: userId=${userId}, originalSessionId=${originalSessionId} taken over. New suspendSessionId=${suspendSessionId}, initial status=${sessionDetails.backendSshStatus}. Log identifier=${logIdentifier}`);
await this.logStorageService.ensureLogDirectoryExists();
console.log(`[SshSuspendService DEBUG] takeOverMarkedSession: Setting up channel 'data' listener for suspendSessionId=${suspendSessionId}`);
channel.on('data', (data: Buffer) => {
if (userSessions.get(suspendSessionId)?.backendSshStatus === 'hanging') {
const currentDetails = userSessions.get(suspendSessionId);
if (currentDetails?.backendSshStatus === 'hanging') {
// console.log(`[SshSuspendService DEBUG] channel.on('data') for suspendSessionId=${suspendSessionId}: Writing to log ${logIdentifier}`);
this.logStorageService.writeToLog(logIdentifier, data.toString('utf-8')).catch(err => {
console.error(`[用户: ${userId}, 挂起ID: ${suspendSessionId}, 日志: ${logIdentifier}] 写入挂起日志失败:`, err);
console.error(`[SshSuspendService ERROR] channel.on('data') for suspendSessionId=${suspendSessionId}, log=${logIdentifier}: Failed to write to log:`, err);
});
} else {
// console.log(`[SshSuspendService DEBUG] channel.on('data') for suspendSessionId=${suspendSessionId}: Backend status is ${currentDetails?.backendSshStatus}, not writing to log.`);
}
});
const handleSessionTermination = (reasonSuffix: string) => {
const currentSession = userSessions.get(suspendSessionId);
console.log(`[SshSuspendService DEBUG] handleSessionTermination: Called for suspendSessionId=${suspendSessionId}, reasonSuffix='${reasonSuffix}'. Session found: ${!!currentSession}. Current status: ${currentSession?.backendSshStatus}`);
if (currentSession && currentSession.backendSshStatus === 'hanging') {
const reason = `SSH connection ${reasonSuffix}.`;
console.warn(`[用户: ${userId}, 挂起ID: ${suspendSessionId}, 日志: ${logIdentifier}] SSH 连接在挂起期间终止。原因: ${reason}`);
console.warn(`[SshSuspendService WARN] handleSessionTermination: userId=${currentSession.userId}, suspendSessionId=${suspendSessionId}. SSH connection terminated during suspension. Reason: ${reason}`);
currentSession.backendSshStatus = 'disconnected_by_backend';
currentSession.disconnectionTimestamp = new Date().toISOString();
this.removeChannelListeners(channel, sshClient);
console.log(`[SshSuspendService DEBUG] handleSessionTermination: Listeners removed for suspendSessionId=${suspendSessionId}.`);
this.emit('sessionAutoTerminated', {
userId: currentSession.userId,
suspendSessionId,
reason
});
console.log(`[SshSuspendService INFO] handleSessionTermination: Emitted 'sessionAutoTerminated' for suspendSessionId=${suspendSessionId}, userId=${currentSession.userId}.`);
} else if (currentSession) {
console.log(`[SshSuspendService DEBUG] handleSessionTermination: Condition not met for suspendSessionId=${suspendSessionId}. Status was '${currentSession.backendSshStatus}', not 'hanging'. No action taken.`);
} else {
console.warn(`[SshSuspendService WARN] handleSessionTermination: Session not found for suspendSessionId=${suspendSessionId} when event '${reasonSuffix}' occurred.`);
}
};
channel.on('close', () => handleSessionTermination('closed'));
channel.on('error', (err: Error) => {
console.error(`[用户: ${userId}, 挂起ID: ${suspendSessionId}, 日志: ${logIdentifier}] 挂起会话的通道错误:`, err);
handleSessionTermination('errored');
console.log(`[SshSuspendService DEBUG] takeOverMarkedSession: Setting up channel/client event listeners for suspendSessionId=${suspendSessionId}`);
channel.on('close', () => {
console.log(`[SshSuspendService DEBUG] channel.on('close') triggered for suspendSessionId=${suspendSessionId}`);
handleSessionTermination('channel closed');
});
channel.on('error', (err: Error) => {
console.error(`[SshSuspendService ERROR] channel.on('error') for suspendSessionId=${suspendSessionId}:`, err);
handleSessionTermination('channel errored');
});
channel.on('end', () => {
console.log(`[SshSuspendService DEBUG] channel.on('end') triggered for suspendSessionId=${suspendSessionId}`);
handleSessionTermination('channel ended');
});
channel.on('exit', (code: number | null, signalName: string | null) => {
console.log(`[SshSuspendService DEBUG] channel.on('exit') triggered for suspendSessionId=${suspendSessionId}. Code: ${code}, Signal: ${signalName}`);
handleSessionTermination(`channel exited with code ${code}, signal ${signalName}`);
});
channel.on('end', () => handleSessionTermination('ended'));
channel.on('exit', (code: number | null, signalName: string | null) => handleSessionTermination(`exited with code ${code}, signal ${signalName}`));
sshClient.on('error', (err: Error) => {
console.error(`[用户: ${userId}, 挂起ID: ${suspendSessionId}, 日志: ${logIdentifier}] 挂起会话的SSH客户端错误:`, err);
console.error(`[SshSuspendService ERROR] sshClient.on('error') for suspendSessionId=${suspendSessionId}:`, err);
handleSessionTermination('client errored');
});
sshClient.on('end', () => {
console.log(`[用户: ${userId}, 挂起ID: ${suspendSessionId}, 日志: ${logIdentifier}] 挂起会话的SSH客户端连接结束。`);
console.log(`[SshSuspendService DEBUG] sshClient.on('end') triggered for suspendSessionId=${suspendSessionId}`);
handleSessionTermination('client ended');
});
@@ -167,11 +191,13 @@ export class SshSuspendService extends EventEmitter {
* @param userId 用户ID。
* @returns Promise<SuspendedSessionInfo[]> 挂起会话信息的数组。
*/
async listSuspendedSessions(userId: number): Promise<SuspendedSessionInfo[]> { // userId: string -> number
async listSuspendedSessions(userId: number): Promise<SuspendedSessionInfo[]> {
console.log(`[SshSuspendService DEBUG] listSuspendedSessions: Called for userId=${userId}`);
const userSessions = this.getUserSessions(userId);
const sessionsInfo: SuspendedSessionInfo[] = [];
for (const [suspendSessionId, details] of userSessions.entries()) {
console.log(`[SshSuspendService DEBUG] listSuspendedSessions: Processing suspendSessionId=${suspendSessionId}, status=${details.backendSshStatus}`);
sessionsInfo.push({
suspendSessionId,
connectionName: details.connectionName,
packages/backend/src/services/ssh.service.ts
+2 -2
View File
@@ -145,8 +145,8 @@ export const establishSshConnection = (
privateKey: connDetails.privateKey,
passphrase: connDetails.passphrase,
readyTimeout: timeout,
keepaliveInterval: 10000, // 保持连接
keepaliveCountMax: 10,
keepaliveInterval: 5000, // 修改：每 5 秒发送一次 keepalive
keepaliveCountMax: 5, // 修改：最多尝试 5 次 (总超时约 5*5=10 秒)
};
const readyHandler = async () => { // 改为 async 函数
packages/backend/src/ssh-suspend/ssh-suspend.controller.ts
+40 -1
View File
@@ -11,6 +11,7 @@ export class SshSuspendController {
this.getSuspendedSshSessions = this.getSuspendedSshSessions.bind(this);
this.terminateAndRemoveSession = this.terminateAndRemoveSession.bind(this);
this.removeSessionEntry = this.removeSessionEntry.bind(this);
this.editSessionNameHttp = this.editSessionNameHttp.bind(this); // 绑定新方法
}
public async getSuspendedSshSessions(req: Request, res: Response): Promise<void> {
@@ -104,4 +105,42 @@ export class SshSuspendController {
}
}
}
}
public async editSessionNameHttp(req: Request, res: Response): Promise<void> {
try {
const userId = req.session.userId;
const { suspendSessionId } = req.params;
const { customName } = req.body; // 从请求体获取新名称
if (!userId) {
res.status(401).json({ message: 'Unauthorized. User ID not found in session.' });
return;
}
if (!suspendSessionId) {
res.status(400).json({ message: 'Bad Request. suspendSessionId parameter is missing.' });
return;
}
if (typeof customName !== 'string') { // 验证 customName
res.status(400).json({ message: 'Bad Request. customName must be a string and is missing or invalid.' });
return;
}
console.log(`[SshSuspendController] editSessionNameHttp called for user ID: ${userId}, suspendSessionId: ${suspendSessionId}, newName: "${customName}"`);
const success = await sshSuspendService.editSuspendedSessionName(userId, suspendSessionId, customName);
if (success) {
res.status(200).json({ message: `Suspended session ${suspendSessionId} name updated to "${customName}".`, customName });
} else {
// 假设服务层在找不到会话时返回 false
res.status(404).json({ message: `Failed to update name for session ${suspendSessionId}. It might not exist.` });
}
} catch (error) {
console.error(`[SshSuspendController] Error editing session name for user ID: ${req.session.userId}, suspendSessionId: ${req.params.suspendSessionId}:`, error);
if (error instanceof Error) {
res.status(500).json({ message: 'Failed to edit suspended session name', error: error.message });
} else {
res.status(500).json({ message: 'Failed to edit suspended session name', error: 'Unknown error' });
}
}
}
}
packages/backend/src/ssh-suspend/ssh-suspend.routes.ts
+7
View File
@@ -27,4 +27,11 @@ router.delete(
sshSuspendController.removeSessionEntry
);
// Route to edit a suspended session's custom name
router.put(
'/name/:suspendSessionId',
isAuthenticated,
sshSuspendController.editSessionNameHttp // 新的控制器方法
);
export default router;
packages/backend/src/websocket/connection.ts
+3 -22
View File
@@ -7,14 +7,14 @@ import {
SshSuspendResumeRequest,
SshSuspendTerminateRequest,
SshSuspendRemoveEntryRequest,
SshSuspendEditNameRequest,
// SshSuspendEditNameRequest, // Removed as it's now HTTP
SshSuspendStartedResponse,
SshSuspendListResponse,
SshSuspendResumedNotification,
SshOutputCachedChunk,
SshSuspendTerminatedResponse,
SshSuspendEntryRemovedResponse,
SshSuspendNameEditedResponse,
// SshSuspendNameEditedResponse, // Removed as it's now HTTP
SshSuspendAutoTerminatedNotification,
SshMarkForSuspendRequest,
SshMarkedForSuspendAck,
@@ -296,26 +296,7 @@ export function initializeConnectionHandler(wss: WebSocketServer, sshSuspendServ
}
break;
}
case 'SSH_SUSPEND_EDIT_NAME': {
const { suspendSessionId, customName } = payload as SshSuspendEditNameRequest['payload'];
if (!ws.userId) {
console.error(`[SSH_SUSPEND_EDIT_NAME] 用户 ID 未定义。`);
if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'SSH_SUSPEND_NAME_EDITED_RESP', payload: { suspendSessionId, success: false, error: '用户认证失败' } }));
break;
}
try {
const success = await sshSuspendService.editSuspendedSessionName(ws.userId, suspendSessionId, customName);
const response: SshSuspendNameEditedResponse = {
type: 'SSH_SUSPEND_NAME_EDITED',
payload: { suspendSessionId, success, customName: success ? customName : undefined }
};
if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(response));
} catch (error: any) {
console.error(`[SSH_SUSPEND_EDIT_NAME] 编辑名称 ${suspendSessionId} 失败:`, error);
if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'SSH_SUSPEND_NAME_EDITED_RESP', payload: { suspendSessionId, success: false, error: error.message || '编辑名称失败' } }));
}
break;
}
// SSH_SUSPEND_EDIT_NAME case removed, handled by HTTP API now
case 'SSH_MARK_FOR_SUSPEND': {
const markPayload = payload as SshMarkForSuspendRequest['payload'];
const sessionToMarkId = markPayload.sessionId;
packages/frontend/src/stores/session/actions/sshSuspendActions.ts
+41 -38
View File
@@ -8,7 +8,7 @@ import type {
SshSuspendResumeReqMessage,
SshSuspendTerminateReqMessage,
SshSuspendRemoveEntryReqMessage,
SshSuspendEditNameReqMessage,
// SshSuspendEditNameReqMessage, // Removed, using HTTP API
// S2C Payloads
SshMarkedForSuspendAckPayload,
SshUnmarkedForSuspendAckPayload, // +++ 新增导入 +++
@@ -17,10 +17,10 @@ import type {
SshOutputCachedChunkPayload,
SshSuspendTerminatedRespPayload,
SshSuspendEntryRemovedRespPayload,
SshSuspendNameEditedRespPayload,
// SshSuspendNameEditedRespPayload, // Removed, using HTTP API
SshSuspendAutoTerminatedNotifPayload,
} from '../../../types/websocket.types'; // 路径: packages/frontend/src/types/websocket.types.ts
import type { WsManagerInstance, SessionState } from '../types'; // 路径: packages/frontend/src/stores/session/types.ts
import type { WsManagerInstance, SessionState } from '../types'; // 路径: packages/frontend/src/stores/session/types.ts // Re-add WsManagerInstance
import { closeSession as closeSessionAction, activateSession as activateSessionAction, openNewSession, closeSession } from './sessionActions'; // 使用 openNewSession 和 closeSession
import { useConnectionsStore } from '../../connections.store'; // 用于获取连接信息
import { useUiNotificationsStore } from '../../uiNotifications.store'; // 用于显示通知
@@ -325,21 +325,43 @@ export const removeSshSessionEntry = async (suspendSessionId: string): Promise<v
};
/**
* 请求编辑挂起 SSH 会话的自定义名称
* 请求编辑挂起 SSH 会话的自定义名称 (通过 HTTP API)
* @param suspendSessionId 要编辑的挂起会话 ID
* @param customName 新的自定义名称
* @param newCustomName 新的自定义名称
*/
export const editSshSessionName = (suspendSessionId: string, customName: string): void => {
const wsManager = getActiveWsManager();
if (wsManager) {
const message: SshSuspendEditNameReqMessage = {
type: 'SSH_SUSPEND_EDIT_NAME',
payload: { suspendSessionId, customName },
};
wsManager.sendMessage(message);
console.log(`[${t('term.sshSuspend')}] 已发送 SSH_SUSPEND_EDIT_NAME_REQ (挂起 ID: ${suspendSessionId}, 名称: "${customName}")`);
} else {
console.warn(`[${t('term.sshSuspend')}] 编辑挂起名称失败 (挂起 ID: ${suspendSessionId})：无可用 WebSocket 连接。`);
export const editSshSessionName = async (suspendSessionId: string, newCustomName: string): Promise<void> => {
console.log(`[${t('term.sshSuspend')}] 请求通过 HTTP API 编辑挂起会话名称 (ID: ${suspendSessionId}, 新名称: "${newCustomName}")`);
const uiNotificationsStore = useUiNotificationsStore();
try {
// 假设后端 API 端点为 /api/ssh-suspend/name/:suspendSessionId
// 并且它接受一个包含 { customName: string } 的 PUT 请求体
// 并返回包含 { message: string, customName: string } 的成功响应
const response = await apiClient.put<{ message: string, customName: string }>(
`ssh-suspend/name/${suspendSessionId}`,
{ customName: newCustomName }
);
console.log(`[${t('term.sshSuspend')}] HTTP API 编辑名称 ${suspendSessionId} 成功:`, response.data);
// 更新前端状态
const session = suspendedSshSessions.value.find(s => s.suspendSessionId === suspendSessionId);
if (session) {
session.customSuspendName = response.data.customName; // 使用后端返回的名称确保一致性
uiNotificationsStore.addNotification({
type: 'success',
message: t('sshSuspend.notifications.nameEditedSuccess', { name: response.data.customName }),
});
} else {
// 如果会话在前端列表中找不到了（理论上不应该发生，因为是先找到再编辑的）
// 也可以选择重新获取列表
fetchSuspendedSshSessions();
}
} catch (error: any) {
console.error(`[${t('term.sshSuspend')}] 通过 HTTP API 编辑名称 ${suspendSessionId} 失败:`, error);
uiNotificationsStore.addNotification({
type: 'error',
message: t('sshSuspend.notifications.nameEditedError', { error: error.response?.data?.message || error.message || t('term.unknownError') }),
});
}
};
@@ -561,26 +583,7 @@ const handleSshSuspendEntryRemovedResp = (payload: SshSuspendEntryRemovedRespPay
}
};
const handleSshSuspendNameEditedResp = (payload: SshSuspendNameEditedRespPayload): void => {
const uiNotificationsStore = useUiNotificationsStore();
console.log(`[${t('term.sshSuspend')}] 接到 SSH_SUSPEND_NAME_EDITED_RESP:`, payload);
if (payload.success && payload.customName !== undefined) {
const session = suspendedSshSessions.value.find(s => s.suspendSessionId === payload.suspendSessionId);
if (session) {
session.customSuspendName = payload.customName;
uiNotificationsStore.addNotification({
type: 'success',
message: t('sshSuspend.notifications.nameEditedSuccess', { name: payload.customName }),
});
}
} else {
uiNotificationsStore.addNotification({
type: 'error',
message: t('sshSuspend.notifications.nameEditedError', { error: payload.error || t('term.unknownError') }),
});
console.error(`[${t('term.sshSuspend')}] 编辑挂起名称失败 (ID: ${payload.suspendSessionId}): ${payload.error}`);
}
};
// handleSshSuspendNameEditedResp removed as edit is now via HTTP
const handleSshSuspendAutoTerminatedNotif = (payload: SshSuspendAutoTerminatedNotifPayload): void => {
const uiNotificationsStore = useUiNotificationsStore();
@@ -621,10 +624,10 @@ export const registerSshSuspendHandlers = (wsManager: WsManagerInstance): void =
wsManager.onMessage('SSH_OUTPUT_CACHED_CHUNK', (p: MessagePayload) => handleSshOutputCachedChunk(p as SshOutputCachedChunkPayload));
wsManager.onMessage('SSH_SUSPEND_TERMINATED_RESP', (p: MessagePayload) => handleSshSuspendTerminatedResp(p as SshSuspendTerminatedRespPayload));
wsManager.onMessage('SSH_SUSPEND_ENTRY_REMOVED_RESP', (p: MessagePayload) => handleSshSuspendEntryRemovedResp(p as SshSuspendEntryRemovedRespPayload));
wsManager.onMessage('SSH_SUSPEND_NAME_EDITED_RESP', (p: MessagePayload) => handleSshSuspendNameEditedResp(p as SshSuspendNameEditedRespPayload));
// SSH_SUSPEND_NAME_EDITED_RESP handler removed
wsManager.onMessage('SSH_SUSPEND_AUTO_TERMINATED_NOTIF', (p: MessagePayload) => handleSshSuspendAutoTerminatedNotif(p as SshSuspendAutoTerminatedNotifPayload));
console.log(`[${t('term.sshSuspend')}] SSH 挂起模式的 WebSocket 消息处理器已注册。`);
console.log(`[${t('term.sshSuspend')}] SSH 挂起模式的 WebSocket 消息处理器已注册 (移除了名称编辑相关的处理器)。`);
// 连接建立后，主动获取一次挂起列表
// 考虑：是否应该在这里做，或者在应用启动时做一次？
packages/frontend/src/views/SuspendedSshSessionsView.vue
+59 -103
View File
@@ -38,7 +38,7 @@
<div class="session-info flex-grow mr-2">
<div class="font-bold text-lg">
<span
v-if="!session.isEditingName"
v-if="editingSuspendSessionId !== session.suspendSessionId"
class="cursor-pointer hover:text-primary"
:title="$t('suspendedSshSessions.tooltip.editName')"
@click="startEditingName(session)"
@@ -47,13 +47,13 @@
</span>
<input
v-else
v-model="session.editingNameValue"
ref="nameInputRef"
v-model="currentEditingNameValue"
type="text"
class="text-lg font-bold w-full px-1 py-0.5 border border-primary rounded-md bg-background text-foreground focus:outline-none focus:ring-1 focus:ring-primary"
autofocus
@blur="finishEditingName(session)"
@keydown.enter.prevent="finishEditingName(session)"
@keydown.esc.prevent="cancelEditingName(session)"
@blur="finishEditingName()"
@keydown.enter.prevent="finishEditingName()"
@keydown.esc.prevent="cancelEditingName()"
/>
</div>
<div class="text-sm text-muted-color">
@@ -107,87 +107,43 @@
</template>
<script setup lang="ts">
import { ref, onMounted, computed } from 'vue';
import { ref, onMounted, computed, nextTick, watch } from 'vue'; // +++ 导入 nextTick 和 watch +++
import { useI18n } from 'vue-i18n';
import { storeToRefs } from 'pinia'; // +++ 导入 storeToRefs +++
// PrimeVue components (InputText, Button, Tag) are assumed to be globally registered
// based on the structure of other views like QuickCommandsView.vue
// and the nature of the 'Cannot find module' errors which might indicate
// they are not meant to be imported directly here if globally available.
// 假设 sessionStore 存在并且有以下类型和方法
import { useSessionStore } from '../stores/session.store'; // 使用真实的 store
import type { SuspendedSshSession } from '../types/ssh-suspend.types'; // 确保 SuspendedSshSession 类型从正确的位置导入
import { storeToRefs } from 'pinia';
import { useSessionStore } from '../stores/session.store';
import type { SuspendedSshSession } from '../types/ssh-suspend.types';
const { t } = useI18n();
// 模拟类型，实际应从 ssh-suspend.types.ts 导入 (保持这个类型扩展)
interface SuspendedSshSessionUIData extends SuspendedSshSession {
isEditingName?: boolean;
editingNameValue?: string;
}
// // 模拟 sessionStore (注释掉)
// const mockSessionStore = {
// suspendedSshSessions: ref<SuspendedSshSessionUIData[]>([
// // ... mock data ...
// ]),
// fetchSuspendedSshSessions: async () => {
// console.log('[SuspendedSshSessionsView] Requesting suspended SSH sessions...');
// // 模拟 API 调用延迟
// return new Promise(resolve => setTimeout(() => {
// mockSessionStore.suspendedSshSessions.value = [
// // ... mock data ...
// ];
// isLoading.value = false;
// console.log('[SuspendedSshSessionsView] Mock sessions loaded:', mockSessionStore.suspendedSshSessions.value);
// resolve(true);
// }, 1500));
// },
// resumeSshSession: async (suspendSessionId: string, newFrontendSessionId: string) => {
// console.log(`[SuspendedSshSessionsView] Action: resumeSshSession(${suspendSessionId}, ${newFrontendSessionId})`);
// alert(`模拟恢复会话: ${suspendSessionId}`);
// },
// terminateAndRemoveSshSession: async (suspendSessionId: string) => {
// console.log(`[SuspendedSshSessionsView] Action: terminateAndRemoveSshSession(${suspendSessionId})`);
// mockSessionStore.suspendedSshSessions.value = mockSessionStore.suspendedSshSessions.value.filter(s => s.suspendSessionId !== suspendSessionId);
// alert(`模拟终止并移除会话: ${suspendSessionId}`);
// },
// removeSshSessionEntry: async (suspendSessionId: string) => {
// console.log(`[SuspendedSshSessionsView] Action: removeSshSessionEntry(${suspendSessionId})`);
// mockSessionStore.suspendedSshSessions.value = mockSessionStore.suspendedSshSessions.value.filter(s => s.suspendSessionId !== suspendSessionId);
// alert(`模拟移除已断开会话条目: ${suspendSessionId}`);
// },
// editSshSessionName: async (suspendSessionId: string, newName: string) => {
// console.log(`[SuspendedSshSessionsView] Action: editSshSessionName(${suspendSessionId}, ${newName})`);
// const session = mockSessionStore.suspendedSshSessions.value.find(s => s.suspendSessionId === suspendSessionId);
// if (session) {
// session.customSuspendName = newName;
// }
// alert(`模拟编辑名称: ${suspendSessionId} -> ${newName}`);
// },
// };
const sessionStore = useSessionStore(); // 使用真实的 store
// const sessionStore = mockSessionStore; // 使用模拟 store (注释掉)
// +++ 使用 storeToRefs 获取响应式状态，并将 isLoadingSuspendedSessions 重命名为 isLoading +++
const sessionStore = useSessionStore();
const { suspendedSshSessions: storeSuspendedSshSessions, isLoadingSuspendedSessions: isLoading } = storeToRefs(sessionStore);
const searchTerm = ref('');
// const isLoading = ref(true); // 现在从 store 的 isLoading 获取
const allSuspendedSshSessions = computed(() => storeSuspendedSshSessions.value.map((s: SuspendedSshSession) => ({ // 显式为 s 添加类型
...(s as SuspendedSshSessionUIData), // 断言为包含 UI 状态的类型
isEditingName: (s as SuspendedSshSessionUIData).isEditingName ?? false,
editingNameValue: (s as SuspendedSshSessionUIData).editingNameValue ?? s.customSuspendName ?? s.connectionName,
})));
// +++ 组件级编辑状态 +++
const editingSuspendSessionId = ref<string | null>(null);
const currentEditingNameValue = ref<string>('');
const nameInputRef = ref<HTMLInputElement | null>(null);
// +++ 监听编辑ID变化以聚焦输入框 +++
watch(editingSuspendSessionId, async (newId) => {
if (newId !== null) {
await nextTick(); // 确保DOM已更新，输入框已渲染
if (nameInputRef.value && typeof nameInputRef.value.focus === 'function') {
nameInputRef.value.focus();
// nameInputRef.value.select(); // 可选：如果希望选中所有文本
} else {
console.warn('[SuspendedSshSessionsView] Watcher: nameInputRef.value is not a focusable input after nextTick.');
}
}
});
// filteredSessions 现在直接基于 storeSuspendedSshSessions
const filteredSessions = computed(() => {
if (!searchTerm.value.trim()) {
return allSuspendedSshSessions.value; // allSuspendedSshSessions 已经是 .value 之后的结果
return storeSuspendedSshSessions.value;
}
const lowerSearchTerm = searchTerm.value.toLowerCase();
return allSuspendedSshSessions.value.filter((session: SuspendedSshSessionUIData) => // 为 session 添加类型
return storeSuspendedSshSessions.value.filter((session: SuspendedSshSession) =>
(session.customSuspendName?.toLowerCase() || '').includes(lowerSearchTerm) ||
session.connectionName.toLowerCase().includes(lowerSearchTerm)
);
@@ -201,44 +157,46 @@ const formatDateTime = (isoString?: string) => {
if (!isoString) return t('time.unknown');
try {
return new Date(isoString).toLocaleString('zh-CN', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
year: 'numeric', month: '2-digit', day: '2-digit',
hour: '2-digit', minute: '2-digit',
});
} catch (e) {
return t('time.invalidDate');
}
};
const startEditingName = (session: SuspendedSshSessionUIData) => {
// 确保同一时间只有一个会话处于编辑状态（可选优化）
allSuspendedSshSessions.value.forEach((s: SuspendedSshSessionUIData) => s.isEditingName = false); // 为 s 添加类型
session.isEditingName = true;
session.editingNameValue = session.customSuspendName || session.connectionName;
const startEditingName = (session: SuspendedSshSession) => { // async 不再需要，聚焦由 watcher 处理
editingSuspendSessionId.value = session.suspendSessionId;
currentEditingNameValue.value = session.customSuspendName || session.connectionName;
// 聚焦逻辑已移至 watcher
};
const finishEditingName = (session: SuspendedSshSessionUIData) => {
if (!session.isEditingName) return;
session.isEditingName = false;
const newName = session.editingNameValue?.trim();
// 仅当名称有变化且不为空时才提交
if (newName && newName !== (session.customSuspendName || session.connectionName)) {
sessionStore.editSshSessionName(session.suspendSessionId, newName);
} else {
// 如果名称未变或变为空，则恢复显示原始值或之前的自定义名
session.editingNameValue = session.customSuspendName || session.connectionName;
const finishEditingName = () => {
if (editingSuspendSessionId.value === null) return;
const sessionId = editingSuspendSessionId.value;
const newName = currentEditingNameValue.value.trim();
const originalSession = storeSuspendedSshSessions.value.find(s => s.suspendSessionId === sessionId);
if (!originalSession) {
editingSuspendSessionId.value = null; // 重置状态
return;
}
editingSuspendSessionId.value = null; // 退出编辑模式
if (newName && newName !== (originalSession.customSuspendName || originalSession.connectionName)) {
sessionStore.editSshSessionName(sessionId, newName);
}
// 如果名称未变或为空，则无需操作，因为 currentEditingNameValue 不会持久化
};
const cancelEditingName = (session: SuspendedSshSessionUIData) => {
session.isEditingName = false;
session.editingNameValue = session.customSuspendName || session.connectionName; // 恢复原值
const cancelEditingName = () => {
editingSuspendSessionId.value = null;
// currentEditingNameValue 不需要显式重置，因为它会在下次 startEditingName 时被新值覆盖
};
const resumeSession = async (session: SuspendedSshSessionUIData) => {
const resumeSession = async (session: SuspendedSshSession) => { // 参数类型改为 SuspendedSshSession
console.log(`[SuspendedSshSessionsView] Attempting to resume session ID: ${session.suspendSessionId}, Name: ${session.customSuspendName || session.connectionName}`);
// 使用 JSON.parse(JSON.stringify()) 来记录会话对象的一个快照，避免在异步操作后因对象被修改而导致日志不准确
console.log('[SuspendedSshSessionsView] Session details snapshot:', JSON.parse(JSON.stringify(session)));
@@ -277,7 +235,7 @@ const resumeSession = async (session: SuspendedSshSessionUIData) => {
}
};
const removeSession = (session: SuspendedSshSessionUIData) => {
const removeSession = (session: SuspendedSshSession) => { // 参数类型改为 SuspendedSshSession
if (session.backendSshStatus === 'hanging') {
sessionStore.terminateAndRemoveSshSession(session.suspendSessionId);
} else if (session.backendSshStatus === 'disconnected_by_backend') {
@@ -286,9 +244,7 @@ const removeSession = (session: SuspendedSshSessionUIData) => {
};
onMounted(async () => {
// isLoading.value = true; // storeIsLoading 会自动更新
await sessionStore.fetchSuspendedSshSessions();
// isLoading.value = false; // fetchSuspendedSshSessions 内部应更新 storeIsLoading
});
</script>