minimal-agent 0.18.13 → 0.18.14

package/src/tools/advisor/advisorDecision.ts

@@ -1,92 +0,0 @@
-import { z } from 'zod';
-
-import { configService } from '../../config/configService.js';
-import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
-import { toToolParameters } from '../../utils/zodToJson.js';
-
-const inputSchema = z
-  .object({
-    consultationId: z
-      .string()
-      .min(1)
-      .describe('Advisor 工具正文返回的完整 consultationId，必须原样使用，不缩写或猜测'),
-    decision: z.enum(['accept', 'partial', 'reject']),
-    rationale: z
-      .string()
-      .min(8)
-      .max(20_000)
-      .describe('逐条说明主 Agent 基于一手证据、成果检查和用户验收条件作出的判断；顾问结论不能作为自身的证据'),
-    acceptedPoints: z.array(z.string().min(1).max(4_000)).max(20).optional()
-      .describe('一层字符串数组，例如 ["补充互操作成本"]；不要嵌套数组或 XML item 标签'),
-    rejectedPoints: z.array(z.string().min(1).max(4_000)).max(20).optional()
-      .describe('一层字符串数组，例如 ["不采纳必须学的措辞：证据不足"]'),
-    verificationPlan: z.array(z.string().min(1).max(4_000)).max(20).optional()
-      .describe('一层字符串数组，每项一个待验证步骤；没有则省略'),
-    evidenceRefs: z.array(z.string().min(1).max(300)).max(40).optional()
-      .describe('已核对的一手工具结果 tool_call_id，必须真实存在。rationale 说明每条建议对应哪个引用；没有证据则省略并列 verificationPlan，记录为待验证而非通过'),
-  })
-  .superRefine((value, ctx) => {
-    if (
-      value.decision === 'partial' &&
-      (!value.acceptedPoints?.length || !value.rejectedPoints?.length)
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ['decision'],
-        message: 'partial 必须同时列出 acceptedPoints 和 rejectedPoints',
-      });
-    }
-    if (value.decision === 'reject' && !value.rejectedPoints?.length) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ['rejectedPoints'],
-        message: 'reject 必须列出被拒绝的顾问意见',
-      });
-    }
-  });
-
-type AdvisorDecisionInput = z.infer<typeof inputSchema>;
-
-async function callWithContext(
-  input: AdvisorDecisionInput,
-  _signal: AbortSignal | undefined,
-  context: ToolCallContext,
-): Promise<ToolResult> {
-  if (!context.advisorRuntime) {
-    return { ok: false, error: '当前运行没有待处理的 Advisor 协调器状态。' };
-  }
-  return context.advisorRuntime.recordDecision(input);
-}
-
-export const advisorDecisionTool: Tool<AdvisorDecisionInput> = {
-  name: 'AdvisorDecision',
-  description:
-    "Records the main Agent's evidence-based decision after a successful Advisor consultation. " +
-    'Optional audit record; this is not an execution or delivery gate. A recording error does not block the task. ' +
-    'The Advisor is a second opinion, not an authority: choose accept, partial, or reject based on primary evidence. ' +
-    'For partial/reject, explicitly identify rejected points and explain primary evidence and acceptance constraints. ' +
-    'Link evidenceRefs (existing tool_call_id) to points in rationale. Missing evidence is recorded as pending verification, not verified; continue the verificationPlan without another approval. A linked reference alone does not prove correctness.',
-  inputSchema,
-  parameters: toToolParameters(inputSchema),
-  isReadOnly: true,
-  isConcurrencySafe: false,
-  interruptBehavior: () => 'cancel',
-  resolveAvailability() {
-    const avail = configService.advisorAvailabilitySync();
-    if (!avail.configured) return { available: false, signature: 'unconfigured' };
-    if (!avail.enabled || avail.mode === 'manual') {
-      return {
-        available: false,
-        signature: avail.enabled ? 'manual-only' : 'disabled',
-      };
-    }
-    return { available: true, signature: avail.modelId! };
-  },
-  async call(): Promise<ToolResult> {
-    return {
-      ok: false,
-      error: 'AdvisorDecision 只能在主 Agent 会话的 Advisor 咨询后调用。',
-    };
-  },
-  callWithContext,
-};

package/src/tools/ssh/ssh.js

