aws-runtime-bridge 1.5.0 → 1.6.2

package/dist/routes/terminal.js

@@ -1,22 +1,290 @@
 /**
  * 终端 API 路由
  *
- * 提供终端会话的启动、输入、调整大小和停止功能
- * 支持 PTY 模式和 SDK 模式
+ * 提供 SDK Agent 会话的启动、输入、调整大小和停止功能
+ * 终端 UI 仅作为 SDK Agent 的消息输入/状态输出载体
  */
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { TextDecoder } from 'node:util';
 import { Router } from 'express';
-import pty from 'node-pty';
 import { v4 as uuidv4 } from 'uuid';
 import { adapterRegistry, registerSdkProviders, resolveSdkProviderIdByCommand, } from '../adapter/index.js';
 import { validateToken } from '../middleware/auth.js';
 import { getAgentProcessManager } from '../services/agent-process-manager.js';
-import { findClaudeCodeProcesses, terminateProcessTree, waitForProcessExit } from '../services/process-detector.js';
-import { flushSessionOutput, scheduleOutputFlush, sendQuestionRequest, sendStatus, sessions } from '../services/session-output.js';
 import { enqueueMcpLaunchBinding } from '../services/mcp-launch-binding-queue.js';
-import { loadPersistedSessions, removePersistedSession, removePersistedSessionByAgentId, savePersistedSessions, upsertPersistedSession, } from '../services/terminal-persistence.js';
+import { findClaudeCodeProcesses } from '../services/process-detector.js';
+import { sendOutput, sendQuestionRequest, sendStatus } from '../services/session-output.js';
+import { removePersistedSession, removePersistedSessionByAgentId, savePersistedSessions, updatePersistedSessionAutoCommands, upsertPersistedSession, } from '../services/terminal-persistence.js';
 export const terminalRouter = Router();
 // 导出 SDK 会话存储，供其他模块使用（如 sessions.ts）
 export const sdkSessions = new Map();
