@xiaoqiong0v0/opencode-ssh-tool 0.2.7 → 0.4.0

package/dist/index.js

@@ -1,5 +1,7 @@
 // 插件入口：导出 5 个 SSH 工具 + 会话生命周期管理 + HTTP 终端记录服务
 import { tool } from "@opencode-ai/plugin";
+import stringArgv from "string-argv";
+import { parseArgs } from "node:util";
 import createLogger from "@xiaoqiong0v0/opencode-plugin-logger";
 import { CACHE_DIR } from "./constants.js";
 import { homedir } from "node:os";
@@ -10,9 +12,10 @@ import { SessionHistory } from "./history.js";
 import { T, getLang, tr } from "./i18n.js";
 import { createDecider } from "./permission.js";
 import { SshSession } from "./session.js";
+import { LocalSession } from "./local-session.js";
 import {} from "./server.js";
 import { ensureServer } from "./server-manager.js";
-import { writeSessionState, removeSessionState } from "./session-store.js";
+import { writeSessionState, removeSessionState, removeAllSessionStates } from "./session-store.js";
 const log = createLogger("opencode-ssh-tool");
 /** 默认终端名（不传 name 时用） */
 const DEFAULT_NAME = "default";
@@ -32,17 +35,22 @@ function sanitizeName(name) {
 }
 /** 会话表：key = opencode sessionID → 内层 key = 终端名 → SshSession（内部状态，不导出） */
 const sshSessions = new Map();
+/** 本地/容器会话表：key = sessionID → 终端名 → LocalSession（Bun.Terminal，内部状态） */
+const localSessions = new Map();
 /** 会话元信息（标题/目录，供 HTTP 页面显示），key = sessionID */
 const sessionMeta = new Map();
 /** HTTP 终端记录服务句柄（本进程持有，可能为 null） */
 let httpServer = null;
 /** HTTP 服务已知地址（本进程启动或复用时记录，供展示） */
 let httpUrl = "";