@@ -1,152 +0,0 @@
-/**
- * ============================================================
- *  src/tools/ssh/ssh.ts —— SSH 工具：在已配置的远程主机上执行命令
- * ------------------------------------------------------------
- *  主机凭据按工作区（workspaceId）隔离存储（见 context/sshHosts.ts），模型
- *  只看到 alias，真实 host/密码不进上下文。危险命令复用本地 Bash 同一套
- *  permanentDeleteReason() 判据（remoteShell 来自主机配置，不许硬编码），
- *  但拒绝文案是远程专属的——本地的 Trash 是纯本地能力，够不着远程路径。
- * ============================================================
- */
-import { randomUUID } from 'node:crypto';
-import { z } from 'zod';
-import { resolveSshHost } from '../../context/sshHosts.js';
-import { CONFIG_LIMITS } from '../../config/numericLimits.js';
-import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
-import { toToolParameters } from '../../utils/zodToJson.js';
-import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { resolveSshToolAvailability } from './sshAvailability.js';
-import { DEFAULT_SSH_TIMEOUT_MS, defaultSshConnect, SshExecTimeoutError } from './sshClient.js';
-const BACKGROUND_CONFIRM_TIMEOUT_MS = 8_000;
-const inputSchema = z.object({
-    host: z.string().optional().describe('已配置的 SSH 主机别名；不填则使用该工作区的默认主机（不确定有哪些主机时先调用 SSHHosts）'),
-    command: z.string().min(1).describe('要在远程主机上执行的命令'),
-    timeoutMs: z.number().int().min(CONFIG_LIMITS.sshTimeoutMs.min).max(CONFIG_LIMITS.sshTimeoutMs.max).optional()
-        .describe('本次执行超时（毫秒），默认 30000'),
-    background: z.boolean().optional()
-        .describe('true 时把命令包装为后台任务（setsid+nohup+日志重定向）立即返回 PID，仅支持 remoteShell=bash 的主机；用于启动长期运行的服务/进程'),
-});
-function shQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-async function callWith(input, signal, context, resolveHost, connectImpl) {
-    const workspaceId = context?.workspaceId;
-    if (!workspaceId) {
-        return { ok: false, error: '当前运行环境没有工作区身份，无法解析 SSH 主机配置（SSH 主机按工作区隔离存储）。', recovery: 'none' };
-    }
-    const resolved = await resolveHost(workspaceId, input.host);
-    if (!resolved.ok)
-        return { ok: false, error: resolved.error, recovery: 'change-input' };
-    const host = resolved.host;
-    if (input.background && host.remoteShell !== 'bash') {
-        return {
-            ok: false,
-            error: `主机 "${host.alias}" 的 remoteShell 是 "${host.remoteShell}"，background 模式目前只支持 bash。请自行在命令里处理后台化。`,
-            recovery: 'change-input',
-        };
-    }
-    const timeoutMs = input.timeoutMs ?? host.timeoutMs ?? DEFAULT_SSH_TIMEOUT_MS;
-    let connection;
-    try {
-        connection = await connectImpl(host, timeoutMs);
-    }
-    catch (error) {
-        return { ok: false, error: `连接主机 "${host.alias}" 失败：${error instanceof Error ? error.message : String(error)}`, recovery: 'retry' };
-    }
-    try {
-        if (input.background) {
-            const logPath = `/tmp/.minimal-agent-ssh-bg-${randomUUID().slice(0, 8)}.log`;
-            const wrapped = `setsid nohup sh -c ${shQuote(input.command)} </dev/null >${logPath} 2>&1 & echo $!`;
-            try {
-                const result = await connection.exec(wrapped, BACKGROUND_CONFIRM_TIMEOUT_MS);
-                const pid = result.stdout.trim().match(/^\d+$/m)?.[0];
-                return {
-                    ok: true,
-                    content: `已在 "${host.alias}" 后台启动命令。${pid ? `PID: ${pid}。` : ''}日志：${logPath}\n` +
-                        `验证请开新的 SSH 调用（不要在同一次调用里等待），示例：\n` +
-                        `  ssh(host="${host.alias}", command="tail -n 50 ${logPath}")\n` +
-                        `  ssh(host="${host.alias}", command="ps aux | grep '[标记词]' | awk '{print $2}'")（该主机可能没有 pkill，杀进程用 kill <PID>）`,
-                    sensitivity: 'local',
-                };
-            }
-            catch (error) {
-                if (error instanceof SshExecTimeoutError) {
-                    // 通道因后台进程存在而不主动关闭是预期行为（Jetson 类设备上反复验证过）——
-                    // 命令已经真的在后台跑起来了，按失败处理会诱使模型重复提交，产生重复进程。
-                    return {
-                        ok: true,
-                        content: `已向 "${host.alias}" 提交后台命令；SSH 通道未在 ${BACKGROUND_CONFIRM_TIMEOUT_MS}ms 内关闭（后台进程存在时这是预期行为，不代表失败）。` +
-                            `未能读取到确认输出（PID/日志句柄）。日志：${logPath}\n` +
-                            `请开新的 SSH 调用验证：ssh(host="${host.alias}", command="cat ${logPath}")`,
-                        sensitivity: 'local',
-                    };
-                }
-                throw error;
-            }
-        }
-        const reason = permanentDeleteReason(input.command, host.remoteShell);
-        if (reason) {
-            return {
-                ok: false,
-                error: '该命令可能绕过删除防护、在远程主机上不可恢复（远程没有本地回收站）。建议改用 mv 把目标移到远程临时目录确认无误后再删除，或先用只读命令确认影响范围并询问用户。',
-                recovery: 'change-input',
-            };
-        }
-        const result = await connection.exec(input.command, timeoutMs);
-        const parts = [];
-        if (result.stdout)
-            parts.push(`<stdout>\n${result.stdout}\n</stdout>`);
-        if (result.stderr)
-            parts.push(`<stderr>\n${result.stderr}\n</stderr>`);
-        parts.push(`[exit code: ${result.code ?? (result.signal ? `killed(${result.signal})` : 'unknown')}]`);
-        let content = parts.join('\n\n');
-        if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-            content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) +
-                `\n\n... (输出超过 ${DEFAULT_MAX_RESULT_SIZE_CHARS} 字符，已截断)`;
-        }
-        if (result.code !== 0) {
-            return { ok: false, error: `远程命令失败 (exit ${result.code})：\n${content}`, recovery: 'retry', sensitivity: 'local' };
-        }
-        return { ok: true, content, sensitivity: 'local' };
-    }
-    catch (error) {
-        if (signal?.aborted)
-            return { ok: false, error: 'SSH 执行已取消', recovery: 'none' };
-        if (error instanceof SshExecTimeoutError) {
-            const partialParts = [];
-            if (error.partialStdout)
-                partialParts.push(`<stdout(partial)>\n${error.partialStdout}\n</stdout(partial)>`);
-            if (error.partialStderr)
-                partialParts.push(`<stderr(partial)>\n${error.partialStderr}\n</stderr(partial)>`);
-            let partial = partialParts.length > 0
-                ? `\n\n超时前已产生的部分输出（命令可能仍在远程后台继续运行）：\n${partialParts.join('\n')}`
-                : '';
-            // partialStdout/partialStderr 各自最多 2×DEFAULT_MAX_RESULT_SIZE_CHARS（见 sshClient.ts 的
-            // MAX_EXEC_BUFFER_CHARS），两路拼起来可达其 4 倍——这里同样按展示层阈值截断，不能指望有
-            // 下游机制兜底（webbrowser.ts 已有先例：maxResultSizeChars 只是声明，全仓没人统一消费它）。
-            if (partial.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-                partial = partial.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) +
-                    `\n\n... (部分输出超过 ${DEFAULT_MAX_RESULT_SIZE_CHARS} 字符，已截断)`;
-            }
-            return { ok: false, error: `${error.message}${partial}`, recovery: 'retry' };
-        }
-        return { ok: false, error: `SSH 执行失败：${error instanceof Error ? error.message : String(error)}`, recovery: 'retry' };
-    }
-    finally {
-        connection.end();
-    }
-}
-export function createSshTool(resolveHost = resolveSshHost, connectImpl = defaultSshConnect) {
-    return {
-        name: 'SSH',
-        description: '在已配置的远程 SSH 主机上执行一条命令，返回 stdout/stderr/exit code。主机由用户在 /config → 远程主机(SSH) 中配置，按当前工作区隔离；不确定有哪些主机时先调用 SSHHosts。每次调用都是一条独立的新连接：cd、环境变量（export/conda activate 等）在内的所有 shell 状态不会跨调用保留，每次都从远程默认工作目录/默认环境重新开始；需要连续在同一目录/环境下操作时，把多条命令用 && 拼进同一次调用。',
-        inputSchema,
-        parameters: toToolParameters(inputSchema),
-        isReadOnly: false,
-        maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-        resolveAvailability: resolveSshToolAvailability,
-        call: (input, signal) => callWith(input, signal, undefined, resolveHost, connectImpl),
-        callWithContext: (input, signal, context) => callWith(input, signal, context, resolveHost, connectImpl),
-    };
-}
-export const sshTool = createSshTool();