+const TOOL_RESULT_PREVIEW_MAX_LENGTH = 4000;
+const terminalCommandStates = new Map();
+const DEFAULT_WINDOWS_TERMINAL_OUTPUT_ENCODING = 'gb18030';
+const DEFAULT_TERMINAL_OUTPUT_ENCODING = 'utf-8';
+/**
+ * 标准化终端输入：将前端回车符还原为 shell 可执行命令文本。
+ */
+export function normalizeTerminalCommandInput(value) {
+    return String(value ?? '').replace(/\r/g, '\n').trim();
+}
+/**
+ * 解析终端命令输出解码编码。
+ * 主流程：优先使用环境变量覆盖 -> Windows 默认 GB18030 -> 其他平台默认 UTF-8。
+ */
+export function resolveTerminalOutputEncoding(platform = process.platform, env = process.env) {
+    const configuredEncoding = env.AWS_TERMINAL_OUTPUT_ENCODING?.trim();
+    if (configuredEncoding) {
+        return configuredEncoding;
+    }
+    return platform === 'win32' ? DEFAULT_WINDOWS_TERMINAL_OUTPUT_ENCODING : DEFAULT_TERMINAL_OUTPUT_ENCODING;
+}
+/**
+ * 创建终端输出流式解码器，避免多字节中文被 chunk 边界截断。
+ */
+export function createTerminalOutputDecoder(encoding = resolveTerminalOutputEncoding()) {
+    try {
+        return new TextDecoder(encoding, { fatal: false });
+    }
+    catch {
+        return new TextDecoder(DEFAULT_TERMINAL_OUTPUT_ENCODING, { fatal: false });
+    }
+}
+/**
+ * 解码终端输出 chunk；end=true 时刷新解码器内部剩余字节。
+ */
+export function decodeTerminalOutputChunk(decoder, chunk, end = false) {
+    if (end) {
+        return decoder.decode();
+    }
+    if (!chunk || chunk.length === 0) {
+        return '';
+    }
+    return decoder.decode(chunk, { stream: true });
+}
+/**
+ * 解析 cd 命令目标；返回 undefined 表示不是目录切换命令，null 表示仅查看当前目录。
+ */
+export function parseTerminalDirectoryChangeTarget(command) {
+    const match = command.trim().match(/^cd(?:\s+(.*))?$/i);
+    if (!match) {
+        return undefined;
+    }
+    const rawTarget = match[1]?.trim();
+    if (!rawTarget) {
+        return null;
+    }
+    const withoutDriveSwitch = rawTarget.replace(/^\/d\s+/i, '').trim();
+    if ((withoutDriveSwitch.startsWith('"') && withoutDriveSwitch.endsWith('"'))
+        || (withoutDriveSwitch.startsWith("'") && withoutDriveSwitch.endsWith("'"))) {
+        return withoutDriveSwitch.slice(1, -1);
+    }
+    return withoutDriveSwitch;
+}
+function getTerminalCommandState(entry) {
+    const existing = terminalCommandStates.get(entry.sessionId);
+    if (existing) {
+        return existing;
+    }
+    const state = {
+        currentDirectory: entry.workspacePath,
+        runningProcess: null,
+    };
+    terminalCommandStates.set(entry.sessionId, state);
+    return state;
+}
+function stopTerminalCommandProcess(sessionId) {
+    const state = terminalCommandStates.get(sessionId);
+    if (!state?.runningProcess) {
+        terminalCommandStates.delete(sessionId);
+        return;
+    }
+    try {
+        state.runningProcess.kill();
+    }
+    catch {
+        // ignore best-effort cleanup failures; session shutdown must continue
+    }
+    finally {
+        state.runningProcess = null;
+        terminalCommandStates.delete(sessionId);
+    }
+}
+function appendCommandOutput(entry, output) {
+    if (!output) {
+        return;
+    }
+    entry.seq += 1;
+    void sendOutput(entry.agentId, output, entry.sessionId, entry.seq);
+}
+/**
+ * 生成显示在终端输出流中的工作目录提示符。
+ */
+export function formatTerminalPrompt(currentDirectory) {
+    return `\x1b[36m${currentDirectory}>\x1b[0m `;
+}
+function resolveDirectoryTarget(currentDirectory, target) {
+    if (target === '~') {
+        return os.homedir();
+    }
+    return path.resolve(currentDirectory, target);
+}
+/**
+ * 处理内置目录切换命令，保持终端后续命令的当前目录连续。
+ */
+async function handleDirectoryChangeCommand(entry, state, command) {
+    const target = parseTerminalDirectoryChangeTarget(command);
+    if (target === undefined) {
+        return false;
+    }
+    if (target === null) {
+        appendCommandOutput(entry, `${state.currentDirectory}\r\n`);
+        return true;
+    }
+    const nextDirectory = resolveDirectoryTarget(state.currentDirectory, target);
+    try {
+        const stat = await fs.stat(nextDirectory);
+        if (!stat.isDirectory()) {
+            appendCommandOutput(entry, `cd: not a directory: ${nextDirectory}\r\n`);
+            return true;
+        }
+        state.currentDirectory = nextDirectory;
+        appendCommandOutput(entry, `${state.currentDirectory}\r\n`);
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        appendCommandOutput(entry, `cd: ${message}\r\n`);
+        return true;
+    }
+}
+/**
+ * 在当前 Agent 工作目录对应的终端上下文中执行命令。
+ */
+async function executeTerminalCommand(sessionId, commandValue) {
+    const entry = sdkSessions.get(sessionId);
+    if (!entry) {
+        throw new Error('SDK session not found');
+    }
+    const command = normalizeTerminalCommandInput(commandValue);
+    const state = getTerminalCommandState(entry);
+    if (!command) {
+        return { started: false, cwd: state.currentDirectory };
+    }
+    if (state.runningProcess) {
+        throw new Error('A terminal command is already running for this session');
+    }
+    appendCommandOutput(entry, `${formatTerminalPrompt(state.currentDirectory)}${command}\r\n`);
+    const handledDirectoryChange = await handleDirectoryChangeCommand(entry, state, command);
+    if (handledDirectoryChange) {
+        return { started: false, cwd: state.currentDirectory };
+    }
+    await sendStatus(entry.agentId, sessionId, 'tool_using', {
+        actionType: 'bash',
+        actionLabel: '终端命令',
+        actionDetail: command,
+    });
+    const child = spawn(command, {
+        cwd: state.currentDirectory,
+        shell: true,
+        env: buildRuntimeEnv(entry.agentId, entry.workspacePath, process.env, entry.config.envOverrides),
+    });
+    state.runningProcess = child;
+    const stdoutDecoder = createTerminalOutputDecoder();
+    const stderrDecoder = createTerminalOutputDecoder();
+    child.stdout.on('data', (chunk) => {
+        appendCommandOutput(entry, decodeTerminalOutputChunk(stdoutDecoder, chunk));
+    });
+    child.stderr.on('data', (chunk) => {
+        appendCommandOutput(entry, decodeTerminalOutputChunk(stderrDecoder, chunk));
+    });
+    child.on('error', (error) => {
+        appendCommandOutput(entry, `\r\n[Terminal Error] ${error.message}\r\n`);
+    });
+    child.on('close', (code, signal) => {
+        state.runningProcess = null;
+        appendCommandOutput(entry, decodeTerminalOutputChunk(stdoutDecoder, undefined, true));
+        appendCommandOutput(entry, decodeTerminalOutputChunk(stderrDecoder, undefined, true));
+        if (code && code !== 0) {
+            appendCommandOutput(entry, `\r\n[exit ${code}]\r\n`);
+        }
+        else if (signal) {
+            appendCommandOutput(entry, `\r\n[signal ${signal}]\r\n`);
+        }
+        appendCommandOutput(entry, formatTerminalPrompt(state.currentDirectory));
+        void sendStatus(entry.agentId, sessionId, 'waiting_input');
+    });
+    return { started: true, cwd: state.currentDirectory };
+}
+export function buildRuntimeEnv(agentId, workspacePath, baseEnv, envOverrides) {
+    const env = {};
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    if (workspacePath) {
+        env.AWS_WORKSPACE_PATH = String(workspacePath);
+    }
+    if (envOverrides) {
+        for (const [key, value] of Object.entries(envOverrides)) {
+            const normalizedKey = key.trim();
+            if (!normalizedKey || value === undefined || value === null) {
+                continue;
+            }
+            const normalizedValue = String(value).trim();
+            if (!normalizedValue) {
+                continue;
+            }
+            env[normalizedKey] = normalizedValue;
+        }
+    }
+    env.AWS_AGENT_ID = String(agentId);
+    env.AWS_MCP_CLAIM_LAUNCH_BINDING = 'true';
+    return env;
+}
+function formatToolResultForTimeline(result) {
+    if (result === undefined || result === null) {
+        return undefined;
+    }
+    const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    const normalized = text.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length <= TOOL_RESULT_PREVIEW_MAX_LENGTH) {
+        return normalized;
+    }
+    return `${normalized.slice(0, TOOL_RESULT_PREVIEW_MAX_LENGTH)}\n...（结果过长，已截断）`;
+}
+function isMcpProviderEvent(event) {
+    const actionType = event.data.actionType;
+    if (actionType === 'mcp') {
+        return true;
+    }
+    const toolName = String(event.data.toolName || '').toLowerCase();
+    return toolName.startsWith('mcp__') || toolName.includes('-mcp__') || toolName.includes('mcp_');
+}
+export function formatSdkOutputEvent(event) {
+    if (event.type === 'text_delta' || event.type === 'thinking') {
+        return event.data.text || undefined;
+    }
+    if (event.type === 'error') {
+        return event.data.text ? `\r\n[SDK Error] ${event.data.text}\r\n` : undefined;
+    }
+    return undefined;
+}
+function forwardSdkOutputEvent(event, entry) {
+    const output = formatSdkOutputEvent(event);
+    if (!output) {
+        return;
+    }
+    entry.seq += 1;
+    void sendOutput(entry.agentId, output, event.sessionId, entry.seq);
+}
 export function resolveSdkProviderId(command) {
     return resolveSdkProviderIdByCommand(command);
 }