-/** 进程退出兜底：关闭全部连接 + 关闭本进程持有的 HTTP 服务 */
+/** 进程退出兜底：关闭全部连接（SSH + 本地终端）+ 关闭本进程持有的 HTTP 服务 */
 process.on("exit", () => {
     for (const map of sshSessions.values())
         for (const s of map.values())
             s.close();
+    for (const map of localSessions.values())
+        for (const s of map.values())
+            s.close();
     if (httpServer) {
         try {
             httpServer.close();
@@ -71,22 +79,25 @@ function listSessionEntries() {
     return entries;
 }
 /**
- * 同步某终端状态到共享文件（跨进程聚合展示用）
+ * 同步某终端状态到共享文件（跨进程聚合展示用，SSH 与本地/容器通用）
  * @param sessionID opencode 会话 ID
  * @param name 终端名（默认 default）
  */
 function syncSessionState(sessionID, name = DEFAULT_NAME) {
-    const session = getSession(sessionID, name);
+    const session = resolveSession(sessionID, name);
     if (!session)
         return;
     const st = session.getStatus();
     const meta = sessionMeta.get(sessionID);
+    const isLocal = !("host" in st) || !st.host;
     writeSessionState(cacheRoot(), {
         sessionID,
         name,
-        host: st.host,
-        user: st.user,
-        port: st.port,
+        kind: isLocal ? "local" : "ssh",
+        host: "host" in st ? st.host : undefined,
+        user: "user" in st ? st.user : undefined,
+        port: "port" in st ? st.port : undefined,
+        program: "program" in st ? st.program : undefined,
         connected: st.connected,
         busy: st.busy,
         pending: st.pending,
@@ -97,6 +108,47 @@ function syncSessionState(sessionID, name = DEFAULT_NAME) {
         updatedAt: Date.now(),
     });
 }
+/** 按 sessionID 取本地/容器终端表（无则返回 undefined） */
+function getLocalSessionMap(sessionID) {
+    return localSessions.get(sessionID);
+}
+/** 按 sessionID + 终端名取本地/容器会话（name 默认 default） */
+function getLocalSession(sessionID, name = DEFAULT_NAME) {
+    return getLocalSessionMap(sessionID)?.get(name);
+}
+/** 解析终端会话：优先 SSH，其次本地/容器（合并后的操作工具统一用此查找） */
+function resolveSession(sessionID, name = DEFAULT_NAME) {
+    return getSession(sessionID, name) ?? getLocalSession(sessionID, name);
+}
+/** 清理指定本地终端：关闭 + 删状态文件 + 从会话表移除 */
+function cleanupLocalSession(sessionID, name = DEFAULT_NAME) {
+    const map = getLocalSessionMap(sessionID);
+    const session = map?.get(name);
+    if (session) {
+        session.close();
+        map.delete(name);
+        if (map.size === 0)
+            localSessions.delete(sessionID);
+    }
+    removeSessionState(cacheRoot(), sessionID, name);
+}
+/** 清理一个 sessionID 下全部本地终端 */
+function cleanupAllLocalSessions(sessionID) {
+    const map = getLocalSessionMap(sessionID);
+    if (map) {
+        for (const s of map.values())
+            s.close();
+        localSessions.delete(sessionID);
+    }
+    // 无论内存是否有句柄都清残留：状态文件 + 历史目录（含其他进程建的会话）
+    removeAllSessionStates(cacheRoot(), sessionID);
+    try {
+        rmSync(join(cacheRoot(), sessionID), { recursive: true, force: true });
+    }
+    catch {
+        /* 忽略 */
+    }
+}
 /** 插件缓存根目录（历史消息对存文件，随会话清理） */
 function cacheRoot() {
     const home = process.env.USERPROFILE || process.env.HOME || homedir();
@@ -129,17 +181,15 @@ function cleanupAllSessions(sessionID) {
     if (map) {
         for (const s of map.values())
             s.close();
-        for (const name of map.keys())
-            removeSessionState(cacheRoot(), sessionID, name);
         sshSessions.delete(sessionID);
     }
-    else {
-        try {
-            rmSync(join(cacheRoot(), sessionID), { recursive: true, force: true });
-        }
-        catch {
-            /* 忽略 */
-        }
+    // 无论内存是否有句柄都清残留：状态文件 + 历史目录（含其他进程建的会话）
+    removeAllSessionStates(cacheRoot(), sessionID);
+    try {
+        rmSync(join(cacheRoot(), sessionID), { recursive: true, force: true });
+    }
+    catch {
+        /* 忽略 */
     }
 }
 export const OpenCodeSshTool = async () => {
@@ -152,7 +202,7 @@ export const OpenCodeSshTool = async () => {
     const decide = createDecider(cfg.permission.deny, cfg.permission.allow);
     if (cfg.server.enabled) {
         try {
-            const sr = await ensureServer(cfg.server.port, listSessionEntries, cacheRoot());
+            const sr = await ensureServer(cfg.server.port, listSessionEntries, cacheRoot(), getLang(cfg.webLang));
             if (sr.server) {
                 httpServer = sr.server;
                 httpUrl = sr.url;
@@ -173,6 +223,236 @@ export const OpenCodeSshTool = async () => {
     else {
         log.info("HTTP 服务未启用（配置 server.enabled=false）");
     }
+    // ===== CLI 风格单工具（ssh_cli）子命令实现 =====
+    /** 完整用法（模型自学手册） */
+    const HELP_TEXT = tr("ssh_cli_help", lang);
+    /** connect：SSH 连接（target=user@host[:port]） */
+    async function doConnect(args, ctx) {
+        const { values, positionals } = parseArgs({ args, options: { name: { type: "string", short: "n" }, password: { type: "string", short: "p" }, user: { type: "string", short: "u" } }, allowPositionals: true });
+        const target = positionals[0] ?? "";
+        const m = target.match(/^(?:([^@]+)@)?([^:]+)(?::(\d+))?$/);
+        if (!m || !m[2])
+            return `${tr("cli_bad_target", lang).replace("{target}", target)}\n${tr("cli_connect_usage", lang)}\n\n${HELP_TEXT}`;
+        const user = m[1] ?? values.user;
+        const host = m[2];
+        const port = m[3] ? parseInt(m[3], 10) : undefined;
+        if (!user || !host)
+            return `${tr("cli_need_user_host", lang)}\n${tr("cli_connect_usage", lang)}\n\n${HELP_TEXT}`;
+        const name = values.name ?? DEFAULT_NAME;
+        if (sanitizeName(name) === null)
+            return tr("invalid_name", lang);
+        try {
+            await ctx.ask({
+                permission: "ssh_connect",
+                patterns: [`${user}@${host}:${port ?? 22}`],
+                always: [`ssh_connect:${user}@${host}:${port ?? 22}`],
+                metadata: { title: `${user}@${host}` },
+            });
+        }
+        catch {
+            return tr("rejected_connect", lang);
+        }
+        const map = getSessionMap(ctx.sessionID);
+        const old = map?.get(name);
+        if (old) {
+            old.close();
+            map.delete(name);
+        }
+        const session = new SshSession(ctx.sessionID, new SessionHistory(join(cacheRoot(), ctx.sessionID), name, cfg.history.maxMessages), name);
+        const result = await session.connect({ host, user, port, password: values.password });
+        log.tool("ssh_connect", { host, user, port: port ?? 22, name });
+        if (!result.ok) {
+            session.close();
+            return `${tr("connect_title_fail", lang)}: ${result.error ?? tr("unknown_error", lang)}`;
+        }
+        if (!map)
+            sshSessions.set(ctx.sessionID, new Map());
+        sshSessions.get(ctx.sessionID).set(name, session);
+        syncSessionState(ctx.sessionID, name);
+        return tr("connect_ok", lang).replace("{user}", user).replace("{host}", host).replace("{port}", String(port ?? 22)).replace("{sid}", ctx.sessionID).replace("{name}", name);
+    }
+    /** local：本地/容器终端连接 */
+    async function doLocal(args, ctx) {
+        const { values, positionals } = parseArgs({ args, options: { name: { type: "string", short: "n" }, cwd: { type: "string", short: "c" } }, allowPositionals: true });
+        const command = positionals.join(" ");
+        if (!command)
+            return `${tr("cli_need_command", lang)}\n${tr("cli_local_usage", lang)}\n\n${HELP_TEXT}`;
+        const name = values.name ?? DEFAULT_NAME;
+        if (sanitizeName(name) === null)
+            return tr("invalid_name", lang);
+        const map = getLocalSessionMap(ctx.sessionID);
+        const old = map?.get(name);
+        if (old) {
+            old.close();
+            map.delete(name);
+        }
+        const session = new LocalSession(ctx.sessionID, new SessionHistory(join(cacheRoot(), ctx.sessionID), `local-${name}`, cfg.history.maxMessages), name);
+        const result = await session.connect({ command, cwd: values.cwd });
+        log.tool("local_connect", { command, name });
+        if (!result.ok) {
+            session.close();
+            return `${tr("local_connect_title_fail", lang)}: ${result.error ?? tr("unknown_error", lang)}`;
+        }
+        if (!map)
+            localSessions.set(ctx.sessionID, new Map());
+        localSessions.get(ctx.sessionID).set(name, session);
+        syncSessionState(ctx.sessionID, name);
+        return tr("local_connect_ok", lang).replace("{cmd}", command).replace("{name}", name);
+    }
+    /** exec：在指定终端执行命令 */
+    async function doExec(args, ctx) {
+        const { values, positionals } = parseArgs({ args, options: { name: { type: "string", short: "n" }, waitResult: { type: "boolean", short: "w" } }, allowPositionals: true });
+        const command = positionals.join(" ");
+        if (!command)
+            return `${tr("cli_need_command", lang)}\n${tr("cli_exec_usage", lang)}\n\n${HELP_TEXT}`;
+        const session = resolveSession(ctx.sessionID, values.name);
+        if (!session)
+            return tr("not_connected", lang);
+        const decision = decide(command);
+        if (decision === "deny") {
+            log.tool("term_exec_denied", { command });
+            return tr("denied_danger", lang);
+        }
+        if (decision === "ask") {
+            try {
+                await ctx.ask({ permission: "term_exec", patterns: [command], always: [`term_exec:${command}`], metadata: { title: command.slice(0, 60) } });
+            }
+            catch {
+                return tr("denied", lang);
+            }
+        }
+        const result = values.waitResult ? await session.exec(command) : await session.submit(command);
+        syncSessionState(ctx.sessionID, values.name ?? DEFAULT_NAME);
+        log.tool("term_exec", { command, ok: result.ok, submitted: result.submitted, interactive: result.interactive, running: result.running });
+        if (result.submitted)
+            return tr("submitted", lang);
+        return result.ok ? result.output : result.error ?? tr("exec_failed", lang);
+    }
+    /** read：读取终端输出 */
+    async function doRead(args, ctx) {
+        const { values } = parseArgs({ args, options: { name: { type: "string", short: "n" }, source: { type: "string", short: "s" }, limit: { type: "string", short: "l" }, head: { type: "boolean" }, includeCommand: { type: "boolean" } }, allowPositionals: true });
+        const session = resolveSession(ctx.sessionID, values.name);
+        if (!session)
+            return tr("not_connected", lang);
+        const source = values.source ?? "history";
+        if (source === "buffer") {
+            const r = await session.readBuffer();
+            return r.output;
+        }
+        const history = session.getHistory();
+        const all = history.getPairs();
+        const limit = Math.max(1, parseInt(values.limit ?? "10", 10) || 10);
+        const direction = values.head ? "head" : "tail";
+        const selected = direction === "tail" ? all.slice(-limit) : all.slice(0, limit);
+        const includeCommand = values.includeCommand ?? false;
+        const text = selected.map((p) => (includeCommand ? `$ ${p.command}\n${history.readOutput(p)}` : history.readOutput(p))).join("\n");
+        const browserLine = httpUrl ? tr("browser_full_record", lang).replace("{url}", httpUrl) : tr("server_not_enabled", lang);
+        return `${tr(direction === "tail" ? "history_title" : "history_title_head", lang).replace("{n}", String(selected.length)).replace("{total}", String(all.length))}\n${text}${browserLine}`;
+    }
+    /** send：发送文本/按键到终端 */
+    async function doSend(args, ctx) {
+        const { values, positionals } = parseArgs({ args, options: { name: { type: "string", short: "n" } }, allowPositionals: true });
+        const text = positionals.join(" ");
+        if (!text)
+            return `${tr("cli_need_text", lang)}\n${tr("cli_send_usage", lang)}\n\n${HELP_TEXT}`;
+        const session = resolveSession(ctx.sessionID, values.name);
+        if (!session)
+            return tr("not_connected", lang);
+        const r = session.send(text);
+        if (!r.ok)
+            return tr("err_not_connected", lang);
+        syncSessionState(ctx.sessionID, values.name ?? DEFAULT_NAME);
+        log.tool("term_send", { text: text.slice(0, 60), name: values.name ?? DEFAULT_NAME });
+        return tr("send_ok", lang).replace("{text}", text.slice(0, 60));
+    }
+    /** status：终端状态 */
+    async function doStatus(args, ctx) {
+        const { values } = parseArgs({ args, options: { name: { type: "string", short: "n" } }, allowPositionals: true });
+        const smap = getSessionMap(ctx.sessionID);
+        const lmap = getLocalSessionMap(ctx.sessionID);
+        if ((!smap || smap.size === 0) && (!lmap || lmap.size === 0))
+            return tr("no_sessions", lang);
+        let sessions;
+        if (values.name) {
+            const s = resolveSession(ctx.sessionID, values.name);
+            if (!s)
+                return tr("no_sessions", lang);
+            sessions = [s];
+        }
+        else {
+            sessions = [...(smap?.values() ?? []), ...(lmap?.values() ?? [])];
+        }
+        const parts = [];
+        for (const s of sessions) {
+            const st = s.getStatus();
+            if (!st.connected) {
+                parts.push(tr("session_disconnected", lang));
+                continue;
+            }
+            const connLine = "host" in st && st.host
+                ? `${tr("st_host", lang)}: ${st.host}@${st.user}:${st.port}`
+                : `${tr("st_program", lang)}: ${st.program ?? "-"}`;
+            parts.push([
+                `${tr("st_name", lang)}: ${st.name ?? "default"}`,
+                `${tr("st_type", lang)}: ${"host" in st ? "ssh" : "local"}`,
+                `${tr("st_connected", lang)}: ${st.connected}`,
+                `${tr("st_busy", lang)}: ${st.busy}`,
+                `${tr("st_pending", lang)}: ${st.pending} ${tr("st_bytes", lang)}`,
+                connLine,
+                st.lastActive ? `${tr("st_last_active", lang)}: ${new Date(st.lastActive).toISOString()}` : null,
+                st.connectedAt ? `${tr("st_connected_at", lang)}: ${new Date(st.connectedAt).toISOString()}` : null,
+            ].filter(Boolean).join("\n"));
+            parts.push(st.busy ? tr("status_busy_hint", lang) : tr("status_idle_hint", lang));
+        }
+        const serverLines = httpUrl
+            ? ["", `${tr("st_http_server", lang)}: ${httpUrl}`, `${tr("st_active_sessions", lang)}: ${listSessionEntries().length}`]
+            : ["", `${tr("st_http_server", lang)}: ${tr("st_disabled", lang)}`];
+        return parts.join("\n\n") + serverLines.join("\n");
+    }
+    /** disconnect：断开终端 */
+    async function doDisconnect(args, ctx) {
+        const { values } = parseArgs({ args, options: { name: { type: "string", short: "n" } }, allowPositionals: true });
+        const smap = getSessionMap(ctx.sessionID);
+        const lmap = getLocalSessionMap(ctx.sessionID);
+        if ((!smap || smap.size === 0) && (!lmap || lmap.size === 0))
+            return tr("no_sessions", lang);
+        if (!values.name) {
+            const firstHost = [...(smap?.values() ?? [])][0]?.getStatus().host;
+            cleanupAllSessions(ctx.sessionID);
+            cleanupAllLocalSessions(ctx.sessionID);
+            return tr("disconnected_all_ok", lang).replace("{host}", firstHost ?? "-");
+        }
+        const ssh = getSession(ctx.sessionID, values.name);
+        if (ssh) {
+            const host = ssh.getStatus().host;
+            cleanupSession(ctx.sessionID, values.name);
+            return tr("disconnected_ok", lang).replace("{host}", host ?? "-");
+        }
+        const local = getLocalSession(ctx.sessionID, values.name);
+        if (local) {
+            const program = local.getStatus().program;
+            cleanupLocalSession(ctx.sessionID, values.name);
+            return tr("disconnected_ok", lang).replace("{host}", program ?? "-");
+        }
+        return tr("no_sessions", lang);
+    }
+    /** CLI 入口：解析命令行字符串并分发子命令 */
+    async function handleCliCommand(raw, ctx) {
+        const tokens = stringArgv(raw);
+        const [cmd, ...rest] = tokens;
+        if (!cmd || cmd === "help")
+            return HELP_TEXT;
+        switch (cmd) {
+            case "connect": return doConnect(rest, ctx);
+            case "local": return doLocal(rest, ctx);
+            case "exec": return doExec(rest, ctx);
+            case "read": return doRead(rest, ctx);
+            case "send": return doSend(rest, ctx);
+            case "status": return doStatus(rest, ctx);
+            case "disconnect": return doDisconnect(rest, ctx);
+            default: return `${tr("cli_unknown", lang).replace("{cmd}", cmd)}\n\n${HELP_TEXT}`;
+        }
+    }
     return {
         event: async ({ event }) => {
             // 会话创建/更新时记录标题与目录（供 HTTP 页面显示会话名称）
@@ -189,264 +469,25 @@ export const OpenCodeSshTool = async () => {
             }
             // 会话删除时清理：关闭全部终端连接 + 删缓存目录 + 删元信息
             if (event.type === "session.deleted") {
-                const info = event.properties?.info;
-                const sid = info?.id;
+                const props = event.properties;
+                // sessionID 直接挂在 properties 层（完整事件）；info.id 为兜底
+                const sid = props?.sessionID ?? props?.info?.id;
                 if (sid) {
                     cleanupAllSessions(sid);
+                    cleanupAllLocalSessions(sid);
                     sessionMeta.delete(sid);
                     log.info(`会话 ${sid} 删除，已清理`);
                 }
             }
         },
         tool: {
-            ssh_connect: tool({
-                description: T.ssh_connect[lang],
-                args: {
-                    host: tool.schema.string().describe(T.ssh_connect_args.host[lang]),
-                    user: tool.schema.string().describe(T.ssh_connect_args.user[lang]),
-                    port: tool.schema.number().optional().describe(T.ssh_connect_args.port[lang]),
-                    name: tool.schema.string().optional().describe(T.ssh_connect_args.name[lang]),
-                    password: tool.schema.string().optional().describe(T.ssh_connect_args.password[lang]),
-                },
-                async execute(args, context) {
-                    const { sessionID } = context;
-                    const name = args.name ?? DEFAULT_NAME;
-                    if (sanitizeName(name) === null) {
-                        return tr("invalid_name", lang);
-                    }
-                    try {
-                        await context.ask({
-                            permission: "ssh_connect",
-                            patterns: [`${args.user}@${args.host}:${args.port ?? 22}`],
-                            always: [`ssh_connect:${args.user}@${args.host}:${args.port ?? 22}`],
-                            metadata: { title: `${args.user}@${args.host}` },
-                        });
-                    }
-                    catch {
-                        return tr("rejected_connect", lang);
-                    }
-                    // 同名终端已有连接 → 先关旧的
-                    const map = getSessionMap(sessionID);
-                    const old = map?.get(name);
-                    if (old) {
-                        old.close();
-                        map.delete(name);
-                    }
-                    const session = new SshSession(sessionID, new SessionHistory(join(cacheRoot(), sessionID), name, cfg.history.maxMessages), name);
-                    const result = await session.connect({ host: args.host, user: args.user, port: args.port, password: args.password });
-                    log.tool("ssh_connect", { host: args.host, user: args.user, port: args.port ?? 22, name });
-                    if (!result.ok) {
-                        session.close(); // 关闭连接 + 清理 history 缓存目录
-                        return {
-                            title: tr("connect_title_fail", lang),
-                            output: result.error ?? tr("unknown_error", lang),
-                        };
-                    }
-                    if (!map)
-                        sshSessions.set(sessionID, new Map());
-                    sshSessions.get(sessionID).set(name, session);
-                    syncSessionState(sessionID, name);
-                    return {
-                        title: `${tr("connect_title_ok", lang)} ${args.user}@${args.host}`,
-                        output: tr("connect_ok", lang)
-                            .replace("{user}", args.user)
-                            .replace("{host}", args.host)
-                            .replace("{port}", String(args.port ?? 22))
-                            .replace("{sid}", sessionID)
-                            .replace("{name}", name),
-                        metadata: { host: args.host, user: args.user, port: args.port ?? 22, name },
-                    };
-                },
-            }),
-            ssh_exec: tool({
-                description: T.ssh_exec[lang],
-                args: {
-                    command: tool.schema.string().describe(T.ssh_exec_args.command[lang]),
-                    waitResult: tool.schema.boolean().optional().describe(T.ssh_exec_args.waitResult[lang]),
-                    name: tool.schema.string().optional().describe(T.ssh_exec_args.name[lang]),
-                },
-                async execute(args, context) {
-                    const { sessionID } = context;
-                    const session = getSession(sessionID, args.name);
-                    if (!session)
-                        return tr("not_connected", lang);
-                    // 权限判定：先黑后白再问
-                    const decision = decide(args.command);
-                    if (decision === "deny") {
-                        log.tool("ssh_exec_denied", { command: args.command });
-                        return tr("denied_danger", lang);
-                    }
-                    if (decision === "ask") {
-                        log.info(`[ask] 命令需审批，调用 context.ask: ${args.command.slice(0, 60)}`);
-                        try {
-                            await context.ask({
-                                permission: "ssh_exec",
-                                patterns: [args.command],
-                                always: [`ssh_exec:${args.command}`],
-                                metadata: { title: args.command.slice(0, 60) },
-                            });
-                            log.info(`[ask] context.ask 返回（已允许）: ${args.command.slice(0, 60)}`);
-                        }
-                        catch {
-                            log.info(`[ask] context.ask 抛异常（已拒绝）: ${args.command.slice(0, 60)}`);
-                            return tr("denied", lang);
-                        }
-                    }
-                    // 默认异步提交（立即返回，不占上下文）；waitResult=true 同步等结果
-                    const result = args.waitResult ? await session.exec(args.command) : await session.submit(args.command);
-                    syncSessionState(sessionID, args.name ?? DEFAULT_NAME);
-                    log.tool("ssh_exec", { command: args.command, ok: result.ok, submitted: result.submitted, interactive: result.interactive, running: result.running });
-                    const meta = {
-                        host: result.host,
-                        command: result.command,
-                        duration: result.duration,
-                        submitted: result.submitted,
-                        interactive: result.interactive,
-                        running: result.running,
-                        timeout: result.timeout,
-                    };
-                    if (result.submitted) {
-                        return { title: tr("exec_title", lang).replace("{cmd}", args.command.slice(0, 60)), output: tr("submitted", lang), metadata: meta };
-                    }
-                    return {
-                        title: tr("exec_title", lang).replace("{cmd}", args.command.slice(0, 60)),
-                        output: result.ok ? result.output : result.error ?? tr("exec_failed", lang),
-                        metadata: meta,
-                    };
-                },
-            }),
-            ssh_read: tool({
-                description: T.ssh_read[lang],
-                args: {
-                    source: tool.schema.enum(["buffer", "history"]).optional().describe(T.ssh_read_args.source[lang]),
-                    lines: tool.schema.number().optional().describe(T.ssh_read_args.lines[lang]),
-                    direction: tool.schema.enum(["tail", "head"]).optional().describe(T.ssh_read_args.direction[lang]),
-                    limit: tool.schema.number().optional().describe(T.ssh_read_args.limit[lang]),
-                    includeCommand: tool.schema.boolean().optional().describe(T.ssh_read_args.includeCommand[lang]),
-                    name: tool.schema.string().optional().describe(T.ssh_read_args.name[lang]),
-                },
-                async execute(args, context) {
-                    const session = getSession(context.sessionID, args.name);
-                    if (!session)
-                        return tr("not_connected", lang);
-                    const source = args.source ?? "history";
-                    if (source === "buffer") {
-                        // 实时未消费缓冲
-                        const r = await session.readBuffer();
-                        const out = args.lines ? r.output.split(/\r?\n/).slice(0, args.lines).join("\n") : r.output;
-                        return { title: tr("session_output_title", lang), output: out };
-                    }
-                    // history：已完成命令+输出对（前 N / 后 N）
-                    const history = session.getHistory();
-                    const all = history.getPairs();
-                    const limit = Math.max(1, args.limit ?? 10);
-                    const direction = args.direction ?? "tail";
-                    const selected = direction === "tail" ? all.slice(-limit) : all.slice(0, limit);
-                    const total = all.length;
-                    const includeCommand = args.includeCommand ?? false;
-                    const text = selected
-                        .map((p) => (includeCommand ? `$ ${p.command}\n${history.readOutput(p)}` : history.readOutput(p)))
-                        .join("\n");
-                    const browserLine = httpUrl
-                        ? tr("browser_full_record", lang).replace("{url}", httpUrl)
-                        : tr("server_not_enabled", lang);
-                    const titleKey = direction === "tail" ? "history_title" : "history_title_head";
-                    return {
-                        title: tr(titleKey, lang).replace("{n}", String(selected.length)).replace("{total}", String(total)),
-                        output: text + browserLine,
-                        metadata: {
-                            direction,
-                            returned: selected.length,
-                            total,
-                            sessionID: context.sessionID,
-                            host: session.getStatus().host,
-                        },
-                    };
-                },
-            }),
-            ssh_send: tool({
-                description: T.ssh_send[lang],
-                args: {
-                    text: tool.schema.string().describe(T.ssh_send_args.text[lang]),
-                    name: tool.schema.string().optional().describe(T.ssh_send_args.name[lang]),
-                },
-                async execute(args, context) {
-                    const session = getSession(context.sessionID, args.name);
-                    if (!session)
-                        return tr("not_connected", lang);
-                    const r = session.send(args.text);
-                    if (!r.ok)
-                        return tr("err_not_connected", lang);
-                    syncSessionState(context.sessionID, args.name ?? DEFAULT_NAME);
-                    log.tool("ssh_send", { text: args.text.slice(0, 60), name: args.name ?? DEFAULT_NAME });
-                    return { title: tr("send_title", lang), output: tr("send_ok", lang).replace("{text}", args.text.slice(0, 60)) };
-                },
-            }),
-            ssh_status: tool({
-                description: T.ssh_status[lang],
-                args: {
-                    name: tool.schema.string().optional().describe(T.ssh_status_args.name[lang]),
-                },
-                async execute(args, context) {
-                    const map = getSessionMap(context.sessionID);
-                    if (!map || map.size === 0)
-                        return tr("no_sessions", lang);
-                    // 未指定 name → 列出全部终端状态
-                    const session = args.name ? map.get(args.name) : undefined;
-                    if (args.name && !session)
-                        return tr("no_sessions", lang);
-                    const sessions = session ? [session] : [...map.values()];
-                    const parts = [];
-                    for (const s of sessions) {
-                        const st = s.getStatus();
-                        if (!st.connected) {
-                            parts.push(tr("session_disconnected", lang));
-                            continue;
-                        }
-                        parts.push([
-                            `name: ${st.name ?? "default"}`,
-                            `connected: ${st.connected}`,
-                            `busy: ${st.busy}`,
-                            `pending: ${st.pending} bytes`,
-                            `host: ${st.host}@${st.user}:${st.port}`,
-                            st.lastActive ? `lastActive: ${new Date(st.lastActive).toISOString()}` : null,
-                            st.connectedAt ? `connectedAt: ${new Date(st.connectedAt).toISOString()}` : null,
-                        ].filter(Boolean).join("\n"));
-                        parts.push(st.busy ? tr("status_busy_hint", lang) : tr("status_idle_hint", lang));
-                    }
-                    // 并入 HTTP 服务状态
-                    const serverLines = httpUrl
-                        ? [
-                            "",
-                            `httpServer: ${httpUrl}`,
-                            `activeSessions: ${listSessionEntries().length}`,
-                        ]
-                        : ["", "httpServer: disabled"];
-                    return { title: tr("status_title", lang), output: parts.join("\n\n") + serverLines.join("\n") };
-                },
-            }),
-            ssh_disconnect: tool({
-                description: T.ssh_disconnect[lang],
+            ssh_cli: tool({
+                description: T.ssh_cli[lang],
                 args: {
-                    name: tool.schema.string().optional().describe(T.ssh_disconnect_args.name[lang]),
+                    args: tool.schema.string().optional().describe(T.ssh_cli_args[lang]),
                 },
                 async execute(args, context) {
-                    const { sessionID } = context;
-                    const map = getSessionMap(sessionID);
-                    if (!map || map.size === 0)
-                        return tr("no_sessions", lang);
-                    // 未指定 name → 断开全部终端；否则断开指定终端
-                    if (!args.name) {
-                        const host = [...map.values()][0]?.getStatus().host;
-                        cleanupAllSessions(sessionID);
-                        return tr("disconnected_all_ok", lang).replace("{host}", host ?? "-");
-                    }
-                    const session = map.get(args.name);
-                    if (!session)
-                        return tr("no_sessions", lang);
-                    const host = session.getStatus().host;
-                    cleanupSession(sessionID, args.name);
-                    return tr("disconnected_ok", lang).replace("{host}", host ?? "-");
+                    return { title: "ssh_cli", output: await handleCliCommand(args.args ?? "help", context) };
                 },
             }),
         },