@huicai/cli 0.5.1

package/src/todo.js

@@ -0,0 +1,75 @@
+// 任务清单工具：
+// 模型用 todo_write 维护当前任务的步骤清单（每次提交完整列表），CLI 实时渲染进度。
+// 纯客户端状态（不落盘、不进模型上下文之外的系统），状态由调用方（会话）持有以跨轮保留。
+
+const STATUSES = new Set(['pending', 'in_progress', 'completed']);
+
+export const TODO_TOOL_NAME = 'todo_write';
+
+/**
+ * 构造 todo_write 工具。
+ * @param {{state:{list:any[]}, emit:(list:any[])=>void}} p state 由调用方持有（跨轮保留）；emit 用于 UI 渲染
+ * @returns {{spec:object, run:Function, readOnly:boolean}}
+ */
+export function makeTodoTool({ state, emit }) {
+  const spec = {
+    type: 'function',
+    function: {
+      name: TODO_TOOL_NAME,
+      description:
+        '维护当前任务的步骤清单，帮助用户看到进度。多步骤/非琐碎任务开始前先列出计划，'
+        + '每完成一步就更新状态（同一时刻至多一项 in_progress）。每次调用需提交完整清单（全量覆盖）。'
+        + '单步小事无需使用。',
+      parameters: {
+        type: 'object',
+        properties: {
+          todos: {
+            type: 'array',
+            description: '完整的任务清单（全量覆盖旧清单）',
+            items: {
+              type: 'object',
+              properties: {
+                content: { type: 'string', description: '任务内容（简短祈使句）' },
+                status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: '任务状态' },
+              },
+              required: ['content', 'status'],
+            },
+          },
+        },
+        required: ['todos'],
+      },
+    },
+  };
+
+  const run = async (args) => {
+    const raw = Array.isArray(args?.todos) ? args.todos : null;
+    if (!raw) return 'todo_write 需要 todos 数组';
+    const list = raw
+      .map((t) => ({
+        content: String(t?.content ?? '').trim(),
+        status: STATUSES.has(t?.status) ? t.status : 'pending',
+      }))
+      .filter((t) => t.content)
+      .slice(0, 50);
+    state.list = list;
+    try {
+      emit?.(list);
+    } catch {
+      /* 渲染失败不影响流程 */
+    }
+    const done = list.filter((t) => t.status === 'completed').length;
+    return `已更新任务清单：共 ${list.length} 项，完成 ${done} 项。`;
+  };
+
+  return { readOnly: true, spec, run };
+}
+
+/** 把清单渲染为多行文本（REPL/降级输出用）。 */
+export function formatTodos(list) {
+  return (list || [])
+    .map((t) => {
+      const mark = t.status === 'completed' ? '☑' : t.status === 'in_progress' ? '◐' : '☐';
+      return `${mark} ${t.content}`;
+    })
+    .join('\n');
+}

package/src/tools.js