package/src/tools/ssh/ssh.ts

@@ -1,167 +0,0 @@
-/**
- * ============================================================
- *  src/tools/ssh/ssh.ts —— SSH 工具：在已配置的远程主机上执行命令
- * ------------------------------------------------------------
- *  主机凭据按工作区（workspaceId）隔离存储（见 context/sshHosts.ts），模型
- *  只看到 alias，真实 host/密码不进上下文。危险命令复用本地 Bash 同一套
- *  permanentDeleteReason() 判据（remoteShell 来自主机配置，不许硬编码），
- *  但拒绝文案是远程专属的——本地的 Trash 是纯本地能力，够不着远程路径。
- * ============================================================
- */
-
-import { randomUUID } from 'node:crypto';
-import { z } from 'zod';
-
-import { resolveSshHost } from '../../context/sshHosts.js';
-import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
-import { CONFIG_LIMITS } from '../../config/numericLimits.js';
-import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
-import { toToolParameters } from '../../utils/zodToJson.js';
-import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { resolveSshToolAvailability } from './sshAvailability.js';
-import { DEFAULT_SSH_TIMEOUT_MS, defaultSshConnect, SshExecTimeoutError, type SshConnectImpl } from './sshClient.js';
-
-const BACKGROUND_CONFIRM_TIMEOUT_MS = 8_000;
-
-const inputSchema = z.object({
-  host: z.string().optional().describe('已配置的 SSH 主机别名；不填则使用该工作区的默认主机（不确定有哪些主机时先调用 SSHHosts）'),
-  command: z.string().min(1).describe('要在远程主机上执行的命令'),
-  timeoutMs: z.number().int().min(CONFIG_LIMITS.sshTimeoutMs.min).max(CONFIG_LIMITS.sshTimeoutMs.max).optional()
-    .describe('本次执行超时（毫秒），默认 30000'),
-  background: z.boolean().optional()
-    .describe('true 时把命令包装为后台任务（setsid+nohup+日志重定向）立即返回 PID，仅支持 remoteShell=bash 的主机；用于启动长期运行的服务/进程'),
-});
-
-type SshInput = z.infer<typeof inputSchema>;
-
-function shQuote(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-
-async function callWith(
-  input: SshInput,
-  signal: AbortSignal | undefined,
-  context: ToolCallContext | undefined,
-  resolveHost: typeof resolveSshHost,
-  connectImpl: SshConnectImpl,
-): Promise<ToolResult> {
-  const workspaceId = context?.workspaceId;
-  if (!workspaceId) {
-    return { ok: false, error: '当前运行环境没有工作区身份，无法解析 SSH 主机配置（SSH 主机按工作区隔离存储）。', recovery: 'none' };
-  }
-  const resolved = await resolveHost(workspaceId, input.host);
-  if (!resolved.ok) return { ok: false, error: resolved.error, recovery: 'change-input' };
-  const host = resolved.host;
-
-  if (input.background && host.remoteShell !== 'bash') {
-    return {
-      ok: false,
-      error: `主机 "${host.alias}" 的 remoteShell 是 "${host.remoteShell}"，background 模式目前只支持 bash。请自行在命令里处理后台化。`,
-      recovery: 'change-input',
-    };
-  }
-
-  const timeoutMs = input.timeoutMs ?? host.timeoutMs ?? DEFAULT_SSH_TIMEOUT_MS;
-  let connection;
-  try {
-    connection = await connectImpl(host, timeoutMs);
-  } catch (error) {
-    return { ok: false, error: `连接主机 "${host.alias}" 失败：${error instanceof Error ? error.message : String(error)}`, recovery: 'retry' };
-  }
-
-  try {
-    if (input.background) {
-      const logPath = `/tmp/.minimal-agent-ssh-bg-${randomUUID().slice(0, 8)}.log`;
-      const wrapped = `setsid nohup sh -c ${shQuote(input.command)} </dev/null >${logPath} 2>&1 & echo $!`;
-      try {
-        const result = await connection.exec(wrapped, BACKGROUND_CONFIRM_TIMEOUT_MS);
-        const pid = result.stdout.trim().match(/^\d+$/m)?.[0];
-        return {
-          ok: true,
-          content: `已在 "${host.alias}" 后台启动命令。${pid ? `PID: ${pid}。` : ''}日志：${logPath}\n` +
-            `验证请开新的 SSH 调用（不要在同一次调用里等待），示例：\n` +
-            `  ssh(host="${host.alias}", command="tail -n 50 ${logPath}")\n` +
-            `  ssh(host="${host.alias}", command="ps aux | grep '[标记词]' | awk '{print $2}'")（该主机可能没有 pkill，杀进程用 kill <PID>）`,
-          sensitivity: 'local',
-        };
-      } catch (error) {
-        if (error instanceof SshExecTimeoutError) {
-          // 通道因后台进程存在而不主动关闭是预期行为（Jetson 类设备上反复验证过）——
-          // 命令已经真的在后台跑起来了，按失败处理会诱使模型重复提交，产生重复进程。
-          return {
-            ok: true,
-            content: `已向 "${host.alias}" 提交后台命令；SSH 通道未在 ${BACKGROUND_CONFIRM_TIMEOUT_MS}ms 内关闭（后台进程存在时这是预期行为，不代表失败）。` +
-              `未能读取到确认输出（PID/日志句柄）。日志：${logPath}\n` +
-              `请开新的 SSH 调用验证：ssh(host="${host.alias}", command="cat ${logPath}")`,
-            sensitivity: 'local',
-          };
-        }
-        throw error;
-      }
-    }
-
-    const reason = permanentDeleteReason(input.command, host.remoteShell);
-    if (reason) {
-      return {
-        ok: false,
-        error: '该命令可能绕过删除防护、在远程主机上不可恢复（远程没有本地回收站）。建议改用 mv 把目标移到远程临时目录确认无误后再删除，或先用只读命令确认影响范围并询问用户。',
-        recovery: 'change-input',
-      };
-    }
-
-    const result = await connection.exec(input.command, timeoutMs);
-    const parts: string[] = [];
-    if (result.stdout) parts.push(`<stdout>\n${result.stdout}\n</stdout>`);
-    if (result.stderr) parts.push(`<stderr>\n${result.stderr}\n</stderr>`);
-    parts.push(`[exit code: ${result.code ?? (result.signal ? `killed(${result.signal})` : 'unknown')}]`);
-    let content = parts.join('\n\n');
-    if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-      content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) +
-        `\n\n... (输出超过 ${DEFAULT_MAX_RESULT_SIZE_CHARS} 字符，已截断)`;
-    }
-    if (result.code !== 0) {
-      return { ok: false, error: `远程命令失败 (exit ${result.code})：\n${content}`, recovery: 'retry', sensitivity: 'local' };
-    }
-    return { ok: true, content, sensitivity: 'local' };
-  } catch (error) {
-    if (signal?.aborted) return { ok: false, error: 'SSH 执行已取消', recovery: 'none' };
-    if (error instanceof SshExecTimeoutError) {
-      const partialParts: string[] = [];
-      if (error.partialStdout) partialParts.push(`<stdout(partial)>\n${error.partialStdout}\n</stdout(partial)>`);
-      if (error.partialStderr) partialParts.push(`<stderr(partial)>\n${error.partialStderr}\n</stderr(partial)>`);
-      let partial = partialParts.length > 0
-        ? `\n\n超时前已产生的部分输出（命令可能仍在远程后台继续运行）：\n${partialParts.join('\n')}`
-        : '';
-      // partialStdout/partialStderr 各自最多 2×DEFAULT_MAX_RESULT_SIZE_CHARS（见 sshClient.ts 的
-      // MAX_EXEC_BUFFER_CHARS），两路拼起来可达其 4 倍——这里同样按展示层阈值截断，不能指望有
-      // 下游机制兜底（webbrowser.ts 已有先例：maxResultSizeChars 只是声明，全仓没人统一消费它）。
-      if (partial.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-        partial = partial.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) +
-          `\n\n... (部分输出超过 ${DEFAULT_MAX_RESULT_SIZE_CHARS} 字符，已截断)`;
-      }
-      return { ok: false, error: `${error.message}${partial}`, recovery: 'retry' };
-    }
-    return { ok: false, error: `SSH 执行失败：${error instanceof Error ? error.message : String(error)}`, recovery: 'retry' };
-  } finally {
-    connection.end();
-  }
-}
-
-export function createSshTool(
-  resolveHost: typeof resolveSshHost = resolveSshHost,
-  connectImpl: SshConnectImpl = defaultSshConnect,
-): Tool<SshInput> {
-  return {
-    name: 'SSH',
-    description: '在已配置的远程 SSH 主机上执行一条命令，返回 stdout/stderr/exit code。主机由用户在 /config → 远程主机(SSH) 中配置，按当前工作区隔离；不确定有哪些主机时先调用 SSHHosts。每次调用都是一条独立的新连接：cd、环境变量（export/conda activate 等）在内的所有 shell 状态不会跨调用保留，每次都从远程默认工作目录/默认环境重新开始；需要连续在同一目录/环境下操作时，把多条命令用 && 拼进同一次调用。',
-    inputSchema,
-    parameters: toToolParameters(inputSchema),
-    isReadOnly: false,
-    maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-    resolveAvailability: resolveSshToolAvailability,
-    call: (input, signal) => callWith(input, signal, undefined, resolveHost, connectImpl),
-    callWithContext: (input, signal, context) => callWith(input, signal, context, resolveHost, connectImpl),
-  };
-}
-
-export const sshTool = createSshTool();