@@ -33,6 +301,19 @@ function wireSdkAdapterEvents(adapter, definition) {
         const entry = sdkSessions.get(event.sessionId);
         if (entry) {
             console.log(`[${definition.displayName} Adapter] Event: ${event.type} for session ${event.sessionId}`);
+            forwardSdkOutputEvent(event, entry);
+            if (event.type === 'tool_use_end' && isMcpProviderEvent(event)) {
+                const actionResult = formatToolResultForTimeline(event.data.toolResult);
+                if (actionResult) {
+                    void sendStatus(entry.agentId, event.sessionId, 'tool_result', {
+                        actionType: 'mcp',
+                        actionLabel: 'MCP返回',
+                        actionDetail: event.data.toolName,
+                        actionId: event.data.toolUseId,
+                        actionResult,
+                    });
+                }
+            }
             if (event.type === 'turn_complete' && event.data.usage) {
                 sendStatus(entry.agentId, event.sessionId, 'waiting_input', undefined, event.data.usage);
             }
@@ -42,7 +323,7 @@ function wireSdkAdapterEvents(adapter, definition) {
         const entry = sdkSessions.get(sessionId);
         if (entry) {
             console.log(`[${definition.displayName} Adapter] Status changed: ${status} for agent ${entry.agentId}`, actionInfo || '');
-            sendStatus(entry.agentId, sessionId, status, actionInfo);
+            void sendStatus(entry.agentId, sessionId, status, actionInfo);
         }
     });
     adapter.on('ask-user-question', (data) => {
@@ -60,17 +341,16 @@ function wireSdkAdapterEvents(adapter, definition) {
     });
 }
 /**
- * 启动终端会话
+ * 启动 SDK Agent 会话
  * POST /runtime/start
- * 支持 mode: 'pty' | 'sdk'
  */
 terminalRouter.post('/start', validateToken, async (req, res) => {
-    const { agentId, workspacePath, command, mode = 'pty' } = req.body || {};
+    const { agentId, workspacePath, mode = 'sdk', } = req.body || {};
     if (!agentId || !workspacePath) {
         res.status(400).json({ error: 'agentId and workspacePath are required' });
         return;
     }
-    const queuedBinding = enqueueMcpLaunchBinding({
+    enqueueMcpLaunchBinding({
         agentId: String(agentId),
         workspacePath: String(workspacePath),
         serverUrl: req.body?.serverUrl || req.body?.schedulerBaseUrl,
@@ -78,104 +358,10 @@ terminalRouter.post('/start', validateToken, async (req, res) => {
         userId: req.body?.userId,
         schedulerBaseUrl: req.body?.schedulerBaseUrl,
     });
-    // SDK 模式
-    if (mode === 'sdk') {
-        await startSdkSession(req, res);
-        return;
+    if (mode && mode !== 'sdk') {
+        console.warn(`[Runtime] Unsupported runtime mode "${mode}" requested for agent ${agentId}; starting SDK session instead.`);
     }
-    // PTY 模式（原有逻辑）
-    const oldSession = Array.from(sessions.entries()).find(([, value]) => value.agentId === agentId);
-    if (oldSession) {
-        try {
-            oldSession[1].ptyProcess.kill();
-        }
-        catch {
-            // ignore stale session cleanup errors
-        }
-        if (oldSession[1].flushTimer) {
-            clearTimeout(oldSession[1].flushTimer);
-        }
-        sessions.delete(oldSession[0]);
-        await removePersistedSession(oldSession[0]);
-    }
-    const sessionId = uuidv4();
-    const shell = process.platform === 'win32' ? 'powershell.exe' : 'bash';
-    const shellArgs = process.platform === 'win32' ? ['-NoLogo'] : [];
-    const actualCommand = command || 'claude';
-    const terminal = pty.spawn(shell, shellArgs, {
-        name: 'xterm-color',
-        cols: 120,
-        rows: 30,
-        cwd: workspacePath,
-        env: {
-            ...process.env,
-            AWS_AGENT_ID: String(agentId),
-            AWS_MCP_CLAIM_LAUNCH_BINDING: 'true',
-        },
-    });
-    sessions.set(sessionId, {
-        agentId,
-        workspacePath,
-        ptyProcess: terminal,
-        outputBuffer: '',
-        flushTimer: null,
-        flushInFlight: null,
-        seq: 0,
-    });
-    await upsertPersistedSession({
-        sessionId,
-        agentId,
-        workspacePath,
-        command: actualCommand,
-        startedAt: new Date().toISOString(),
-        status: 'running',
-        mode: 'pty',
-        // ★ PTY 模式：记录 pty 进程的 PID
-        pid: terminal.pid,
-    });
-    // ★ 注册到进程管理器
-    const processManager = getAgentProcessManager();
-    await processManager.startProcess({
-        agentId,
-        sessionId,
-        pid: terminal.pid,
-        mode: 'pty',
-        workspacePath,
-        command: actualCommand,
-    });
-    await sendStatus(agentId, sessionId, 'running');
-    terminal.onData((data) => {
-        const session = sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.outputBuffer += data;
-        scheduleOutputFlush(sessionId);
-    });
-    terminal.onExit(async () => {
-        const session = sessions.get(sessionId);
-        if (session?.flushTimer) {
-            clearTimeout(session.flushTimer);
-            session.flushTimer = null;
-        }
-        await flushSessionOutput(sessionId);
-        sessions.delete(sessionId);
-        // 直接删除持久化会话，而不是改成 stopped，避免后续被恢复
-        await removePersistedSession(sessionId);
-        // ★ 从进程管理器中移除
-        const processManager = getAgentProcessManager();
-        await processManager.removeProcess(agentId);
-        await sendStatus(agentId, null, 'stopped');
-    });
-    terminal.write(`${actualCommand}\r`);
-    res.json({
-        sessionId,
-        status: 'running',
-        agentId,
-        workspacePath,
-        command: actualCommand,
-        mode: 'pty',
-    });
+    await startSdkSession(req, res);
 });
 /**
  * 启动 SDK 会话
@@ -184,7 +370,7 @@ terminalRouter.post('/start', validateToken, async (req, res) => {
 async function startSdkSession(req, res) {
     const { agentId, workspacePath, command, autoAccept = true, initialPrompt, 
     // MCP 配置 - 加载 aws-client-agent-mcp
-    mcpConfigPath, extraMcpServers, 
+    mcpConfigPath, extraMcpServers, envOverrides, 
     // 空闲命令配置
     idleInputAutoCommand, nonInputAutoCommand, } = req.body || {};
     let sessionId = null;
@@ -208,11 +394,7 @@ async function startSdkSession(req, res) {
             // MCP 配置：不再默认注入 aws-mcp；由用户在面板中安装/配置
             mcpConfigPath,
             extraMcpServers: extraMcpServers || {},
-            envOverrides: {
-                AWS_AGENT_ID: String(agentId),
-                AWS_WORKSPACE_PATH: String(workspacePath),
-                AWS_MCP_CLAIM_LAUNCH_BINDING: 'true',
-            },
+            envOverrides: buildRuntimeEnv(String(agentId), String(workspacePath), process.env, envOverrides),
         };
         // 存储会话信息
         sdkSessions.set(sessionId, {
@@ -221,6 +403,7 @@ async function startSdkSession(req, res) {
             sessionId,
             config,
             providerId, // 记录使用的 provider
+            seq: 0,
         });
         // 启动 SDK 会话
         await adapter.startSession(sessionId, config);
@@ -433,6 +616,7 @@ terminalRouter.post('/sdk/stop', validateToken, async (req, res) => {
         const adapter = adapterRegistry.get(providerId);
         await adapter.terminateSession(sessionId);
         sdkSessions.delete(sessionId);
+        stopTerminalCommandProcess(sessionId);
         await removePersistedSession(sessionId);
         // ★ 从进程管理器中移除
         const processManager = getAgentProcessManager();
@@ -479,27 +663,105 @@ terminalRouter.get('/sdk/status/:sessionId', validateToken, (req, res) => {
         res.status(500).json({ error: errorMessage });
     }
 });
-// ============ PTY 模式原有路由 ============
 /**
- * 发送输入到终端（PTY 模式）
+ * 执行当前 Agent 工作目录下的终端命令。
+ *
+ * 主流程：校验 session/command -> 读取会话 workspacePath -> 在该 cwd 下启动 shell 命令 -> 通过终端输出回调流式返回。
+ * POST /runtime/command
+ */
+terminalRouter.post('/command', validateToken, async (req, res) => {
+    const { sessionId, command } = req.body || {};
+    if (!sessionId || command === undefined || command === null) {
+        res.status(400).json({ error: 'sessionId and command are required' });
+        return;
+    }
+    try {
+        const result = await executeTerminalCommand(String(sessionId), command);
+        res.json({ ok: true, mode: 'terminal', ...result });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ error: errorMessage });
+    }
+});
+// ============ 兼容终端 UI 的 SDK 路由 ============
+/**
+ * 发送消息到 SDK 会话。
+ *
+ * 主流程：校验 session/input -> 定位 SDK 会话 -> 通过 provider adapter 发送用户消息。
  * POST /runtime/input
  */
-terminalRouter.post('/input', validateToken, (req, res) => {
-    const { sessionId, input } = req.body || {};
+terminalRouter.post('/input', validateToken, async (req, res) => {
+    const { sessionId, input, mode } = req.body || {};
     if (!sessionId || input === undefined || input === null) {
         res.status(400).json({ error: 'sessionId and input are required' });
         return;
     }
-    const session = sessions.get(sessionId);
-    if (!session) {
-        res.status(404).json({ error: 'session not found' });
+    const entry = sdkSessions.get(sessionId);
+    if (!entry) {
+        res.status(404).json({ error: 'SDK session not found' });
         return;
     }
-    session.ptyProcess.write(input);
-    res.json({ ok: true });
+    try {
+        const providerId = entry.providerId || 'claude-code';
+        const adapter = adapterRegistry.get(providerId);
+        if (mode === 'shortcut') {
+            if (!adapter.sendShortcutInput) {
+                res.status(400).json({ error: 'shortcut input is not supported by this SDK provider' });
+                return;
+            }
+            await adapter.sendShortcutInput(sessionId, String(input));
+            res.json({ ok: true, mode: 'shortcut' });
+            return;
+        }
+        await adapter.sendMessage(sessionId, String(input));
+        res.json({ ok: true, mode: 'sdk' });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ error: errorMessage });
+    }
 });
 /**
- * 调整终端大小（PTY 模式）
+ * 热更新运行中 SDK 会话的自动命令配置。
+ *
+ * 主流程：按 agentId 定位 SDK 会话 -> 更新 adapter 内存配置 -> 同步持久化会话字段。
+ * POST /runtime/update-auto-commands
+ */
+terminalRouter.post('/update-auto-commands', validateToken, async (req, res) => {
+    const { agentId, idleInputAutoCommand = '', nonInputAutoCommand = '' } = req.body || {};
+    const normalizedAgentId = String(agentId || '').trim();
+    if (!normalizedAgentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    const entry = [...sdkSessions.values()].find((session) => session.agentId === normalizedAgentId);
+    const commands = {
+        idleInputCommand: String(idleInputAutoCommand || ''),
+        nonInputCommand: String(nonInputAutoCommand || ''),
+    };
+    try {
+        let sessionUpdated = false;
+        if (entry) {
+            const adapter = adapterRegistry.get(entry.providerId || 'claude-code');
+            adapter.setIdleCommands?.(entry.sessionId, commands);
+            sessionUpdated = true;
+        }
+        const persistedUpdated = await updatePersistedSessionAutoCommands(normalizedAgentId, {
+            idleInputAutoCommand: commands.idleInputCommand,
+            nonInputAutoCommand: commands.nonInputCommand,
+        });
+        res.json({ ok: true, mode: 'sdk', sessionUpdated, persistedUpdated });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ ok: false, mode: 'sdk', error: errorMessage });
+    }
+});
+/**
+ * 兼容终端尺寸调整 API。
+ *
+ * SDK 会话没有终端尺寸概念；保留该端点用于前端 xterm fit 回调，返回 no-op。
  * POST /runtime/resize
  */
 terminalRouter.post('/resize', validateToken, (req, res) => {
@@ -508,16 +770,14 @@ terminalRouter.post('/resize', validateToken, (req, res) => {
         res.status(400).json({ error: 'sessionId, cols, rows are required' });
         return;
     }
-    const session = sessions.get(sessionId);
-    if (!session) {
-        res.status(404).json({ error: 'session not found' });
+    if (!sdkSessions.has(sessionId)) {
+        res.status(404).json({ error: 'SDK session not found' });
         return;
     }
-    session.ptyProcess.resize(Number(cols), Number(rows));
-    res.json({ ok: true, cols: Number(cols), rows: Number(rows) });
+    res.json({ ok: true, mode: 'sdk', noop: true, cols: Number(cols), rows: Number(rows) });
 });
 /**
- * 停止终端会话（PTY 模式和 SDK 模式）
+ * 停止 SDK 会话。
  * POST /runtime/stop
  */
 terminalRouter.post('/stop', validateToken, async (req, res) => {
@@ -526,133 +786,41 @@ terminalRouter.post('/stop', validateToken, async (req, res) => {
         res.status(400).json({ error: 'sessionId is required' });
         return;
     }
-    // 1. 检查是否是 SDK 会话
     const sdkEntry = sdkSessions.get(sessionId);
-    if (sdkEntry) {
-        const agentId = sdkEntry.agentId;
-        try {
-            // 根据 providerId 获取对应的 adapter
-            const providerId = sdkEntry.providerId || 'claude-code';
-            const adapter = adapterRegistry.get(providerId);
-            await adapter.terminateSession(sessionId);
-            sdkSessions.delete(sessionId);
-            // 同时按 sessionId 和 agentId 删除，确保持久化会话被清除
-            await removePersistedSession(sessionId);
-            await removePersistedSessionByAgentId(agentId);
-            // ★ 从进程管理器中移除
-            const processManager = getAgentProcessManager();
-            await processManager.removeProcess(agentId);
-            await sendStatus(agentId, null, 'stopped');
-            res.json({ ok: true, status: 'stopped', mode: 'sdk' });
-            return;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`[Runtime] Failed to terminate SDK session ${sessionId}:`, errorMessage);
-            res.status(500).json({ ok: false, status: 'stop_failed', mode: 'sdk', error: errorMessage });
-            return;
-        }
-    }
-    // 2. 检查是否是 PTY 会话
-    const session = sessions.get(sessionId);
-    if (!session) {
-        // 3. 会话不存在于内存，直接清理持久化记录，避免后续恢复
+    if (!sdkEntry) {
         await removePersistedSession(sessionId);
-        // 也从进程管理器清理（通过持久化会话查找 agentId）
-        try {
-            const persistedSessions = await loadPersistedSessions();
-            const persistedSession = persistedSessions.find(p => p.sessionId === sessionId);
-            if (persistedSession) {
-                const processManager = getAgentProcessManager();
-                await processManager.removeProcess(persistedSession.agentId);
-            }
-        }
-        catch {
-            // ignore cleanup errors
-        }
         res.json({ ok: true, status: 'stopped', mode: 'none' });
         return;
     }
-    // 4. 终止 PTY 进程
-    const agentId = session.agentId;
-    const pid = session.ptyProcess.pid;
-    let exited = false;
-    let terminated = 0;
-    let failed = 0;
+    const agentId = sdkEntry.agentId;
     try {
-        session.ptyProcess.kill();
-        exited = await waitForProcessExit(pid, 3000);
+        const providerId = sdkEntry.providerId || 'claude-code';
+        const adapter = adapterRegistry.get(providerId);
+        await adapter.terminateSession(sessionId);
+        sdkSessions.delete(sessionId);
+        stopTerminalCommandProcess(sessionId);
+        await removePersistedSession(sessionId);
+        await removePersistedSessionByAgentId(agentId);
+        const processManager = getAgentProcessManager();
+        await processManager.removeProcess(agentId);
+        await sendStatus(agentId, null, 'stopped');
+        res.json({ ok: true, status: 'stopped', mode: 'sdk' });
     }
     catch (error) {
-        console.warn(`[Runtime] Failed to kill PTY process gracefully: sessionId=${sessionId}, pid=${pid}`, error);
-    }
-    if (!exited) {
-        const result = terminateProcessTree(pid);
-        terminated = result.terminated;
-        failed = result.failed;
-        exited = await waitForProcessExit(pid, 5000);
-    }
-    if (!exited) {
-        await sendStatus(agentId, sessionId, 'stop_failed');
-        res.status(500).json({
-            ok: false,
-            status: 'stop_failed',
-            mode: 'pty',
-            pid,
-            terminated,
-            failed,
-            error: `process ${pid} is still running after termination attempts`,
-        });
-        return;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[Runtime] Failed to terminate SDK session ${sessionId}:`, errorMessage);
+        res.status(500).json({ ok: false, status: 'stop_failed', mode: 'sdk', error: errorMessage });
     }
-    if (session.flushTimer) {
-        clearTimeout(session.flushTimer);
-        session.flushTimer = null;
-    }
-    await flushSessionOutput(sessionId);
-    sessions.delete(sessionId);
-    // 同时按 sessionId 和 agentId 删除，确保持久化会话被清除
-    await removePersistedSession(sessionId);
-    await removePersistedSessionByAgentId(agentId);
-    // ★ 从进程管理器中移除
-    const processManager = getAgentProcessManager();
-    await processManager.removeProcess(agentId);
-    await sendStatus(agentId, null, 'stopped');
-    res.json({ ok: true, status: 'stopped', mode: 'pty' });
 });
 /**
- * 停止所有终端会话（PTY 和 SDK）
+ * 停止所有 SDK 会话
  * POST /runtime/stop-all
- * 用于 aws-mcp-server 重启时清理所有终端
+ * 用于 aws-mcp-server 重启时清理所有 SDK Agent 会话
  */
 terminalRouter.post('/stop-all', validateToken, async (_req, res) => {
-    const stoppedPty = [];
     const stoppedSdk = [];
     const errors = [];
-    // 1. 停止所有 PTY 会话
-    for (const [sessionId, session] of sessions.entries()) {
-        try {
-            if (session.flushTimer) {
-                clearTimeout(session.flushTimer);
-                session.flushTimer = null;
-            }
-            await flushSessionOutput(sessionId);
-            try {
-                session.ptyProcess.kill();
-            }
-            catch {
-                // ignore kill errors
-            }
-            sessions.delete(sessionId);
-            stoppedPty.push(sessionId);
-            await sendStatus(session.agentId, null, 'stopped');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            errors.push(`PTY ${sessionId}: ${errorMessage}`);
-        }
-    }
-    // 2. 停止所有 SDK 会话
+    // 1. 停止所有 SDK 会话
     for (const [sessionId, entry] of sdkSessions.entries()) {
         try {
             // 根据 providerId 获取对应的 adapter
@@ -660,6 +828,7 @@ terminalRouter.post('/stop-all', validateToken, async (_req, res) => {
             const adapter = adapterRegistry.get(providerId);
             await adapter.terminateSession(sessionId);
             sdkSessions.delete(sessionId);
+            stopTerminalCommandProcess(sessionId);
             stoppedSdk.push(sessionId);
             await sendStatus(entry.agentId, null, 'stopped');
         }
@@ -668,7 +837,7 @@ terminalRouter.post('/stop-all', validateToken, async (_req, res) => {
             errors.push(`SDK ${sessionId}: ${errorMessage}`);
         }
     }
-    // 3. 清理持久化状态，避免 stop-all 后还能被恢复
+    // 2. 清理持久化状态，避免 stop-all 后还能被恢复
     // 直接清空整个持久化文件，确保不会有残留
     try {
         await savePersistedSessions([]);
@@ -681,7 +850,6 @@ terminalRouter.post('/stop-all', validateToken, async (_req, res) => {
     res.json({
         ok: true,
         stopped: {
-            pty: stoppedPty.length,
             sdk: stoppedSdk.length,
         },
         errors: errors.length > 0 ? errors : undefined,