@@ -0,0 +1,132 @@
+// 本机工具的 OpenAI 函数规格（随请求透传给平台模型）+ 名称→执行器分发。
+
+import * as ex from './executors.js';
+
+const obj = (properties, required) => ({ type: 'object', properties, required: required || [] });
+const str = (description) => ({ type: 'string', description });
+const int = (description) => ({ type: 'integer', description });
+const bool = (description) => ({ type: 'boolean', description });
+
+/** @type {any[]} 暴露给模型的工具（函数调用规格）。 */
+export const TOOL_SPECS = [
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description:
+        '读取文本文件内容，每行带「行号→」前缀（行号仅供定位，不属于文件内容，编辑时不要包含它）。'
+        + '默认最多 2000 行，可用 offset(起始行,1基)/limit(行数) 分段读取大文件。',
+      parameters: obj(
+        { path: str('相对项目根的文件路径'), offset: int('可选：起始行(1基)'), limit: int('可选：读取行数') },
+        ['path'],
+      ),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_files',
+      description: '列出目录下的文件树（跳过 .git/node_modules 等）。可选 path 指定子目录（默认项目根）。',
+      parameters: obj({ path: str('可选：子目录路径，默认当前项目根') }, []),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'glob',
+      description: '按 glob 模式查找文件（支持 ** 与 *），如 "**/*.ts"、"src/**/*.java"。',
+      parameters: obj({ pattern: str('glob 模式') }, ['pattern']),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'grep',
+      description:
+        '在文件内容中按正则搜索，返回 匹配文件:行号: 该行。可选 path 限定目录、glob 限定文件名模式、'
+        + 'ignore_case 忽略大小写、files_only 只列出命中文件。',
+      parameters: obj(
+        {
+          pattern: str('正则表达式'),
+          path: str('可选：搜索目录，默认项目根'),
+          glob: str('可选：文件名 glob 过滤'),
+          ignore_case: bool('可选：忽略大小写（默认否）'),
+          files_only: bool('可选：只返回命中文件列表，不含匹配行（默认否）'),
+          max_results: int('可选：最多返回条数（默认 200，上限 500）'),
+        },
+        ['pattern'],
+      ),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: '把文本写入文件（覆盖式，自动建父目录）。仅限当前项目目录内。仅用于新建文件或全量重写；小改动优先 edit_file。',
+      parameters: obj({ path: str('相对项目根的文件路径'), content: str('完整文件内容') }, ['path', 'content']),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit_file',
+      description:
+        '精确替换文件中的片段：old_string 必须是文件原文（不含 read_file 的行号前缀）且在文件中唯一'
+        + '（除非 replace_all=true）。仅限项目目录内。',
+      parameters: obj(
+        {
+          path: str('相对项目根的文件路径'),
+          old_string: str('被替换的原文（需在文件中唯一，除非 replace_all；不要包含行号前缀）'),
+          new_string: str('替换为的新内容'),
+          replace_all: bool('是否替换全部匹配（默认否）'),
+        },
+        ['path', 'old_string', 'new_string'],
+      ),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_bash',
+      description:
+        '在项目目录下执行一条 shell 命令并返回输出（stdout+stderr+退出码）。用于构建、测试、git、脚手架等。'
+        + '默认超时 120s（可用 timeout 调整）。避免用它读文件/搜索（用 read_file/grep 更高效）。',
+      parameters: obj({ command: str('要执行的 shell 命令'), timeout: int('可选：超时毫秒') }, ['command']),
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'fetch_url',
+      description:
+        '抓取一个 http/https 网页或接口（GET），HTML 自动转为纯文本。用于查在线文档、API 说明、Issue 等。'
+        + '结果可能很长，尽量带着明确目的使用。',
+      parameters: obj({ url: str('完整 URL（http/https）'), timeout: int('可选：超时毫秒，默认 30000') }, ['url']),
+    },
+  },
+];
+
+/** 只读工具（默认自动放行，无需审批）。fetch_url 涉及外发请求，需用户授权。 */
+export const READONLY_TOOLS = new Set(['read_file', 'list_files', 'glob', 'grep']);
+
+const EXECUTORS = {
+  read_file: ex.readFile,
+  list_files: ex.listFiles,
+  glob: ex.glob,
+  grep: ex.grep,
+  write_file: ex.writeFile,
+  edit_file: ex.editFile,
+  run_bash: ex.runBash,
+  fetch_url: ex.fetchUrl,
+};
+
+/** 执行一个本机工具，返回文本结果（回填给模型）。抛错转为可读文本，保证循环不中断。 */
+export async function runTool(name, args, cwd) {
+  const fn = EXECUTORS[name];
+  if (!fn) return `未知工具：${name}`;
+  try {
+    return await fn(cwd, args || {});
+  } catch (e) {
+    return `工具执行失败：${e.message}`;
+  }
+}

package/src/tui/app.js