package/src/tools/ssh/sshAvailability.js

@@ -1,35 +0,0 @@
-/**
- * ============================================================
- *  src/tools/ssh/sshAvailability.ts —— SSH 四件套共用的 resolveAvailability
- * ------------------------------------------------------------
- *  仿 tools/lsp/config.ts::lspAvailabilitySignature 的做法：同步探测
- *  ssh-hosts.json 的存在性/mtime/size 算出 signature，配置一变工具集
- *  签名跟着变，不需要重启进程或重开会话就能让新增主机对模型可见
- *  （见 tools/effectiveToolSet.ts 的 signature 参与缓存 key 这条链路）。
- *
- *  取舍同 advisor.ts 的既有先例——"少一个工具比多一个工具严重得多"：
- *  拿不到 workspaceId、或读取过程出现非预期错误（损坏 JSON、权限问题等）
- *  一律 fail-open 判可用；只有明确读到"从未配置过任何主机"（文件不存在）
- *  才判不可用。真正的凭据解析仍然走 resolveSshHost() 的完整校验，这里
- *  只是减少零主机场景下的工具列表噪音，不是安全边界。
- * ============================================================
- */
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { sshHostsFilePath } from '../../context/sshHosts.js';
-export function resolveSshToolAvailability(runtime) {
-    const workspaceId = runtime.workspaceId;
-    if (!workspaceId)
-        return { available: true, signature: 'no-workspace' };
-    const path = sshHostsFilePath(workspaceId);
-    if (!existsSync(path))
-        return { available: false, signature: `${workspaceId}:empty` };
-    try {
-        const stat = statSync(path);
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        const hasHosts = Array.isArray(parsed.hosts) && parsed.hosts.length > 0;
-        return { available: hasHosts, signature: `${workspaceId}:${stat.mtimeMs}:${stat.size}:${hasHosts}` };
-    }
-    catch {
-        return { available: true, signature: `${workspaceId}:unreadable` };
-    }
-}

