llm-api-gateway-cli 1.0.0

package/cli-agent.js

@@ -0,0 +1,666 @@
+#!/usr/bin/env node
+/**
+ * 模式六 · 原生 Agent CLI（不依赖 Claude Code）
+ *
+ * 这是一个自带工具循环的终端编程助手：复用 lib/agent.js 的循环与 lib/tools.js 的沙箱，
+ * 直接在命令行里读写工作目录内的文件，写入前在终端里向你确认。
+ * 与 cli-claude-code.js 的区别：那边是把外部 `claude` 可执行文件接到网关上，
+ * 这边不依赖任何外部 Agent —— Node 原生 fetch 直连网关的 /v1/chat/completions。
+ *
+ * 用法示例：
+ *   node cli-agent.js -C ./myproject -p "看下 README 再帮我加一节安装说明"
+ *   node cli-agent.js -i                       # 在终端里多轮对话（默认工作目录为当前目录）
+ *   node cli-agent.js -i --continue            # 接着最近一次会话继续聊
+ *   node cli-agent.js -i --resume <会话id>      # 切到指定会话
+ *   echo "列出目录并总结" | node cli-agent.js   # 从标准输入取提示词
+ *
+ * 安全的写入闸门：模型每次写入都会先展示预览（覆盖已有文件时带行级 diff）并等你输入 y；
+ * 非交互环境（管道）默认**拒绝**写入，确需自动批准请显式加 --yes。
+ *
+ * 密钥来源与其余入口一致（lib/config.js）：--key > SK / GATEWAY_KEY / OPENAI_API_KEY / ANTHROPIC_API_KEY > .env
+ */
+
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import readline from 'node:readline';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+
+import { loadDotEnv, parseArgs, DEFAULT_BASE_URL } from './lib/common.js';
+import { resolveConfig, numArg, fail, KEY_HINT } from './lib/config.js';
+import { checkWorkDir, setBashEnabled, availableTools } from './lib/tools.js';
+import { createSession, restoreSession, runTurn, resumePendingTurn, countTurns } from './lib/runner.js';
+import { createSessionStore, resolveSessionDir, SESSION_TTL_MS } from './lib/sessionstore.js';
+import { COMMANDS, parseSlash, unescapeSlash, suggest, helpText, diffLines } from './lib/commands.js';
+import { configCommand, configHelp } from './lib/configcmd.js';
+import { settingsFilePath } from './lib/settings.js';
+import { AGENT_LIMITS } from './lib/agent.js';
+import { MEMORY_FILES, readMemory } from './lib/memory.js';
+import { refreshMcpTools, mcpStatusText } from './lib/mcp.js';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+loadDotEnv(SCRIPT_DIR);
+
+const DEFAULT_MODEL = process.env.GATEWAY_MODEL || 'qwen3:8b';
+const HISTORY_LIMIT = 200;
+
+const HELP = `用法：node cli-agent.js [选项] [提示词]
+       node cli-agent.js config <list|get|set|unset|path> [键] [值]
+
+模式六 · 原生 Agent：自带工具循环，直接在终端里读写工作目录内的文件，写入前需确认。
+不依赖 Claude Code（无需安装 @anthropic-ai/claude-code）。
+
+子命令：
+  config list|get|set|unset|path
+                           查看/修改持久化配置（存到磁盘，清缓存不丢）。config list 会标出
+                           每一项「当前生效值」来自命令行、环境变量、配置文件还是内置默认
+                           —— 改了没生效时看这一列就知道被谁盖住了。
+
+模式六 · 原生 Agent：自带工具循环，直接在终端里读写工作目录内的文件，写入前需确认。
+不依赖 Claude Code（无需安装 @anthropic-ai/claude-code）。
+
+选项：
+  -p, --prompt <文本>      单轮任务（省略则读位置参数 / 标准输入）
+  -i, --interactive        进入多轮交互（REPL）
+  -C, --cwd <目录>         工作目录，工具被沙箱限制在该目录内（默认当前目录）
+  -m, --model <模型>       模型名（默认 ${DEFAULT_MODEL}）
+  -k, --key <sk-密钥>      网关密钥（也可用环境变量 SK/GATEWAY_KEY/OPENAI_API_KEY 或 .env）
+      --base-url <地址>    网关地址（默认 ${DEFAULT_BASE_URL}）
+  -s, --system <文本>      追加的系统提示词
+      --temperature <值>   采样温度
+      --max-tokens <值>    最大生成 token 数（思考模型给小了可能只见思维链）
+      --max-steps <轮数>   单个任务最多几轮模型调用（默认 ${AGENT_LIMITS.MAX_STEPS}）
+      --continue           接着最近一次会话继续（恢复上下文与待批准态）
+      --resume <会话id>    恢复指定会话（UUID）
+      --session-dir <目录> 会话落盘目录（默认在用户主目录下的 .llm-api-gateway-cli）
+      --no-session         不落盘会话（纯内存，退出即丢）
+      --no-memory          不读取 AGENTS.md / CLAUDE.md 项目记忆
+      --allow-bash         开启 bash 工具（默认关闭；开启后每次执行仍需批准）
+      --output-format <值> 输出格式：text（默认）或 stream-json（逐行 JSON 事件，便于管道）
+      --yes                自动批准所有**文件写入**（危险：模型可直接改文件，慎用）。MCP 调用不需要它
+      --verbose            打印工具结果正文（默认只显示一行摘要）
+      --no-color           关闭彩色输出（也遵循 NO_COLOR 环境变量）
+  -h, --help               显示帮助
+
+单个任务最多 ${AGENT_LIMITS.MAX_STEPS} 轮工具调用（--max-steps 可调）。写入被拒后模型会改为向你说明思路。
+`;
+
+const VALUE_FLAGS = {
+  '--prompt': 'prompt',
+  '-p': 'prompt',
+  '--cwd': 'cwd',
+  '-C': 'cwd',
+  '--model': 'model',
+  '-m': 'model',
+  '--key': 'key',
+  '-k': 'key',
+  '--base-url': 'base-url',
+  '--system': 'system',
+  '-s': 'system',
+  '--temperature': 'temperature',
+  '--max-tokens': 'max-tokens',
+  '--max-steps': 'max-steps',
+  '--resume': 'resume',
+  '--session-dir': 'session-dir',
+  '--output-format': 'output-format',
+};
+const BOOL_FLAGS = {
+  '--interactive': 'interactive',
+  '-i': 'interactive',
+  '--continue': 'continue',
+  '--no-session': 'no-session',
+  '--no-memory': 'no-memory',
+  '--allow-bash': 'allow-bash',
+  '--yes': 'yes',
+  '--verbose': 'verbose',
+  '--no-color': 'no-color',
+  '--help': 'help',
+  '-h': 'help',
+};
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data.trim()));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+/** 读工作目录里的项目记忆（AGENTS.md / CLAUDE.md）—— 与 Web 任务页的 /instructions 同一实现 */
+function loadProjectMemory(workDir) {
+  return readMemory(workDir).text;
+}
+
+// ---------- 颜色 ----------
+
+function makeColor(enabled) {
+  const wrap = (code) => (s) => (enabled ? `\x1b[${code}m${s}\x1b[0m` : s);
+  return { dim: wrap('2'), cyan: wrap('36'), green: wrap('32'), red: wrap('31'), yellow: wrap('33'), bold: wrap('1') };
+}
+
+// ---------- 终端事件渲染 ----------
+
+function createRenderer({ color, verbose, json }) {
+  let outMid = false; // stdout 是否停在没有换行的一行上
+  let reasonOpen = false; // 思维链是否处于输出中
+
+  const closeOut = () => {
+    if (outMid) {
+      process.stdout.write('\n');
+      outMid = false;
+    }
+  };
+  const closeReason = () => {
+    if (reasonOpen) {
+      process.stderr.write('\n');
+      reasonOpen = false;
+    }
+  };
+
+  return {
+    handle(ev) {
+      // stream-json：每个事件一行 JSON，直接给管道/CI 用；人看的提示仍走 stderr
+      if (json) {
+        process.stdout.write(`${JSON.stringify(ev)}\n`);
+        return;
+      }
+      switch (ev.type) {
+        case 'reasoning':
+          closeOut();
+          if (!reasonOpen) {
+            process.stderr.write(color.dim('💭 '));
+            reasonOpen = true;
+          }
+          process.stderr.write(color.dim(ev.text));
+          break;
+        case 'delta':
+          closeReason();
+          process.stdout.write(ev.text);
+          outMid = true;
+          break;
+        case 'assistant_text_end':
+          closeOut();
+          break;
+        case 'tool_call':
+          closeReason();
+          closeOut();
+          process.stderr.write(`${color.cyan('⚙')} ${ev.label}\n`);
+          break;
+        case 'tool_result': {
+          closeReason();
+          closeOut();
+          const mark = ev.ok ? color.green('✓') : color.red('✗');
+          process.stderr.write(`  ${mark} ${ev.summary}\n`);
+          if (verbose && ev.content) {
+            for (const line of String(ev.content).split('\n').slice(0, 200)) {
+              process.stderr.write(color.dim(`    ${line}\n`));
+            }
+          }
+          break;
+        }
+        case 'notice':
+          closeReason();
+          closeOut();
+          process.stderr.write(`${color.yellow('!')} ${ev.text}\n`);
+          break;
+        default:
+          break; // usage / usage_total 由调用方在收尾统一打印
+      }
+    },
+    finish() {
+      closeReason();
+      closeOut();
+    },
+  };
+}
+
+// ---------- 写入批准 ----------
+
+function renderApproval(preview, color) {
+  const top = '┌─ 待批准写入 ─────────────────────────────';
+  const mid = '├──────────────────────────────────────────';
+  const bot = '└──────────────────────────────────────────';
+  const kind = preview.shell ? '执行命令' : preview.patch ? '增量修改' : preview.exists ? '覆盖已有文件' : '新建文件';
+  const out = [top, `│ ${preview.path}  (${kind})`, `│ ${preview.lines} 行 / ${preview.bytes} 字节`];
+
+  // 覆盖已有文件时给出行级 diff：只看新内容根本判断不出改了什么
+  const canDiff = !preview.shell && preview.exists && typeof preview.old === 'string' && preview.old !== preview.content;
+  if (canDiff) {
+    const { lines, removed, added } = diffLines(preview.old, preview.content);
+    out.push(mid, `│ 改动：-${removed} 行 / +${added} 行`);
+    for (const line of lines) {
+      const painted = line.startsWith('-') ? color.red(line) : line.startsWith('+') ? color.green(line) : line;
+      out.push(`│ ${painted}`);
+    }
+  } else {
+    out.push(mid);
+    const contentLines = String(preview.content ?? '').split('\n');
+    const shown = contentLines.slice(0, 40);
+    for (const line of shown) out.push(`│ ${line}`);
+    if (contentLines.length > shown.length) out.push(`│ …（预览截断，共 ${contentLines.length} 行）`);
+  }
+  if (preview.note) out.push(`│ ${color.yellow(preview.note)}`);
+  out.push(bot);
+  process.stderr.write(color.dim(out.join('\n')) + '\n');
+}
+
+function question(rl, prompt) {
+  return new Promise((resolve) => rl.question(prompt, resolve));
+}
+
+/**
+ * 读一行输入，支持行尾 `\` 续行（多行提示词不用引号包一坨）。
+ * 不引 TUI 库：readline 就够，多行只是多问几次。
+ */
+async function readInput(rl, color) {
+  const first = await question(rl, color.cyan('你> '));
+  if (!first.trimEnd().endsWith('\\')) return first;
+  const parts = [first.trimEnd().slice(0, -1)];
+  for (;;) {
+    const more = await question(rl, color.dim('... '));
+    if (more.trimEnd().endsWith('\\')) {
+      parts.push(more.trimEnd().slice(0, -1));
+      continue;
+    }
+    parts.push(more);
+    return parts.join('\n');
+  }
+}
+
+/** 造一个批准函数：终端的 y/N 闸门。
+ * --yes 自动批准；非交互环境默认拒绝（安全），避免脚本误改文件。
+ * 只对**文件写入**（write_file / apply_patch / bash）调用；远端 MCP 调用不走这道闸门
+ * ——逐个批准会让一次调研的十几次地图查询全被拒，而放开又只能靠 --yes（连文件写入一起放开）。
+ */
+function makeApproval({ autoApprove, rl, color }) {
+  return async (pending, preview) => {
+    renderApproval(preview, color);
+    if (autoApprove) {
+      process.stderr.write(color.yellow('  [--yes] 已自动批准这次写入\n'));
+      return true;
+    }
+    if (!rl || !process.stdin.isTTY) {
+      process.stderr.write(color.red('  非交互环境，默认拒绝文件写入（确需自动批准请加 --yes；MCP 调用不受此限）\n'));
+      return false;
+    }
+    const ans = await question(rl, color.cyan(`批准 ${preview.shell ? '执行该命令' : `写入 ${preview.path}`} ？(y/N) `));
+    return /^(y|yes)$/i.test(ans.trim());
+  };
+}
+
+// ---------- 命令历史落盘 ----------
+
+function historyPath(sessionDir) {
+  return sessionDir ? path.join(sessionDir, 'history') : null;
+}
+
+function loadHistory(sessionDir) {
+  const file = historyPath(sessionDir);
+  if (!file) return [];
+  try {
+    if (!existsSync(file)) return [];
+    // readline 的 history 是「新的在前」
+    return readFileSync(file, 'utf8')
+      .split('\n')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .slice(-HISTORY_LIMIT)
+      .reverse();
+  } catch {
+    return [];
+  }
+}
+
+function saveHistory(sessionDir, rl) {
+  const file = historyPath(sessionDir);
+  const hist = Array.isArray(rl?.history) ? rl.history : [];
+  if (!file || !hist.length) return;
+  try {
+    // 去重后保留最近 HISTORY_LIMIT 条，落盘顺序是「旧的在前」，下次读回来再反转
+    const seen = new Set();
+    const out = [];
+    for (const line of hist) {
+      const t = String(line).trim();
+      if (!t || seen.has(t)) continue;
+      seen.add(t);
+      out.push(t);
+      if (out.length >= HISTORY_LIMIT) break;
+    }
+    writeFileSync(file, out.reverse().join('\n'), 'utf8');
+  } catch {
+    /* 历史存不下不影响主流程 */
+  }
+}
+
+// ---------- 主流程 ----------
+
+async function main() {
+  // `gateway-agent config …`：配置子命令。放在 parseArgs 之前，而且不需要密钥 ——
+  // 「配置还没弄好」恰恰是用户最可能先跑它的场景；交给 parseArgs 还会把
+  // `set system --foo` 这类取值当成选项吃掉。
+  const raw = process.argv.slice(2);
+  if (raw[0] === 'config') {
+    const rest = raw.slice(1);
+    if (rest.includes('-h') || rest.includes('--help')) {
+      process.stdout.write(configHelp());
+      return;
+    }
+    const r = configCommand(rest, { env: process.env, file: settingsFilePath() });
+    if (r.out) process.stdout.write(r.out);
+    if (r.err) process.stderr.write(r.err);
+    if (r.code) process.exitCode = r.code;
+    return;
+  }
+
+  const args = parseArgs(process.argv.slice(2), VALUE_FLAGS, BOOL_FLAGS);
+
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+
+  // bash 默认关闭：命令级权限不该默默打开
+  setBashEnabled(Boolean(args['allow-bash']));
+
+  const { key, baseUrl, model, temperature, maxTokens } = resolveConfig(args, { defaultModel: DEFAULT_MODEL });
+  // 模型轮次上限：与 Web 侧同名同义；非法值交给 resolveMaxSteps 回落到默认
+  const maxSteps = numArg(args['max-steps']);
+  if (!key) {
+    process.stderr.write(`[错误] ${KEY_HINT}\n`);
+    process.exit(1);
+  }
+
+  // 会话存储（可关）：--no-session 时 store 为 null，行为退回纯内存
+  let store = null;
+  let sessionDir = null;
+  let sessionWarning = null;
+  let sessionNotice = null;
+  if (!args['no-session']) {
+    try {
+      const resolved = resolveSessionDir(typeof args['session-dir'] === 'string' ? args['session-dir'] : '', SCRIPT_DIR);
+      sessionDir = resolved.dir;
+      sessionWarning = resolved.warning;
+      sessionNotice = resolved.notice;
+      store = createSessionStore(sessionDir);
+    } catch (e) {
+      sessionWarning = `会话落盘不可用（${e.message}），本次会话不会保存`;
+    }
+  }
+
+  // 先看要恢复哪个会话，再决定工作目录 —— 恢复时优先沿用会话里记的工作目录
+  let restored = null;
+  if (args.resume !== undefined) {
+    const id = typeof args.resume === 'string' ? args.resume.trim() : '';
+    if (!store) {
+      process.stderr.write('[错误] --resume 与 --no-session 不能同时用\n');
+      process.exit(1);
+    }
+    if (!id) {
+      process.stderr.write(`[错误] --resume 需要一个会话 id（UUID）。会话目录：${sessionDir}\n`);
+      process.exit(1);
+    }
+    restored = store.read(id);
+    if (!restored) {
+      process.stderr.write(`[错误] 找不到会话 ${id}（id 需为 UUID，且未被 TTL 清理）。会话目录：${sessionDir}\n`);
+      process.exit(1);
+    }
+  } else if (args.continue) {
+    restored = store ? store.latest(SESSION_TTL_MS) : null;
+    if (!restored) {
+      const plain = makeColor(false);
+      process.stderr.write(`${plain.yellow('!')} --continue 没有找到可恢复的会话，将新建一个\n`);
+    }
+  }
+
+  let workDir;
+  try {
+    const want = typeof args.cwd === 'string' ? args.cwd : restored?.workingDir || process.cwd();
+    workDir = checkWorkDir(want);
+  } catch (e) {
+    process.stderr.write(`[错误] 工作目录无效：${e.message}\n`);
+    process.exit(1);
+  }
+
+  const memory = args['no-memory'] ? '' : loadProjectMemory(workDir);
+  const systemParts = [typeof args.system === 'string' ? args.system : '', memory].filter(Boolean);
+  const system = systemParts.length ? systemParts.join('\n\n') : undefined;
+
+  const makeSession = () => createSession({ workingDir: workDir, model, temperature, maxTokens, system });
+
+  // 恢复：沿用存下来的 messages，只覆盖元数据；没有可恢复的就新建
+  let session = (restored && restoreSession(restored, { workingDir: workDir, model })) || null;
+  const resumedFrom = session ? session.id : null;
+  if (!session) session = makeSession();
+  // 轮次上限只作用于本次进程（--max-steps 是运行时开关，不随会话落盘）
+  if (maxSteps) session.maxSteps = maxSteps;
+
+  const color = makeColor(!args['no-color'] && !process.env.NO_COLOR && Boolean(process.stdout.isTTY));
+  const jsonOut = args['output-format'] === 'stream-json';
+  if (args['output-format'] && !jsonOut && args['output-format'] !== 'text') {
+    process.stderr.write('[错误] --output-format 只支持 text / stream-json\n');
+    process.exit(1);
+  }
+  const renderer = createRenderer({ color, verbose: Boolean(args.verbose), json: jsonOut });
+  const cfg = { baseUrl, key };
+  const persist = () => {
+    if (!store) return;
+    try {
+      store.write(session);
+    } catch (e) {
+      process.stderr.write(color.yellow(`! 会话落盘失败：${e.message}\n`));
+    }
+  };
+
+  let interactive = Boolean(args.interactive);
+  let prompt = typeof args.prompt === 'string' ? args.prompt : args._.join(' ').trim();
+
+  // 没给提示词又不在交互模式：先尝试标准输入；TTY 下（没有输入）则退化为交互模式
+  if (!interactive && !prompt) {
+    prompt = await readStdin();
+    if (!prompt && process.stdin.isTTY) interactive = true;
+  }
+
+  if (!interactive && !prompt) {
+    console.log(HELP);
+    return;
+  }
+
+  // 需要一个 readline：交互模式要它读输入，单轮 TTY 模式要它做写入确认
+  const rl =
+    interactive || process.stdin.isTTY
+      ? readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+          terminal: Boolean(process.stdin.isTTY),
+          history: loadHistory(sessionDir),
+          historySize: HISTORY_LIMIT,
+        })
+      : null;
+
+  const askApproval = makeApproval({ autoApprove: Boolean(args.yes), rl, color });
+
+  let controller = null;
+  const onSigint = () => {
+    if (controller) {
+      process.stderr.write(`\n${color.yellow('!')} 已中断当前任务\n`);
+      controller.abort();
+      controller = null;
+    } else if (rl) {
+      rl.close();
+      saveHistory(sessionDir, rl);
+      process.exit(130);
+    }
+  };
+  process.on('SIGINT', onSigint);
+
+  // 启动时就向网关要一次 MCP 工具清单，不等第一轮对话才顺手拉。
+  // 为什么必须放在横幅之前：横幅上的「工具」列表读的是 availableTools()，而它是**同步读缓存**的
+  // —— 不先刷新，这里永远只列内置工具，用户（以及排障的人）根本看不出 CLI 到底有没有参与 MCP。
+  // Web 侧的 /api/config 一直有这一步（页面一刷新就能看到请求），CLI 之前一直没有，两边表现不一致。
+  // best-effort：网关没开 MCP / 断网 / 密钥无效都只记一行原因，绝不拦住启动（本模块的硬约束 1）；
+  // 失败后会走 lib/mcp.js 的冷却，所以第一轮对话不会为一个注定失败的请求再等一次超时。
+  const mcpInfo = await refreshMcpTools({ baseUrl, key });
+
+  const toolNames = availableTools()
+    .map((t) => t.function.name)
+    .join(' / ');
+  // 失败/关闭时把「到底发没发请求」直说出来：否则「CLI 压根没拉清单」（GATEWAY_MCP=off /
+  // 密钥配置不全）与「拉了但网关没给」（404/断网）在用户眼里长得一模一样，只能去翻网关日志。
+  // attemptedAt 由 lib/mcp.js 在真正发请求时记下，所以这句话是事实而不是推测。
+  // 注意后半句的措辞：`GATEWAY_MCP=off` 时工具是网关自己注入的，说「没有 MCP」会误导，
+  // 只能保证「CLI 不携带」。
+  const mcpLine = mcpInfo?.error
+    ? `${mcpStatusText()} · ${mcpInfo.attemptedAt
+        ? `已请求 GET ${baseUrl}/v1/mcp/tools`
+        : '按上述原因未向网关发出请求'}（CLI 本次不携带 MCP 工具）`
+    : mcpStatusText();
+  process.stderr.write(
+    `[gateway] 原生 Agent · base=${baseUrl} model=${model}\n` +
+      `          工作目录 ${workDir}\n` +
+      `          工具 ${toolNames}${args['allow-bash'] ? '  [bash 已开启]' : ''}\n` +
+      `          ${mcpLine}\n` +
+      `          轮次上限 ${session.maxSteps || AGENT_LIMITS.MAX_STEPS} 轮\n` +
+      (resumedFrom ? `          已恢复会话 ${resumedFrom}（${countTurns(session)} 条消息）\n` : '') +
+      (store ? `          会话目录 ${sessionDir}\n` : '') +
+      (sessionNotice ? `${color.yellow('!')} ${sessionNotice}\n` : '') +
+      (sessionWarning ? `${color.yellow('!')} ${sessionWarning}\n` : '') +
+      (memory ? `          已注入项目记忆（${MEMORY_FILES.join(' / ')}）\n` : ''),
+  );
+
+  const runOnce = async (text) => {
+    controller = new AbortController();
+    try {
+      await runTurn({ cfg, session, prompt: text, onEvent: renderer.handle, askApproval, persist, signal: controller.signal });
+    } finally {
+      controller = null;
+      renderer.finish();
+    }
+    persist();
+    const u = session.usage;
+    process.stderr.write(color.dim(`[usage] 输入 ${u.prompt} / 输出 ${u.completion} / 合计 ${u.prompt + u.completion} tokens\n`));
+    if (jsonOut) process.stdout.write(`${JSON.stringify({ type: 'done', sessionId: session.id, usage: { ...u } })}\n`);
+  };
+
+  // 会话里有待批准的写入（进程退出前留下的）→ 先问批不批再接着跑
+  if (session.pending) {
+    process.stderr.write(color.yellow(`! 恢复了一个待批准的写入：${session.pending.name}\n`));
+    controller = new AbortController();
+    try {
+      const outcome = await resumePendingTurn({ cfg, session, onEvent: renderer.handle, askApproval, persist, signal: controller.signal });
+      if (outcome) process.stderr.write(color.dim(`[恢复完成] 状态 ${outcome.status}\n`));
+    } catch (e) {
+      fail(e, { exit: false });
+    } finally {
+      controller = null;
+      renderer.finish();
+    }
+  }
+
+  if (interactive) {
+    process.stderr.write(color.dim('交互模式：直接输入任务；/help 看命令，/exit 退出。\n'));
+    const ctx = {
+      get session() {
+        return session;
+      },
+      setSession: (next) => {
+        session = next;
+      },
+      newSession: makeSession,
+      setModel: (m) => {
+        session.model = m;
+      },
+      cfg,
+      say: (t) => process.stderr.write(`${t}\n`),
+      persist,
+      loadSession: (id) => {
+        const rec = store?.read(id);
+        return rec ? restoreSession(rec, { workingDir: workDir, model }) : null;
+      },
+      listSessions: () =>
+        (store ? store.list(SESSION_TTL_MS) : []).map((r) => ({
+          id: r.id,
+          model: r.model,
+          messages: r.messages?.length || 0,
+          touchedAt: r.touchedAt,
+        })),
+      // /config 用：与 `gateway-agent config` 完全同一份实现与同一个文件
+      configOpts: () => ({ env: process.env, file: settingsFilePath() }),
+    };
+
+    for (;;) {
+      let line;
+      try {
+        line = (await readInput(rl, color)).trim();
+      } catch {
+        break; // 输入流关闭
+      }
+      if (!line) continue;
+
+      // /exit /quit / exit / quit 全部由命令表的 `bare` 标记兜住（run 返回 { exit: true }），
+      // 这里不再硬编码 —— 硬编码会让"命令表"不再是唯一出处（A2 对齐，见 lib/commands.js 文件头）。
+      const cmd = parseSlash(line);
+      if (cmd) {
+        if (cmd.error) {
+          process.stderr.write(color.red(`  ${cmd.error}\n  用法：${cmd.cmd.usage}\n`));
+          continue;
+        }
+        // await 是必须的：命令可以是异步的（如 /mcp 要出网重拉清单）。
+        // 不 await 的话 promise 会被丢掉，输出时序也会乱（「命令跑完了但没打印」就是它）。
+        const result = await cmd.cmd.run(ctx, cmd.arg, cmd.argv);
+        if (result?.exit) break;
+        continue;
+      }
+
+      // `//xxx` 是转义：去掉一个斜杠后**当普通提问发给模型**（与网关 Web 端 R3 同一口径）
+      const escaped = unescapeSlash(line);
+      if (escaped !== null) {
+        try {
+          await runOnce(escaped);
+        } catch (e) {
+          fail(e, { exit: false });
+        }
+        continue;
+      }
+
+      if (line.startsWith('/') || line.startsWith('／')) {
+        // 前缀只补全、不执行；REPL 没有候选面板（readInput 用 rl.question，无 raw mode），
+        // 所以候选以文本列表打印（对齐方案 §1.3）
+        const head = line.split(/\s/)[0].replace(/^／/, '/').toLowerCase();
+        const near = suggest(head.slice(1));
+        if (near.length) {
+          process.stderr.write(color.dim(
+            `  命令名不完整：${head}\n  候选：${near.map((c) => c.usage.split(' ')[0]).join('　')}\n`));
+        } else {
+          process.stderr.write(color.dim(`未知命令 ${head}（/help 看可用命令）。\n`));
+        }
+        continue;
+      }
+
+      try {
+        await runOnce(line);
+      } catch (e) {
+        fail(e, { exit: false });
+      }
+    }
+    if (rl) {
+      rl.close();
+      saveHistory(sessionDir, rl);
+    }
+    process.stderr.write('再见。\n');
+    return;
+  }
+
+  try {
+    await runOnce(prompt);
+  } catch (e) {
+    fail(e);
+  }
+  if (rl) {
+    rl.close();
+    saveHistory(sessionDir, rl);
+  }
+}
+
+main();