@@ -0,0 +1,468 @@
+// ink + React 富终端界面（TUI）。用 React.createElement 编写（无 JSX，故仍无需构建步骤）。
+// 通过 runTurn 的结构化 events（onDelta/onToolStart/onTodo/…）驱动渲染：Static 承载已定稿的对话记录，
+// 下方动态区呈现流式正文、任务清单、思考 spinner、授权提示与可编辑输入行、底部状态栏。
+//
+// 交互细节：
+//  - 输入行支持光标移动/行内编辑（←→、Ctrl+A/E/U/K/W）与上下键历史（按项目目录持久化）；
+//  - 模型工作中可继续输入：回车即排队，工具轮间隙自动注入（「边跑边补充指令」）；Esc 中断当前回合；
+//  - 授权提示含高风险命令警示，[A] 可把允许规则写入项目 .huicai/settings.json；
+//  - 斜杠命令与 REPL 共用 commands.js 注册表；@文件 引用与 !命令 直通同样可用。
+//
+// 仅在 TTY 且已安装 ink 时启用；未安装时 bin 回退到零依赖 readline REPL。
+
+import React, { useState, useRef, useReducer, useEffect } from 'react';
+import { render, Box, Text, Static, useInput, useApp } from 'ink';
+import { runTurn } from '../agent.js';
+import { toolLabel } from '../render.js';
+import { createSession, saveSession } from '../session.js';
+import { buildExtraTools } from '../repl.js';
+import { closeMcp } from '../mcp.js';
+import { runSlash } from '../commands.js';
+import { expandAtMentions, runBangCommand, loadHistory, appendHistory } from '../input.js';
+import { loadAllowRules, matchAllowRules, suggestRule, addProjectAllowRule, riskWarning } from '../settings.js';
+
+const h = React.createElement;
+
+function shortLine(s, max = 200) {
+  const first = String(s).split('\n')[0];
+  return first.length > max ? first.slice(0, max) + '…' : first;
+}
+
+function clipLines(s, maxLines = 12) {
+  const lines = String(s).split('\n');
+  if (lines.length <= maxLines) return s;
+  return lines.slice(0, maxLines).join('\n') + `\n…（共 ${lines.length} 行）`;
+}
+
+function fmtTok(n) {
+  return n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n);
+}
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+function App({ config, cwd, session: initialSession, extraTools, yolo, initialPrompt, version, onExit }) {
+  const app = useApp();
+  const logRef = useRef([]); // 已定稿记录：{id,kind,text}
+  const idRef = useRef(0);
+  const liveRef = useRef(''); // 当前流式正文
+  const sessionRef = useRef(initialSession);
+  const abortRef = useRef(null);
+  const pendingRef = useRef(null); // 授权中：{name,args,resolve}
+  const sessionAllow = useRef(new Set());
+  const rulesRef = useRef(loadAllowRules(cwd)); // settings.json 允许规则
+  const yoloRef = useRef(!!yolo);
+  const startedRef = useRef(false);
+  const statusRef = useRef('idle');
+  const queueRef = useRef([]); // 忙时排队的用户消息
+  const todoStateRef = useRef({ list: [] });
+  const historyRef = useRef(loadHistory(cwd));
+  const histIdxRef = useRef(null);
+  const draftRef = useRef('');
+
+  const [, force] = useReducer((x) => x + 1, 0);
+  const [status, setStatus] = useState('idle'); // idle | busy
+  const [inp, setInp] = useState({ text: '', cursor: 0 });
+  const [pending, setPending] = useState(null);
+  const [usage, setUsage] = useState({ prompt: 0, completion: 0 });
+  const [ctxTok, setCtxTok] = useState(0);
+  const [todos, setTodos] = useState([]);
+  const [queueLen, setQueueLen] = useState(0);
+  const [spin, setSpin] = useState(0);
+
+  const addLog = (kind, text) => {
+    logRef.current.push({ id: idRef.current++, kind, text });
+    force();
+  };
+  const flushLive = () => {
+    if (liveRef.current) {
+      addLog('assistant', liveRef.current);
+      liveRef.current = '';
+    }
+  };
+  const setBusy = (b) => {
+    statusRef.current = b ? 'busy' : 'idle';
+    setStatus(statusRef.current);
+  };
+
+  // 思考中 spinner
+  useEffect(() => {
+    if (status !== 'busy') return;
+    const t = setInterval(() => setSpin((s) => (s + 1) % SPINNER.length), 80);
+    return () => clearInterval(t);
+  }, [status]);
+
+  const thinkRef = useRef(''); // 思考过程（reasoning）流式缓冲，仅动态区展示不入定稿记录
+  const events = {
+    onDelta: (t) => {
+      if (thinkRef.current) thinkRef.current = ''; // 正文开始，思考收起
+      liveRef.current += t;
+      force();
+    },
+    onReasoning: (t) => {
+      thinkRef.current = (thinkRef.current + t).slice(-400);
+      force();
+    },
+    onToolStart: (name, args) => {
+      thinkRef.current = '';
+      flushLive();
+      addLog('tool', toolLabel(name, args));
+    },
+    onToolResult: (name, res) => addLog('toolresult', shortLine(res)),
+    onSkip: (name, args) => addLog('skip', toolLabel(name, args) + ' — 已跳过'),
+    onInfo: (t) => {
+      flushLive();
+      addLog('info', t);
+    },
+    onTodo: (list) => setTodos(list),
+    onTurnEnd: () => {
+      thinkRef.current = '';
+      flushLive();
+    },
+  };
+
+  // ink 版权限：只读/yolo/本会话/settings 规则放行；否则弹提示等待按键（y/a/A/n）
+  const permissions = {
+    request: (name, args, _cwd, readOnly) => {
+      if (readOnly || yoloRef.current || sessionAllow.current.has(name)
+        || matchAllowRules(rulesRef.current, name, args)) {
+        return Promise.resolve({ allow: true });
+      }
+      return new Promise((resolve) => {
+        pendingRef.current = { name, args, resolve };
+        setPending({ label: toolLabel(name, args), name, args, risk: riskWarning(name, args) });
+      });
+    },
+    isYolo: () => yoloRef.current,
+    setYolo: (v) => {
+      yoloRef.current = !!v;
+    },
+  };
+
+  const pullQueued = () => {
+    const q = queueRef.current.shift();
+    setQueueLen(queueRef.current.length);
+    if (q == null) return null;
+    return expandAtMentions(q, cwd).text;
+  };
+
+  const runUserTurn = async (text) => {
+    sessionRef.current.messages.push({ role: 'user', content: expandAtMentions(text, cwd).text });
+    setBusy(true);
+    abortRef.current = new AbortController();
+    if (!sessionRef.current.compaction) sessionRef.current.compaction = {};
+    const r = await runTurn({
+      config,
+      messages: sessionRef.current.messages,
+      permissions,
+      cwd,
+      extraTools,
+      events,
+      signal: abortRef.current.signal,
+      todoState: todoStateRef.current,
+      compaction: sessionRef.current.compaction,
+      pullQueued,
+    });
+    abortRef.current = null;
+    flushLive();
+    if (r?.usage) setUsage((u) => ({ prompt: u.prompt + r.usage.prompt, completion: u.completion + r.usage.completion }));
+    if (r?.lastPromptTokens) {
+      setCtxTok(r.lastPromptTokens);
+      sessionRef.current.lastPromptTokens = r.lastPromptTokens;
+    }
+    saveSession(sessionRef.current);
+    if ((r?.aborted || r?.error) && queueRef.current.length) {
+      queueRef.current = [];
+      setQueueLen(0);
+      addLog('info', '已清空排队消息');
+    }
+    setBusy(false);
+  };
+
+  const doExit = () => {
+    onExit?.();
+    app.exit();
+  };
+
+  const handleSlash = async (line) => {
+    const ctx = {
+      version,
+      config,
+      cwd,
+      usage,
+      permissions,
+      extraTools,
+      session: sessionRef.current,
+      print: (t) => addLog('info', String(t)),
+    };
+    const r = await runSlash(line, ctx);
+    if (r.action === 'exit') return doExit();
+    if (r.action === 'clear') {
+      sessionRef.current = createSession({ cwd, model: config.model, messages: [sessionRef.current.messages[0]] });
+      todoStateRef.current.list = [];
+      setTodos([]);
+      setCtxTok(0);
+      logRef.current = [];
+      liveRef.current = '';
+      addLog('info', '已开启新会话（旧会话仍可 --resume 恢复）');
+    }
+    if (r.prompt) {
+      if (statusRef.current === 'busy') {
+        queueRef.current.push(r.prompt);
+        setQueueLen(queueRef.current.length);
+      } else {
+        addLog('user', r.prompt);
+        await runUserTurn(r.prompt);
+      }
+    }
+  };
+
+  const handleBang = async (command) => {
+    if (statusRef.current === 'busy') {
+      addLog('info', '正在处理上一条，! 命令请稍候再试');
+      return;
+    }
+    addLog('user', '! ' + command);
+    const { output, record } = await runBangCommand(command, cwd);
+    addLog('toolresult', clipLines(output));
+    sessionRef.current.messages.push({ role: 'user', content: record });
+    saveSession(sessionRef.current);
+  };
+
+  const submit = async (raw) => {
+    const t = raw.trim();
+    setInp({ text: '', cursor: 0 });
+    histIdxRef.current = null;
+    if (!t) return;
+    appendHistory(cwd, t);
+    if (historyRef.current[historyRef.current.length - 1] !== t) historyRef.current.push(t);
+    if (t.startsWith('/')) return handleSlash(t);
+    if (t.startsWith('!') && t.length > 1) return handleBang(t.slice(1).trim());
+    if (statusRef.current === 'busy') {
+      // 边跑边补充：排队，工具轮间隙自动注入本回合
+      addLog('user', t);
+      queueRef.current.push(t);
+      setQueueLen(queueRef.current.length);
+      return;
+    }
+    addLog('user', t);
+    await runUserTurn(t);
+  };
+
+  // 首个自动指令
+  useEffect(() => {
+    if (!startedRef.current && initialPrompt) {
+      startedRef.current = true;
+      void submit(initialPrompt);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // 历史翻阅
+  const histUp = () => {
+    const hist = historyRef.current;
+    if (!hist.length) return;
+    if (histIdxRef.current == null) {
+      draftRef.current = inp.text;
+      histIdxRef.current = hist.length - 1;
+    } else if (histIdxRef.current > 0) {
+      histIdxRef.current--;
+    }
+    const t = hist[histIdxRef.current] ?? '';
+    setInp({ text: t, cursor: t.length });
+  };
+  const histDown = () => {
+    if (histIdxRef.current == null) return;
+    const hist = historyRef.current;
+    if (histIdxRef.current < hist.length - 1) {
+      histIdxRef.current++;
+      const t = hist[histIdxRef.current];
+      setInp({ text: t, cursor: t.length });
+    } else {
+      histIdxRef.current = null;
+      setInp({ text: draftRef.current, cursor: draftRef.current.length });
+    }
+  };
+
+  useInput((ch, key) => {
+    // 授权提示优先（y 一次 / a 本会话 / A 永久规则 / n·Esc·回车 拒绝）
+    if (pendingRef.current) {
+      const p = pendingRef.current;
+      const done = (res) => {
+        pendingRef.current = null;
+        setPending(null);
+        p.resolve(res);
+      };
+      if (ch === 'y') return done({ allow: true });
+      if (ch === 'a') {
+        sessionAllow.current.add(p.name);
+        return done({ allow: true });
+      }
+      if (ch === 'A') {
+        sessionAllow.current.add(p.name);
+        const rule = suggestRule(p.name, p.args);
+        try {
+          addProjectAllowRule(cwd, rule);
+          rulesRef.current = loadAllowRules(cwd);
+          addLog('info', `已写入允许规则：${rule} → .huicai/settings.json`);
+        } catch (e) {
+          addLog('info', `规则写入失败（本会话仍生效）：${e.message}`);
+        }
+        return done({ allow: true });
+      }
+      if (ch === 'n' || key.escape || key.return) return done({ allow: false, reason: '用户拒绝了该操作。' });
+      return;
+    }
+    if (key.escape) {
+      if (statusRef.current === 'busy' && abortRef.current) {
+        abortRef.current.abort();
+        addLog('info', '已请求中断（Esc）');
+      }
+      return;
+    }
+    if (key.ctrl && ch === 'c') {
+      if (statusRef.current === 'busy' && abortRef.current) {
+        abortRef.current.abort();
+        addLog('info', '已请求中断');
+      } else {
+        doExit();
+      }
+      return;
+    }
+    if (key.return) {
+      void submit(inp.text);
+      return;
+    }
+    if (key.upArrow) return histUp();
+    if (key.downArrow) return histDown();
+    if (key.leftArrow) return setInp((s) => ({ ...s, cursor: Math.max(0, s.cursor - 1) }));
+    if (key.rightArrow) return setInp((s) => ({ ...s, cursor: Math.min(s.text.length, s.cursor + 1) }));
+    if (key.ctrl && ch === 'a') return setInp((s) => ({ ...s, cursor: 0 }));
+    if (key.ctrl && ch === 'e') return setInp((s) => ({ ...s, cursor: s.text.length }));
+    if (key.ctrl && ch === 'u') return setInp((s) => ({ text: s.text.slice(s.cursor), cursor: 0 }));
+    if (key.ctrl && ch === 'k') return setInp((s) => ({ text: s.text.slice(0, s.cursor), cursor: s.cursor }));
+    if (key.ctrl && ch === 'w') {
+      return setInp((s) => {
+        const before = s.text.slice(0, s.cursor).replace(/\S+\s*$/, '');
+        return { text: before + s.text.slice(s.cursor), cursor: before.length };
+      });
+    }
+    if (key.backspace || key.delete) {
+      histIdxRef.current = null;
+      return setInp((s) => (s.cursor > 0
+        ? { text: s.text.slice(0, s.cursor - 1) + s.text.slice(s.cursor), cursor: s.cursor - 1 }
+        : s));
+    }
+    if (ch && !key.ctrl && !key.meta) {
+      histIdxRef.current = null;
+      const str = ch.replace(/\r\n?/g, '\n'); // 粘贴多行归一化
+      setInp((s) => ({ text: s.text.slice(0, s.cursor) + str + s.text.slice(s.cursor), cursor: s.cursor + str.length }));
+    }
+  });
+
+  // ---- 渲染 ----
+  const logItems = logRef.current;
+  const cwdName = cwd.split('/').filter(Boolean).pop() || cwd;
+  const before = inp.text.slice(0, inp.cursor);
+  const at = inp.text[inp.cursor] ?? ' ';
+  const after = inp.text.slice(inp.cursor + 1);
+
+  return h(
+    Box,
+    { flexDirection: 'column' },
+    // 已定稿记录（Static：只渲染一次，天然滚动）
+    h(Static, { items: logItems }, (item) => h(LogLine, { key: item.id, item })),
+    // 思考过程（reasoning，流式、不入定稿记录）
+    thinkRef.current
+      ? h(Box, null, h(Text, { color: 'gray', italic: true }, '✦ 思考 ' + thinkRef.current.replace(/\n/g, ' ').slice(-160)))
+      : null,
+    // 流式正文
+    liveRef.current ? h(Box, { marginTop: 0 }, h(Text, null, liveRef.current)) : null,
+    // 任务清单（todo_write 实时更新）
+    todos.length
+      ? h(
+          Box,
+          { flexDirection: 'column', paddingLeft: 2, marginTop: 1 },
+          ...todos.map((t, i) =>
+            h(
+              Text,
+              {
+                key: i,
+                color: t.status === 'completed' ? 'green' : t.status === 'in_progress' ? 'cyan' : 'gray',
+                dimColor: t.status === 'completed',
+                bold: t.status === 'in_progress',
+              },
+              (t.status === 'completed' ? '☑ ' : t.status === 'in_progress' ? '◐ ' : '☐ ') + t.content,
+            ),
+          ),
+        )
+      : null,
+    // 思考 spinner
+    status === 'busy' && !liveRef.current
+      ? h(Box, null, h(Text, { color: 'cyan' }, SPINNER[spin] + ' 思考中…'), h(Text, { color: 'gray' }, '（Esc 中断 · 输入回车可排队补充）'))
+      : null,
+    // 授权提示
+    pending
+      ? h(
+          Box,
+          { flexDirection: 'column', borderStyle: 'round', borderColor: 'yellow', paddingX: 1, marginTop: 1 },
+          h(Text, { color: 'yellow', bold: true }, '● 需要授权：' + pending.label),
+          pending.risk ? h(Text, { color: 'red', bold: true }, '⚠ ' + pending.risk) : null,
+          pending.name === 'run_bash' ? h(Text, { color: 'gray' }, '$ ' + (pending.args.command || '')) : null,
+          pending.name === 'fetch_url' ? h(Text, { color: 'gray' }, 'GET ' + (pending.args.url || '')) : null,
+          h(Text, null, '[y] 允许一次 · [a] 本会话 · [A] 永久(写入项目设置) · [n/Esc] 拒绝'),
+        )
+      : null,
+    // 输入行（带光标；忙时输入会排队）
+    h(
+      Box,
+      { marginTop: 1 },
+      h(Text, { color: status === 'busy' ? 'yellow' : 'cyan' }, status === 'busy' ? '⧗ ' : '› '),
+      h(Text, null, before),
+      h(Text, { inverse: true }, at),
+      h(Text, null, after),
+    ),
+    // 状态栏
+    h(
+      Box,
+      null,
+      h(
+        Text,
+        { color: 'gray' },
+        `${cwdName} · ${config.model}${yoloRef.current ? ' · ⚠ yolo' : ''}`
+          + ` · tok ${usage.prompt}/${usage.completion}`
+          + (ctxTok ? ` · ctx ~${fmtTok(ctxTok)}` : '')
+          + (queueLen ? ` · 排队 ${queueLen}` : '')
+          + ' · /help',
+      ),
+    ),
+  );
+}
+
+/** 单行记录渲染（按 kind 着色）。 */
+function LogLine({ item }) {
+  const { kind, text } = item;
+  if (kind === 'user') return h(Box, { marginTop: 1 }, h(Text, { color: 'cyan', bold: true }, '› '), h(Text, { bold: true }, text));
+  if (kind === 'assistant') return h(Box, null, h(Text, null, text));
+  if (kind === 'tool') return h(Text, { color: 'cyan' }, '  ⏺ ' + text);
+  if (kind === 'toolresult') return h(Text, { color: 'gray' }, '     ' + text);
+  if (kind === 'skip') return h(Text, { color: 'gray' }, '  ⊘ ' + text);
+  if (kind === 'info') {
+    // 失败/错误类信息用红色高亮，避免被淹没（如「模型调用失败：令牌校验失败」）
+    const isErr = /✗|失败|错误|error/i.test(text);
+    return h(Text, { color: isErr ? 'red' : 'yellow' }, (isErr ? '  ✗ ' : '  · ') + text.replace(/^✗\s*/, ''));
+  }
+  return h(Text, null, text);
+}
+
+/**
+ * 启动 ink TUI。先（在 ink 接管屏幕前）连接 MCP 并打印连接信息，再进入全屏界面；退出后关闭 MCP。
+ */
+export async function runInk({ config, cwd, session, yolo, initialPrompt, version }) {
+  process.stdout.write(`\n  huicai · 终端智能体（ink TUI） · ${config.model}\n`);
+  const { extraTools, clients } = await buildExtraTools(config, cwd);
+  const { waitUntilExit } = render(
+    h(App, { config, cwd, session, extraTools, yolo, initialPrompt, version, onExit: () => closeMcp(clients) }),
+  );
+  await waitUntilExit();
+  closeMcp(clients);
+}