package/src/tools/ssh/sshAvailability.ts

@@ -1,39 +0,0 @@
-/**
- * ============================================================
- *  src/tools/ssh/sshAvailability.ts —— SSH 四件套共用的 resolveAvailability
- * ------------------------------------------------------------
- *  仿 tools/lsp/config.ts::lspAvailabilitySignature 的做法：同步探测
- *  ssh-hosts.json 的存在性/mtime/size 算出 signature，配置一变工具集
- *  签名跟着变，不需要重启进程或重开会话就能让新增主机对模型可见
- *  （见 tools/effectiveToolSet.ts 的 signature 参与缓存 key 这条链路）。
- *
- *  取舍同 advisor.ts 的既有先例——"少一个工具比多一个工具严重得多"：
- *  拿不到 workspaceId、或读取过程出现非预期错误（损坏 JSON、权限问题等）
- *  一律 fail-open 判可用；只有明确读到"从未配置过任何主机"（文件不存在）
- *  才判不可用。真正的凭据解析仍然走 resolveSshHost() 的完整校验，这里
- *  只是减少零主机场景下的工具列表噪音，不是安全边界。
- * ============================================================
- */
-
-import { existsSync, readFileSync, statSync } from 'node:fs';
-
-import { sshHostsFilePath } from '../../context/sshHosts.js';
-import type { AgentRuntimeContext } from '../../runtime/agentRuntimeContext.js';
-import type { ToolAvailability } from '../../types.js';
-
-export function resolveSshToolAvailability(runtime: AgentRuntimeContext): ToolAvailability {
-  const workspaceId = runtime.workspaceId;
-  if (!workspaceId) return { available: true, signature: 'no-workspace' };
-
-  const path = sshHostsFilePath(workspaceId);
-  if (!existsSync(path)) return { available: false, signature: `${workspaceId}:empty` };
-
-  try {
-    const stat = statSync(path);
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { hosts?: unknown[] };
-    const hasHosts = Array.isArray(parsed.hosts) && parsed.hosts.length > 0;
-    return { available: hasHosts, signature: `${workspaceId}:${stat.mtimeMs}:${stat.size}:${hasHosts}` };
-  } catch {
-    return { available: true, signature: `${workspaceId}:unreadable` };
-  }
-}

