@huicai/cli 0.5.1

package/bin/huicai.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+// huicai —— 终端智能体入口：解析参数并分发（交互 / 一次性 / login / models / help）。
+
+import readline from 'node:readline';
+import path from 'node:path';
+import { c } from '../src/colors.js';
+import { loadConfig, saveConfig, CONFIG_PATH, DEFAULT_MODEL } from '../src/config.js';
+import { listModels, getAgentPersona, fetchUsage, listPlatformSkills, getPlatformSkill, pushPlatformSkill } from '../src/api.js';
+import { deviceLogin } from '../src/device.js';
+import { startRepl, runOnce } from '../src/repl.js';
+import { buildSystemPrompt } from '../src/context.js';
+import * as sessions from '../src/session.js';
+import { loadLocalSkills, skillDirs, writeSkillToDir, readSkillDirForPush } from '../src/skills.js';
+
+const VERSION = '0.5.1';
+
+function parse(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '--yolo':
+        flags.yolo = true;
+        break;
+      case '-p':
+      case '--print':
+        flags.print = true;
+        break;
+      case '-h':
+      case '--help':
+        flags.help = true;
+        break;
+      case '-v':
+      case '--version':
+        flags.version = true;
+        break;
+      case '-m':
+      case '--model':
+        flags.model = argv[++i];
+        break;
+      case '--base':
+        flags.base = argv[++i];
+        break;
+      case '--key':
+        flags.key = argv[++i];
+        break;
+      case '--cwd':
+        flags.cwd = argv[++i];
+        break;
+      case '--agent':
+        flags.agent = argv[++i];
+        break;
+      case '--project':
+        flags.project = true;
+        break;
+      case '--overwrite':
+        flags.overwrite = true;
+        break;
+      case '--paste':
+        flags.paste = true;
+        break;
+      case '-c':
+      case '--continue':
+        flags.continue = true;
+        break;
+      case '-r':
+      case '--resume':
+        flags.resume = true;
+        break;
+      case '-a':
+      case '--all':
+        flags.all = true;
+        break;
+      case '--tui':
+        flags.tui = true;
+        break;
+      case '--plain':
+        flags.plain = true;
+        break;
+      case '--file':
+        flags.file = argv[++i];
+        break;
+      case '--prompt':
+        flags.prompt = argv[++i];
+        break;
+      case '--output-format':
+        flags.outputFormat = argv[++i];
+        break;
+      case '--max-turns':
+        flags.maxTurns = parseInt(argv[++i], 10);
+        break;
+      case '--system-prompt':
+        flags.systemPrompt = argv[++i];
+        break;
+      case '--append-system-prompt':
+        flags.appendSystemPrompt = argv[++i];
+        break;
+      default:
+        positional.push(a);
+    }
+  }
+  return { flags, positional };
+}
+
+function usage() {
+  process.stdout.write(`
+${c.bold('huicai')} — 终端智能体，以 HuiCai_AI 平台为模型后端，在本机执行工具。
+
+用法:
+  huicai                     进入交互式会话（当前目录）
+  huicai "帮我修复登录bug"     进入会话并先执行该指令
+  huicai -p "运行测试并总结"   一次性执行后退出（脚本/CI；写/执行需 --yolo）
+  cat err.log | huicai -p "分析这段日志"   管道内容自动作为上下文
+  huicai --agent <id>        采用某已发布智能体的人格（工具仍在本机执行）
+  huicai -c ["prompt"]       继续当前目录最近一次会话
+  huicai -r                  从当前目录历史会话中选择恢复
+  huicai resume <id>         恢复指定会话
+  huicai sessions [-a]       列出历史会话（-a 跨目录全部）
+  huicai login               浏览器授权登录（内置平台地址，无需输入网关）
+  huicai login --paste       无浏览器环境：手动粘贴 API 令牌
+  huicai models              列出可用模型
+  huicai usage               查看 Token 用量窗口（5小时/7天，按会员等级）
+  huicai skills              列出本地 + 平台技能（Agent Skills）
+  huicai skills pull [name]  平台技能 → 本地（默认 ~/.huicai/skills；--project 放入项目）
+  huicai skills push <name>  本地技能 → 平台（默认同名跳过；--overwrite 覆盖）
+  huicai help                显示本帮助
+
+选项:
+  -m, --model <id>       指定模型（覆盖配置）
+  --agent <id>           采用平台智能体人格（分享令牌或 agent-xxx）
+  -c, --continue         继续最近一次会话（当前目录）
+  -r, --resume           选择并恢复历史会话（当前目录）
+  --base <url>           覆盖内置平台地址（自建 / 联调用）
+  --key <sk-...>         API 令牌（覆盖配置）
+  --cwd <dir>            指定工作目录（默认当前目录）
+  --yolo                 自动放行写/执行工具（谨慎）
+  --tui / --plain        强制富 TUI（ink）/ 普通 REPL（默认 TTY 下自动用 TUI）
+  -p, --print            一次性非交互模式
+  --output-format <fmt>  -p 输出格式：text（默认）| json（结构化，脚本集成）
+  --max-turns <n>        单回合最大工具轮数（默认 60）
+  --system-prompt <s>        完全替换系统提示词（-p/新会话）
+  --append-system-prompt <s> 在系统提示词末尾追加指示
+  -h, --help             帮助
+  -v, --version          版本
+
+交互技巧:
+  /help 查看命令 · @文件路径 引用文件内容 · !命令 直通 shell（输出进上下文）
+  自定义命令：.huicai/commands/<名>.md（$ARGUMENTS 为参数占位符）
+  权限规则：.huicai/settings.json {"permissions":{"allow":["run_bash(git *)"]}}
+
+会话默认自动保存到 ~/.huicai/sessions（按项目目录归属），随时可 -c/-r 恢复。
+
+配置: ${CONFIG_PATH}（或环境变量 HUICAI_BASE_URL / HUICAI_API_KEY / HUICAI_MODEL / HUICAI_MAX_TURNS）
+`);
+}
+
+async function login(flags = {}) {
+  const cur = loadConfig();
+  // 网关地址内置默认（huicai-ai.sjht.com）；仅在显式 --base / 环境变量时覆盖，用户无需输入
+  const normBase = (flags.base ? String(flags.base) : cur.baseUrl).replace(/\/+$/, '');
+
+  let key = cur.apiKey;
+  if (!flags.paste) {
+    // 默认：直接打开浏览器授权（设备码流），无需任何输入
+    process.stdout.write(c.bold('\n登录 huicai') + c.gray(` · ${normBase}`) + '\n');
+    try {
+      key = await deviceLogin(normBase);
+    } catch (e) {
+      process.stdout.write(c.yellow(`浏览器授权未完成（${e.message}），可改用 huicai login --paste 手动粘贴令牌。`) + '\n');
+      return;
+    }
+  } else {
+    // 显式 --paste：无浏览器环境下手动粘贴令牌
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    key = (await new Promise((r) => rl.question(`API 令牌 (sk-huicai-…)${cur.apiKey ? ' [回车保留已保存]' : ''}: `, r))).trim()
+      || cur.apiKey;
+    rl.close();
+    if (!key) {
+      process.stdout.write(c.red('未提供令牌。\n'));
+      return;
+    }
+  }
+
+  // 校验令牌并挑一个「原始渠道模型」作默认（智能体伪模型 agent-/workflow-/datahuman- 走服务端编排，
+  // 不适合 CLI 的本机工具循环——用 `huicai --agent <ref>` 才是采用智能体的正确方式）。
+  let model = cur.model;
+  let tokenOk = true;
+  try {
+    const models = await listModels(normBase, key);
+    const raw = models.map((m) => m.id).filter((id) => !/^(agent|workflow|datahuman)-/.test(id));
+    if (models.length === 0) {
+      process.stdout.write(c.yellow('⚠ 已拿到令牌，但平台没返回任何可用模型——通常是令牌无效或账号无模型权限，请联系管理员。') + '\n');
+    } else if (raw.length === 0) {
+      process.stdout.write(c.yellow('⚠ 你的账号没有可直连的原始模型（本机工具循环不可用）。仍可 `huicai -m agent-xxx` 与智能体/数字人/工作流做平台编排对话，或 `huicai --agent <分享令牌>`。') + '\n');
+    } else if (!raw.includes(model)) {
+      // 当前(默认)模型不在账号可用清单里 → 优先内置默认模型，否则退回第一个原始模型
+      model = raw.includes(DEFAULT_MODEL) ? DEFAULT_MODEL : raw[0];
+    }
+  } catch (e) {
+    tokenOk = false;
+    process.stdout.write(c.red('⚠ 令牌校验失败：' + e.message) + '\n');
+  }
+
+  saveConfig({ baseUrl: normBase, apiKey: key, model });
+  if (tokenOk) {
+    process.stdout.write(c.green('登录成功') + (model ? c.gray(` · 默认模型 ${model}`) : '') + '\n');
+    process.stdout.write(c.gray(`已保存到 ${CONFIG_PATH}，直接运行 huicai 开始。`) + '\n');
+  } else {
+    process.stdout.write(c.yellow(`令牌已保存到 ${CONFIG_PATH}，但校验未通过——请重试 huicai login 或联系管理员。`) + '\n');
+  }
+}
+
+function validateAuth(config) {
+  if (!config.baseUrl) return c.red('未配置平台地址。运行 `huicai login` 或设置 HUICAI_BASE_URL。');
+  if (!config.apiKey) return c.red('未配置 API 令牌。运行 `huicai login` 或设置 HUICAI_API_KEY。');
+  return null;
+}
+
+async function cmdModels(config) {
+  const problem = validateAuth(config);
+  if (problem) {
+    process.stderr.write(problem + '\n');
+    process.exit(1);
+  }
+  try {
+    const models = await listModels(config.baseUrl, config.apiKey);
+    process.stdout.write(models.map((m) => m.id).join('\n') + '\n');
+  } catch (e) {
+    process.stderr.write(c.red('拉取失败：' + e.message) + '\n');
+    process.exit(1);
+  }
+}
+
+/** usage 子命令：显示当前令牌用户的 5 小时 / 7 天 Token 用量窗口（按会员等级）。 */
+async function cmdUsage(config) {
+  const problem = validateAuth(config);
+  if (problem) {
+    process.stderr.write(problem + '\n');
+    process.exit(1);
+  }
+  const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+  const fmt = (used, limit) => {
+    used = num(used);
+    limit = num(limit);
+    if (limit < 0) return `${used.toLocaleString()} / 无限`;
+    if (limit === 0) return '该档未开放';
+    const pct = Math.min(100, Math.round((used / limit) * 100));
+    return `${used.toLocaleString()} / ${limit.toLocaleString()} (${pct}%)`;
+  };
+  try {
+    const u = await fetchUsage(config.baseUrl, config.apiKey);
+    // 平台未部署 /v1/usage 或返回异常结构时给出清晰提示，而非崩栈
+    if (!u || (typeof u.used5h !== 'number' && typeof u.used7d !== 'number')) {
+      process.stderr.write(c.red('拉取用量失败：平台未返回用量数据（请确认平台已支持 /v1/usage）') + '\n');
+      process.exit(1);
+    }
+    process.stdout.write(c.bold('Token 用量窗口（按会员等级）') + '\n');
+    process.stdout.write('  近 5 小时：' + fmt(u.used5h, u.limit5h) + '\n');
+    process.stdout.write('  近 7 天　：' + fmt(u.used7d, u.limit7d) + '\n');
+    if (!u.allowed && u.message) {
+      process.stdout.write(c.yellow('  ' + u.message) + '\n');
+    } else if (u.resetAtEpochMs) {
+      process.stdout.write(c.gray('  最早释放：' + new Date(u.resetAtEpochMs).toLocaleString()) + '\n');
+    }
+  } catch (e) {
+    process.stderr.write(c.red('拉取用量失败：' + e.message) + '\n');
+    process.exit(1);
+  }
+}
+
+/**
+ * skills 子命令：本地技能与平台云端技能库的查看/同步。
+ *   huicai skills                    列出本地 + 平台技能
+ *   huicai skills pull [name]       平台 → 本地（默认 ~/.huicai/skills；--project 放入项目 .huicai/skills）
+ *   huicai skills push <name|目录>   本地 → 平台（默认同名跳过；--overwrite 覆盖）
+ */
+async function cmdSkills(config, args, flags, cwd) {
+  const action = args[0] || 'list';
+  const locals = loadLocalSkills(cwd);
+
+  if (action === 'list') {
+    process.stdout.write(c.bold('本地技能') + c.gray('（.huicai/skills 与 ~/.huicai/skills）') + '\n');
+    if (!locals.length) {
+      process.stdout.write(c.gray('  （无。huicai skills pull 可从平台拉取）') + '\n');
+    } else {
+      for (const s of locals) {
+        process.stdout.write(`  ${s.name}${s.version ? c.gray(' v' + s.version) : ''}`
+          + c.gray(`（${s.scope === 'project' ? '项目' : '全局'}${s.files.length ? ` · ${s.files.length} 附件` : ''}）`)
+          + (s.description ? c.gray(' ' + s.description.slice(0, 60)) : '') + '\n');
+      }
+    }
+    const problem = validateAuth(config);
+    if (problem) {
+      process.stdout.write(c.gray('（未登录，跳过平台技能列表；huicai login 后可 pull/push）') + '\n');
+      return;
+    }
+    try {
+      const remote = await listPlatformSkills(config.baseUrl, config.apiKey);
+      process.stdout.write(c.bold('平台技能') + c.gray('（文档技能，' + config.baseUrl + '）') + '\n');
+      if (!remote.length) {
+        process.stdout.write(c.gray('  （无）') + '\n');
+        return;
+      }
+      const localNames = new Set(locals.map((s) => s.name));
+      for (const s of remote) {
+        process.stdout.write(`  ${s.name}${s.version ? c.gray(' v' + s.version) : ''}`
+          + (localNames.has(s.name) ? c.green(' [已在本地]') : '')
+          + (s.description ? c.gray(' ' + String(s.description).slice(0, 60)) : '') + '\n');
+      }
+      process.stdout.write(c.gray('（huicai skills pull [name] 拉取到本地）') + '\n');
+    } catch (e) {
+      process.stderr.write(c.red('拉取平台技能失败：' + e.message) + '\n');
+    }
+    return;
+  }
+
+  const problem = validateAuth(config);
+  if (problem) {
+    process.stderr.write(problem + '\n');
+    process.exit(1);
+  }
+
+  if (action === 'pull') {
+    const wanted = args[1] || '';
+    const baseDir = flags.project ? skillDirs(cwd)[0] : skillDirs(cwd)[skillDirs(cwd).length - 1];
+    try {
+      const remote = await listPlatformSkills(config.baseUrl, config.apiKey);
+      const targets = wanted ? remote.filter((s) => s.name === wanted) : remote;
+      if (!targets.length) {
+        process.stderr.write(c.red(wanted ? `平台上没有技能：${wanted}` : '平台上没有可拉取的文档技能') + '\n');
+        process.exit(1);
+      }
+      for (const s of targets) {
+        const detail = await getPlatformSkill(config.baseUrl, config.apiKey, s.id);
+        const dir = writeSkillToDir(baseDir, detail);
+        process.stdout.write(c.green('已拉取 ') + s.name
+          + c.gray(`（${detail.files?.length || 0} 附件）→ ${dir}`) + '\n');
+      }
+      process.stdout.write(c.gray('新会话中生效（系统提示词注入技能目录，load_skill 按需载入）。') + '\n');
+    } catch (e) {
+      process.stderr.write(c.red('拉取失败：' + e.message) + '\n');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (action === 'push') {
+    const target = args[1];
+    if (!target) {
+      process.stderr.write(c.red('用法：huicai skills push <本地技能名|技能目录> [--overwrite]') + '\n');
+      process.exit(1);
+    }
+    // 按本地技能名解析（项目级优先），否则视为目录路径
+    const local = locals.find((s) => s.name === target);
+    const dir = local ? local.dir : path.resolve(cwd, target);
+    let payload;
+    try {
+      payload = readSkillDirForPush(dir);
+    } catch (e) {
+      process.stderr.write(c.red(`读取技能失败（目录须含 SKILL.md）：${e.message}`) + '\n');
+      process.exit(1);
+    }
+    try {
+      const r = await pushPlatformSkill(config.baseUrl, config.apiKey, {
+        ...payload, conflict: flags.overwrite ? 'overwrite' : 'skip',
+      });
+      const label = r.status === 'imported' ? '已推送（新建）'
+        : r.status === 'overwritten' ? '已推送（覆盖同名）' : '已跳过：平台已有同名技能（--overwrite 可覆盖）';
+      process.stdout.write((r.status === 'skipped' ? c.yellow(label) : c.green(label))
+        + c.gray(` · ${payload.filename} → ${config.baseUrl}`) + '\n');
+      for (const w of r.warnings || []) {
+        process.stdout.write(c.yellow('  规范提示：' + w) + '\n');
+      }
+    } catch (e) {
+      process.stderr.write(c.red('推送失败：' + e.message) + '\n');
+      process.exit(1);
+    }
+    return;
+  }
+
+  process.stderr.write(c.red(`未知子命令：skills ${action}（可用：list / pull / push）`) + '\n');
+  process.exit(1);
+}
+
+/** -p 模式下读取管道 stdin（若有）：作为提示词本体或附加上下文。上限 5MB。 */
+async function readPipedStdin() {
+  if (process.stdin.isTTY) return '';
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+    size += chunk.length;
+    if (size > 5 * 1024 * 1024) break;
+  }
+  return Buffer.concat(chunks).toString('utf8').trim();
+}
+
+async function main() {
+  const { flags, positional } = parse(process.argv.slice(2));
+  if (flags.version) {
+    process.stdout.write('huicai ' + VERSION + '\n');
+    return;
+  }
+  const sub = positional[0];
+  if (flags.help || sub === 'help') {
+    usage();
+    return;
+  }
+  if (sub === 'login') {
+    await login(flags);
+    return;
+  }
+
+  const config = loadConfig();
+  if (flags.base) config.baseUrl = flags.base.replace(/\/+$/, '');
+  if (flags.key) config.apiKey = flags.key;
+  if (flags.model) config.model = flags.model;
+  if (Number.isFinite(flags.maxTurns) && flags.maxTurns > 0) config.maxTurns = flags.maxTurns;
+  const cwd = flags.cwd ? path.resolve(flags.cwd) : process.cwd();
+
+  // 会话列表：纯本地，无需鉴权
+  if (sub === 'sessions') {
+    cmdSessions(cwd, flags.all || positional.includes('--all') || positional.includes('-a'));
+    return;
+  }
+
+  if (sub === 'models') {
+    await cmdModels(config);
+    return;
+  }
+
+  if (sub === 'usage') {
+    await cmdUsage(config);
+    return;
+  }
+
+  if (sub === 'skills') {
+    await cmdSkills(config, positional.slice(1), flags, cwd);
+    return;
+  }
+
+  const problem = validateAuth(config);
+  if (problem) {
+    process.stderr.write(problem + '\n');
+    process.exit(1);
+  }
+
+  // --agent：采用平台智能体人格（其模型/系统提示词），工具仍在本机执行
+  let persona = null;
+  if (flags.agent) {
+    try {
+      const p = await getAgentPersona(config.baseUrl, config.apiKey, flags.agent);
+      persona = p?.systemPrompt || null;
+      if (p?.model && !flags.model) config.model = p.model; // 未显式 -m 时采用智能体的模型
+      process.stdout.write(c.gray(`已采用智能体人格：${p?.name || flags.agent}`) + '\n');
+    } catch (e) {
+      process.stderr.write(c.red('获取智能体人格失败：' + e.message) + '\n');
+      process.exit(1);
+    }
+  }
+
+  // 恢复会话：resume <id> 子命令 / -r 选择器 / -c 最近一次
+  let resumeId = null;
+  let positionalPrompt = positional;
+  if (sub === 'resume') {
+    resumeId = positional[1] || null;
+    positionalPrompt = positional.slice(2);
+    if (!resumeId) resumeId = await pickSession(cwd);
+    if (!resumeId) return; // 无会话/取消
+  } else if (flags.resume) {
+    resumeId = await pickSession(cwd);
+    if (!resumeId) return;
+  } else if (flags.continue) {
+    resumeId = sessions.mostRecent(cwd);
+    if (!resumeId) process.stdout.write(c.gray('当前目录暂无历史会话，将开启新会话。') + '\n');
+  }
+
+  let session = resumeId ? sessions.loadSession(resumeId) : null;
+  if (resumeId && !session) {
+    process.stderr.write(c.red('未找到会话: ' + resumeId) + '\n');
+    process.exit(1);
+  }
+  const resuming = !!session;
+  if (session && !flags.model && !flags.agent && session.model) {
+    config.model = session.model; // 恢复会话默认沿用其模型（-m/--agent 可覆盖）
+  }
+
+  if (!config.model) {
+    process.stderr.write(
+      c.red('未设置模型。用 `huicai -m <模型>`、`huicai login` 设置，或先 `huicai models` 查看可用模型。') + '\n',
+    );
+    process.exit(1);
+  }
+
+  // 新会话：用当前 cwd/persona 构建系统提示词（--system-prompt 完全替换、--append-system-prompt 追加）
+  if (!session) {
+    const sys = flags.systemPrompt
+      ? flags.systemPrompt
+      : buildSystemPrompt(cwd, { persona, append: flags.appendSystemPrompt });
+    session = sessions.createSession({ cwd, model: config.model, messages: [{ role: 'system', content: sys }] });
+  }
+
+  // 编辑器上下文（VS Code 扩展经 --file / 环境变量注入）；context.js 会据此加入系统提示词
+  if (flags.file) process.env.HUICAI_IDE_FILE = flags.file;
+
+  let prompt = (flags.prompt || positionalPrompt.join(' ')).trim();
+
+  if (flags.print) {
+    // 管道 stdin：有提示词则作为附加上下文，无提示词则直接作为提示词（cat log | huicai -p）
+    const piped = await readPipedStdin();
+    if (piped) {
+      prompt = prompt ? `${prompt}\n\n【以下为管道输入(stdin)】\n${piped}` : piped;
+    }
+    await runOnce({
+      config, cwd, yolo: flags.yolo, prompt, session,
+      persist: resuming,
+      outputFormat: flags.outputFormat || 'text',
+      maxTurns: config.maxTurns || undefined,
+    });
+    return;
+  }
+
+  // 交互式：默认富 TUI（ink，需已安装依赖 + TTY）；--plain 强制普通 REPL；TUI 不可用则自动回退
+  const wantTui = flags.tui || (!flags.plain && process.stdout.isTTY && process.stdin.isTTY);
+  if (wantTui) {
+    try {
+      const { runInk } = await import('../src/tui/app.js');
+      await runInk({ config, cwd, session, yolo: flags.yolo, initialPrompt: prompt || null, version: VERSION });
+      return;
+    } catch (e) {
+      process.stderr.write(c.gray('（未启用 TUI：' + e.message + '，回退普通模式）') + '\n');
+    }
+  }
+  await startRepl({ config, cwd, yolo: flags.yolo, initialPrompt: prompt || null, session, version: VERSION });
+}
+
+/** 交互式选择要恢复的会话（当前目录）；返回选中的会话 id，或 null（无会话/取消）。 */
+async function pickSession(cwd) {
+  const list = sessions.listSessions(cwd);
+  if (!list.length) {
+    process.stdout.write(c.gray('当前目录暂无历史会话。') + '\n');
+    return null;
+  }
+  process.stdout.write(c.bold('\n历史会话（当前目录）:') + '\n');
+  list.slice(0, 20).forEach((s, i) => {
+    process.stdout.write(
+      `  ${c.cyan(String(i + 1).padStart(2))}) ${c.gray(sessions.relTime(s.updatedAt).padStart(8))}  ${s.title}  ${c.gray(s.turns + '轮')}\n`,
+    );
+  });
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ans = await new Promise((r) => rl.question(c.cyan('\n选择编号恢复（回车取消）: '), r));
+  rl.close();
+  const idx = parseInt(String(ans).trim(), 10);
+  if (!ans || Number.isNaN(idx) || idx < 1 || idx > list.length) return null;
+  return list[idx - 1].id;
+}
+
+/** 列出会话（huicai sessions）。 */
+function cmdSessions(cwd, all) {
+  const list = sessions.listSessions(all ? null : cwd);
+  if (!list.length) {
+    process.stdout.write(all ? '暂无历史会话。\n' : '当前目录暂无历史会话（-a/--all 查看全部）。\n');
+    return;
+  }
+  for (const s of list) {
+    process.stdout.write(
+      `${c.gray(sessions.relTime(s.updatedAt).padStart(9))}  ${c.bold(s.id)}  ${c.gray(s.turns + '轮')}  ${s.title}\n`,
+    );
+    if (all) process.stdout.write(c.gray(`            ${s.cwd || ''}`) + '\n');
+  }
+  process.stdout.write(c.gray('\n恢复：huicai resume <id>  或  huicai -c（最近一次）\n'));
+}
+
+main().catch((e) => {
+  process.stderr.write(c.red('\n致命错误：' + (e?.stack || e?.message || e)) + '\n');
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@huicai/cli",
+  "version": "0.5.1",
+  "description": "在终端运行的智能体 CLI：以 HuiCai_AI 平台的 OpenAI 兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
+  "type": "module",
+  "bin": {
+    "huicai": "bin/huicai.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/huicai.js",
+    "check": "node --check bin/huicai.js",
+    "test": "node --test --test-concurrency=1 test/*.test.mjs",
+    "prepublishOnly": "node --check bin/huicai.js"
+  },
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "terminal",    "huicai",
+    "openai-compatible",
+    "coding-agent"
+  ],
+  "author": "ChenBo",
+  "license": "MIT",
+  "homepage": "https://github.com/SJHT-SDK/huicai-cli/tree/master#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SJHT-SDK/huicai-cli.git/",
+    "directory": "huicai-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/SJHT-SDK/huicai-cli/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ink": "^7.1.0",
+    "react": "^19.2.7"
+  }
+}