package/src/tools/ssh/sshClient.js

@@ -1,177 +0,0 @@
-/**
- * ============================================================
- *  src/tools/ssh/sshClient.ts —— ssh2 的薄封装（Promise 化 exec / sftp）
- * ------------------------------------------------------------
- *  只做协议层：连接、执行命令、传文件。主机解析（别名→凭据）、危险命令拦截、
- *  后台模式语义全部在调用方（ssh.ts / sshUpload.ts / sshDownload.ts）处理，
- *  这里不掺业务判断，方便测试用假实现替换（见 createSshTool 系列的 DI 参数）。
- * ============================================================
- */
-import { readFile } from 'node:fs/promises';
-import { posix } from 'node:path';
-import { Client } from 'ssh2';
-import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-/** 三个 SSH 工具（exec/upload/download）共用的默认超时——唯一真值。 */
-export const DEFAULT_SSH_TIMEOUT_MS = 30_000;
-/**
- * exec() 累积 stdout/stderr 时的内存安全上限（字符，每路各自）——远程命令狂输出
- * （如误连到日志尾/`cat` 大文件）时防止字符串无限增长撑爆内存。跟 Bash 工具的
- * `MAX_STREAM_BUFFER_CHARS` 同一思路：取展示层截断阈值（`ssh.ts` 里做）的 2 倍，
- * 正常输出不受影响。这里只做内存兜底，不做背压/归档——那是业务逻辑，本文件按头注
- * 原则不掺（真要背压得像 Bash 那样接 `ToolOutputStore`，成本对协议薄封装层不划算）。
- */
-const MAX_EXEC_BUFFER_CHARS = DEFAULT_MAX_RESULT_SIZE_CHARS * 2;
-function appendCapped(current, chunk, capChars) {
-    if (current.length >= capChars)
-        return current;
-    const combined = current + chunk;
-    return combined.length > capChars ? combined.slice(0, capChars) : combined;
-}
-/** 专门区分「执行超时」与其它失败（认证/网络错误）——background 模式要能识别前者。 */
-export class SshExecTimeoutError extends Error {
-    /** 超时发生前已经收到的部分输出（exec 用）——调用方可选择性地把它带给模型，而不是整段丢弃。 */
-    partialStdout;
-    partialStderr;
-    constructor(timeoutMs, partial) {
-        super(`执行超时（${timeoutMs}ms）`);
-        this.name = 'SshExecTimeoutError';
-        this.partialStdout = partial?.stdout;
-        this.partialStderr = partial?.stderr;
-    }
-}
-async function buildConnectConfig(host, connectTimeoutMs) {
-    const base = {
-        host: host.host,
-        port: host.port,
-        username: host.username,
-        readyTimeout: connectTimeoutMs,
-    };
-    if (host.authMethod === 'password')
-        return { ...base, password: host.password };
-    const privateKey = await readFile(host.privateKeyPath);
-    return { ...base, privateKey, ...(host.passphrase ? { passphrase: host.passphrase } : {}) };
-}
-/**
- * 逐级 mkdir 出 remotePath 的父目录（SFTP 没有 `mkdir -p`，ssh2 的 `sftp.mkdir` 一次只建一层）。
- * 每一级都直接 mkdir、忽略错误（多数情况下是"已存在"）——不去解析具体 SFTP 错误码区分
- * "已存在" vs "无权限"：无权限时 mkdir 静默失败，紧随其后的 fastPut 会用清楚得多的错误
- * 报出真实原因，没必要在这里重复判断一遍。
- */
-function sftpMkdirParents(sftp, remotePath) {
-    const dir = posix.dirname(remotePath);
-    if (dir === '.' || dir === '/' || dir === '')
-        return Promise.resolve();
-    const absolute = dir.startsWith('/');
-    const segments = dir.split('/').filter(Boolean);
-    let current = '';
-    let chain = Promise.resolve();
-    for (const seg of segments) {
-        current += `/${seg}`;
-        const path = absolute ? current : current.slice(1);
-        chain = chain.then(() => new Promise((resolve) => sftp.mkdir(path, () => resolve())));
-    }
-    return chain;
-}
-/** 导出仅供单测直接驱动（绕开真实 ssh2.Client 网络连接，喂假 exec/sftp 回调验证超时与 mkdir-parents 行为）。 */
-export function wrapConnection(conn) {
-    return {
-        exec(command, timeoutMs) {
-            return new Promise((resolvePromise, rejectPromise) => {
-                let stdout = '';
-                let stderr = '';
-                const timer = setTimeout(() => {
-                    conn.end();
-                    rejectPromise(new SshExecTimeoutError(timeoutMs, { stdout, stderr }));
-                }, timeoutMs);
-                conn.exec(command, (execError, stream) => {
-                    if (execError) {
-                        clearTimeout(timer);
-                        rejectPromise(execError);
-                        return;
-                    }
-                    stream
-                        .on('close', (code, signal) => {
-                        clearTimeout(timer);
-                        resolvePromise({ stdout, stderr, code, signal: signal ?? null });
-                    })
-                        .on('data', (data) => { stdout = appendCapped(stdout, data.toString('utf8'), MAX_EXEC_BUFFER_CHARS); })
-                        .stderr.on('data', (data) => { stderr = appendCapped(stderr, data.toString('utf8'), MAX_EXEC_BUFFER_CHARS); });
-                });
-            });
-        },
-        put(localPath, remotePath, timeoutMs) {
-            return new Promise((resolvePromise, rejectPromise) => {
-                const timer = setTimeout(() => {
-                    conn.end();
-                    rejectPromise(new SshExecTimeoutError(timeoutMs));
-                }, timeoutMs);
-                conn.sftp((sftpError, sftp) => {
-                    if (sftpError) {
-                        clearTimeout(timer);
-                        rejectPromise(sftpError);
-                        return;
-                    }
-                    sftpMkdirParents(sftp, remotePath)
-                        .then(() => {
-                        sftp.fastPut(localPath, remotePath, (putError) => {
-                            if (putError) {
-                                clearTimeout(timer);
-                                rejectPromise(putError);
-                                return;
-                            }
-                            sftp.stat(remotePath, (statError, stats) => {
-                                clearTimeout(timer);
-                                resolvePromise(statError ? 0 : stats.size);
-                            });
-                        });
-                    })
-                        // sftp.mkdir 的回调本身吞错误恒 resolve（见 sftpMkdirParents 头注），这里防的是
-                        // 更早一层：sftp 连接在 mkdir 期间掉线导致同步抛出——没有这个 catch，链路会挂成
-                        // 未处理 rejection，外层 Promise 只能干等到 timer 触发，模型看到的是「执行超时」
-                        // 而不是真实的连接错误。
-                        .catch((mkdirError) => { clearTimeout(timer); rejectPromise(mkdirError); });
-                });
-            });
-        },
-        get(remotePath, localPath, timeoutMs) {
-            return new Promise((resolvePromise, rejectPromise) => {
-                const timer = setTimeout(() => {
-                    conn.end();
-                    rejectPromise(new SshExecTimeoutError(timeoutMs));
-                }, timeoutMs);
-                conn.sftp((sftpError, sftp) => {
-                    if (sftpError) {
-                        clearTimeout(timer);
-                        rejectPromise(sftpError);
-                        return;
-                    }
-                    sftp.fastGet(remotePath, localPath, (getError) => {
-                        if (getError) {
-                            clearTimeout(timer);
-                            rejectPromise(getError);
-                            return;
-                        }
-                        sftp.stat(remotePath, (statError, stats) => {
-                            clearTimeout(timer);
-                            resolvePromise(statError ? 0 : stats.size);
-                        });
-                    });
-                });
-            });
-        },
-        end() {
-            conn.end();
-        },
-    };
-}
-/** 生产环境的真实连接实现——测试通过 DI 参数注入假实现，不经过这里。 */
-export const defaultSshConnect = async (host, connectTimeoutMs) => {
-    const config = await buildConnectConfig(host, connectTimeoutMs);
-    return new Promise((resolvePromise, rejectPromise) => {
-        const conn = new Client();
-        conn
-            .on('ready', () => resolvePromise(wrapConnection(conn)))
-            .on('error', (error) => rejectPromise(error))
-            .connect(config);
-    });
-};