haoyuan 1.0.0 → 1.1.0

package/README.md

@@ -109,6 +109,36 @@ Kernel（会话 / 事件 / 工具注册 / 策略 / 模型网关 / 审批）
 - Node.js 18+
 - Windows / Linux / macOS
 
+### npm 安装（推荐）
+
+```bash
+# 前提：Node.js 18+、Python 3.10+
+npm install -g haoyuan
+
+# 国内加速：
+npm install -g haoyuan --registry=https://registry.npmmirror.com
+
+# 终端对话（首次自动创建 venv、安装依赖）
+haoyuan
+
+# 启动服务并自动打开网页
+haoyuan web
+```
+
+| 命令 | 作用 |
+|---|---|
+| `haoyuan` | 终端对话（流式输出、工具调用、审批确认） |
+| `haoyuan web` | 启动服务并自动打开网页 |
+| `haoyuan web --no-open` | 启动服务但不打开浏览器 |
+| `haoyuan --version` / `-V` | 查看版本号 |
+| `haoyuan login` / `haoyuan logout` | 账号保护开启时登录 / 清除本地令牌 |
+| `haoyuan setup` | 仅预装依赖 |
+| `haoyuan help` | 显示帮助 |
+
+终端内命令：`/new` 新建会话、`/web` 在浏览器打开当前会话、`/cancel` 取消当前任务、`/exit` 退出（Ctrl+C 同样有效）。
+
+网页默认地址 `http://127.0.0.1:8030`，端口被占用自动 +1。未配置模型 Key 时使用内置 `mock` 模型，会话、工具调用、审批与前端均可完整运行。
+
 ### Windows 一键启动
 
 ```bat

package/bin/haoyuan.js

@@ -3,9 +3,17 @@
 
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
+const http = require("http");
 const path = require("path");
+const readline = require("readline");
 
 const ROOT = path.resolve(__dirname, "..");
+let VERSION = "0.0.0";
+try {
+  VERSION = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8")).version || VERSION;
+} catch {
+  /* ignore */
+}
 const IS_WIN = process.platform === "win32";
 const NPM = IS_WIN ? "npm.cmd" : "npm";
 const VENV = path.join(ROOT, "api", "env1");
@@ -16,6 +24,48 @@ const WEB = path.join(ROOT, "web");
 const API = path.join(ROOT, "api");
 const RUNTIME_FILE = path.join(API, "data", "runtime.json");
 const DIST_INDEX = path.join(WEB, "dist", "index.html");
+const TOKEN_FILE = path.join(API, "data", "cli-token");
+let TOKEN = (process.env.HAOYUAN_TOKEN || "").trim();
+if (!TOKEN) {
+  try {
+    TOKEN = fs.readFileSync(TOKEN_FILE, "utf8").trim();
+  } catch {
+    TOKEN = "";
+  }
+}
+
+function saveToken(token) {
+  TOKEN = token;
+  try {
+    fs.mkdirSync(path.dirname(TOKEN_FILE), { recursive: true });
+    fs.writeFileSync(TOKEN_FILE, token);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function clearToken() {
+  TOKEN = "";
+  try {
+    fs.unlinkSync(TOKEN_FILE);
+  } catch {
+    /* ignore */
+  }
+}
+
+const COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+const C = COLOR
+  ? {
+      reset: "\x1b[0m",
+      dim: "\x1b[2m",
+      bold: "\x1b[1m",
+      cyan: "\x1b[36m",
+      green: "\x1b[32m",
+      red: "\x1b[31m",
+      yellow: "\x1b[33m",
+    }
+  : { reset: "", dim: "", bold: "", cyan: "", green: "", red: "", yellow: "" };
 
 function log(msg) {
   process.stdout.write(`[HaoYuan] ${msg}\n`);
@@ -38,8 +88,7 @@ function shellQuote(s) {
 function run(cmd, args, opts = {}) {
   const lenient = opts.lenient === true;
   const useShell = IS_WIN && /\.(cmd|bat)$/i.test(cmd);
-  const display = useShell ? `${cmd} ${args.join(" ")}` : `${cmd} ${args.join(" ")}`;
-  log(display);
+  log(`${cmd} ${args.join(" ")}`);
   const r = spawnSync(
     cmd,
     useShell ? args.map(shellQuote) : args,
@@ -121,20 +170,23 @@ function readApiPort() {
   }
 }
 
+async function healthyPort(port) {
+  if (!port) return false;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
 async function waitUntilHealthy(timeoutMs = 180000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const port = readApiPort();
-    if (port) {
-      try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
-          signal: AbortSignal.timeout(1500),
-        });
-        if (res.ok) return port;
-      } catch {
-        /* 服务未就绪，继续等待 */
-      }
-    }
+    if (await healthyPort(port)) return port;
     await new Promise((r) => setTimeout(r, 500));
   }
   return 0;
@@ -169,7 +221,16 @@ function postinstall() {
   }
 }
 
-async function start(options = {}) {
+async function web(options = {}) {
+  const running = await healthyPort(readApiPort());
+  if (running) {
+    const url = `http://127.0.0.1:${running}`;
+    log(`服务已在运行: ${url}`);
+    if (options.noOpen) log(`（--no-open 模式，请手动打开 ${url}）`);
+    else openBrowser(url);
+    return;
+  }
+
   if (!fs.existsSync(PYTHON)) {
     log("首次运行，安装后端依赖 ...");
     setup({ build: !fs.existsSync(DIST_INDEX) });
@@ -203,44 +264,637 @@ async function start(options = {}) {
   }
 }
 
-const argv = process.argv.slice(2);
-const command = argv[0] || "start";
-const noOpen = argv.includes("--no-open");
-const noBuild = argv.includes("--no-build");
-
-switch (command) {
-  case "start":
-    start({ noOpen });
-    break;
-  case "setup":
-    setup({ build: !noBuild });
-    break;
-  case "build":
-    buildFrontend();
-    break;
-  case "postinstall":
-    postinstall();
-    break;
-  case "help":
-  case "-h":
-  case "--help":
+async function ensureServer() {
+  const running = await healthyPort(readApiPort());
+  if (running) return { port: running, child: null };
+
+  if (!fs.existsSync(PYTHON)) {
+    log("首次运行，安装后端依赖 ...");
+    setup({ build: !fs.existsSync(DIST_INDEX) });
+  }
+  if (!fs.existsSync(DIST_INDEX)) buildFrontend();
+
+  log("启动 API（端口 8030，被占用时自动顺延）...");
+  let tail = "";
+  const child = spawn(PYTHON, ["main.py"], {
+    cwd: API,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+  });
+  const keep = (chunk) => {
+    tail = (tail + chunk.toString()).slice(-4000);
+  };
+  child.stdout.on("data", keep);
+  child.stderr.on("data", keep);
+  child.on("error", (err) => {
+    warn(`服务启动失败: ${err.message}`);
+    process.exit(1);
+  });
+
+  const port = await waitUntilHealthy();
+  if (!port) {
+    child.kill();
+    warn("服务启动超时。服务日志:");
+    if (tail) process.stderr.write(tail + "\n");
+    process.exit(1);
+  }
+  log(`服务已就绪: http://127.0.0.1:${port}`);
+  return { port, child };
+}
+
+function apiHeaders() {
+  const headers = { "content-type": "application/json" };
+  if (TOKEN) {
+    headers["authorization"] = `Bearer ${TOKEN}`;
+    headers["x-haoyuan-token"] = TOKEN;
+  }
+  return headers;
+}
+
+async function apiJson(port, method, apiPath, body) {
+  const res = await fetch(`http://127.0.0.1:${port}${apiPath}`, {
+    method,
+    headers: apiHeaders(),
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(30000),
+  });
+  let payload = null;
+  try {
+    payload = await res.json();
+  } catch {
+    /* ignore */
+  }
+  if (!payload || payload.code !== 200) {
+    throw new Error((payload && payload.message) || `HTTP ${res.status}`);
+  }
+  return payload.data;
+}
+
+function shortJson(value, limit = 120) {
+  let text;
+  try {
+    text = JSON.stringify(value);
+  } catch {
+    text = String(value);
+  }
+  if (!text) text = "";
+  return text.length > limit ? `${text.slice(0, limit)}…` : text;
+}
+
+function ask(rl, promptText, { mute = false } = {}) {
+  return new Promise((resolve) => {
+    if (!mute) {
+      rl.question(promptText, resolve);
+      return;
+    }
+    process.stdout.write(promptText);
+    const original = rl._writeToOutput;
+    rl._writeToOutput = () => {};
+    rl.question("", (answer) => {
+      rl._writeToOutput = original;
+      process.stdout.write("\n");
+      resolve(answer);
+    });
+  });
+}
+
+async function loginAt(port, rl) {
+  const statusRes = await fetch(`http://127.0.0.1:${port}/api/auth/status`, {
+    signal: AbortSignal.timeout(10000),
+  });
+  const status = await statusRes.json().catch(() => null);
+  const data = (status && status.data) || {};
+  if (!data.configured) {
+    log("该实例未开启账号保护，无需登录。");
+    return "";
+  }
+  const username = (await ask(rl, `用户名${data.username ? `（${data.username}）` : ""}: `)).trim();
+  const password = await ask(rl, "密码: ", { mute: true });
+  const res = await fetch(`http://127.0.0.1:${port}/api/auth/login`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ username, password }),
+    signal: AbortSignal.timeout(15000),
+  });
+  const payload = await res.json().catch(() => null);
+  if (!payload || payload.code !== 200) {
+    throw new Error((payload && payload.message) || `HTTP ${res.status}`);
+  }
+  saveToken(payload.data.token);
+  log(`已登录: ${payload.data.username || username}`);
+  return payload.data.token;
+}
+
+async function loginCommand() {
+  const { port, child } = await ensureServer();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdin.isTTY === true,
+  });
+  try {
+    await loginAt(port, rl);
+  } catch (err) {
+    warn(`登录失败: ${err.message}`);
+  } finally {
+    try {
+      rl.close();
+    } catch {
+      /* ignore */
+    }
+    if (child) {
+      try {
+        child.kill();
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+}
+
+function logoutCommand() {
+  clearToken();
+  log("已清除本地 CLI 令牌。");
+}
+
+async function chat() {
+  const { port, child: serverChild } = await ensureServer();
+
+  const die = (msg) => {
+    if (serverChild) {
+      try {
+        serverChild.kill();
+      } catch {
+        /* ignore */
+      }
+    }
+    fail(msg);
+  };
+
+  const state = {
+    sessionId: "",
+    busy: false,
+    approval: null,
+    inText: false,
+    inReasoning: false,
+    streamReq: null,
+    lastEventId: 0,
+    closing: false,
+  };
+
+  let rl = null;
+
+  function prompt() {
+    if (state.closing) return;
+    rl.setPrompt(`${C.cyan}>${C.reset} `);
+    rl.prompt();
+  }
+
+  function endLine() {
+    if (state.inText || state.inReasoning) {
+      process.stdout.write(`${C.reset}\n`);
+      state.inText = false;
+      state.inReasoning = false;
+    }
+  }
+
+  function shutdown(code = 0) {
+    state.closing = true;
+    closeStream();
+    try {
+      rl.close();
+    } catch {
+      /* ignore */
+    }
+    if (serverChild) {
+      try {
+        serverChild.kill();
+      } catch {
+        /* ignore */
+      }
+    }
+    process.exit(code);
+  }
+
+  function closeStream() {
+    if (state.streamReq) {
+      try {
+        state.streamReq.destroy();
+      } catch {
+        /* ignore */
+      }
+      state.streamReq = null;
+    }
+  }
+
+  function openStream() {
+    if (state.streamReq || state.closing) return;
+    const qs = `after_id=${state.lastEventId}${TOKEN ? `&token=${encodeURIComponent(TOKEN)}` : ""}`;
+    const headers = { Accept: "text/event-stream" };
+    if (TOKEN) headers["x-haoyuan-token"] = TOKEN;
+    const req = http.get(
+      {
+        host: "127.0.0.1",
+        port,
+        path: `/api/sessions/${encodeURIComponent(state.sessionId)}/stream?${qs}`,
+        headers,
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          state.streamReq = null;
+          if (state.busy) setTimeout(openStream, 500);
+          return;
+        }
+        let buf = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          buf += chunk;
+          let idx;
+          while ((idx = buf.indexOf("\n\n")) >= 0) {
+            const block = buf.slice(0, idx);
+            buf = buf.slice(idx + 2);
+            const data = block
+              .split("\n")
+              .filter((line) => line.startsWith("data:"))
+              .map((line) => line.slice(5).trim())
+              .join("");
+            if (!data) continue;
+            let event;
+            try {
+              event = JSON.parse(data);
+            } catch {
+              continue;
+            }
+            handleEvent(event);
+          }
+        });
+        res.on("end", () => {
+          state.streamReq = null;
+          if (state.busy && !state.closing) setTimeout(openStream, 600);
+        });
+        res.on("error", () => {
+          state.streamReq = null;
+        });
+      }
+    );
+    req.on("error", () => {
+      state.streamReq = null;
+      if (state.busy && !state.closing) setTimeout(openStream, 800);
+    });
+    state.streamReq = req;
+  }
+
+  function handleEvent(event) {
+    if (event && event.id !== undefined) {
+      const id = Number(event.id);
+      if (Number.isFinite(id) && id > state.lastEventId) state.lastEventId = id;
+    }
+    const type = event.type || event.event;
+    const payload = event.payload || {};
+
+    if (type === "stream.end") {
+      state.streamReq = null;
+      if (state.busy) {
+        state.busy = false;
+        endLine();
+        prompt();
+      }
+      return;
+    }
+
+    if (type === "delta") {
+      if (state.inReasoning) {
+        process.stdout.write(`${C.reset}\n`);
+        state.inReasoning = false;
+      }
+      if (!state.inText) {
+        process.stdout.write(`${C.bold}[助手]${C.reset} `);
+        state.inText = true;
+      }
+      if (payload.text) process.stdout.write(payload.text);
+      return;
+    }
+
+    if (type === "reasoning") {
+      if (payload.text) {
+        if (!state.inReasoning) {
+          process.stdout.write(`${C.dim}[思考] `);
+          state.inReasoning = true;
+        }
+        process.stdout.write(payload.text);
+      }
+      return;
+    }
+
+    if (type === "tool.start") {
+      endLine();
+      process.stdout.write(`${C.cyan}[工具]${C.reset} ${payload.tool} ${C.dim}${shortJson(payload.args)}${C.reset}\n`);
+      return;
+    }
+
+    if (type === "tool.end") {
+      const mark = payload.ok ? `${C.green}[完成]${C.reset}` : `${C.red}[失败]${C.reset}`;
+      const ms = payload.ms != null ? ` ${C.dim}${payload.ms}ms${C.reset}` : "";
+      const detail = payload.ok ? payload.summary || "" : payload.error || "";
+      process.stdout.write(`${mark} ${payload.tool}${ms}${detail ? ` ${C.dim}${shortJson(detail, 160)}${C.reset}` : ""}\n`);
+      return;
+    }
+
+    if (type === "approval.required") {
+      endLine();
+      state.approval = payload;
+      process.stdout.write(
+        `${C.yellow}[审批]${C.reset} ${payload.tool} 需要确认 ${C.dim}${shortJson(payload.args, 200)}${C.reset}\n`
+      );
+      if (payload.preview) {
+        process.stdout.write(`${C.dim}${shortJson(payload.preview, 400)}${C.reset}\n`);
+      }
+      rl.setPrompt(`${C.yellow}批准执行? (y/N)${C.reset} `);
+      rl.prompt();
+      return;
+    }
+
+    if (type === "approval.resolved") {
+      state.approval = null;
+      return;
+    }
+
+    if (type === "error") {
+      endLine();
+      process.stdout.write(`${C.red}[错误] ${payload.message || "未知错误"}${C.reset}\n`);
+      return;
+    }
+
+    if (type === "done") {
+      if (!state.inText && payload.text) {
+        process.stdout.write(`${C.bold}[助手]${C.reset} ${payload.text}\n`);
+      }
+      endLine();
+      if (state.busy) {
+        state.busy = false;
+        prompt();
+      }
+      return;
+    }
+
+    if (type === "session.status") {
+      if (payload.status === "error" && payload.error) {
+        endLine();
+        process.stdout.write(`${C.red}[错误] ${payload.error}${C.reset}\n`);
+      }
+    }
+  }
+
+  async function resolveApproval(approved) {
+    const approval = state.approval;
+    state.approval = null;
+    rl.setPrompt(`${C.cyan}>${C.reset} `);
+    if (!approval) return;
+    try {
+      await apiJson(port, "POST", `/api/approvals/${encodeURIComponent(approval.approval_id)}/resolve`, {
+        approved,
+        reason: approved ? "approved from CLI" : "rejected from CLI",
+      });
+      process.stdout.write(`${approved ? C.green : C.red}[${approved ? "已批准" : "已拒绝"}]${C.reset}\n`);
+    } catch (err) {
+      warn(`审批提交失败: ${err.message}`);
+    }
+  }
+
+  async function newSession() {
+    const data = await apiJson(port, "POST", "/api/sessions", {
+      kind: "auto",
+      workspace: process.cwd(),
+    });
+    state.sessionId = data.id;
+    state.lastEventId = 0;
+    openStream();
+    return data;
+  }
+
+  async function sendMessage(text) {
+    state.busy = true;
+    try {
+      await apiJson(port, "POST", `/api/sessions/${encodeURIComponent(state.sessionId)}/messages`, {
+        content: text,
+        locale: "",
+      });
+      if (!state.streamReq) openStream();
+    } catch (err) {
+      state.busy = false;
+      warn(`发送失败: ${err.message}`);
+      prompt();
+    }
+  }
+
+  async function cancelRun() {
+    try {
+      await apiJson(port, "POST", `/api/sessions/${encodeURIComponent(state.sessionId)}/cancel`, {});
+      process.stdout.write(`${C.yellow}[已取消当前任务]${C.reset}\n`);
+    } catch (err) {
+      warn(`取消失败: ${err.message}`);
+    }
+  }
+
+  function chatHelp() {
     process.stdout.write(
       [
-        "用法: haoyuan [command] [options]",
-        "",
-        "命令:",
-        "  start        安装（如需）+ 启动服务 + 自动打开网页（默认）",
-        "  setup        安装后端/前端依赖并构建前端",
-        "  build        仅构建前端",
-        "  help         显示帮助",
-        "",
-        "选项:",
-        "  --no-open    启动后不自动打开浏览器",
-        "  --no-build   setup 时跳过前端构建（已有 dist 时自动跳过）",
+        `${C.bold}终端命令${C.reset}`,
+        "  /new      新建会话",
+        "  /web      在浏览器打开当前会话",
+        "  /cancel   取消当前任务",
+        "  /exit     退出（也可 Ctrl+C）",
         "",
       ].join("\n")
     );
-    break;
-  default:
-    fail(`未知命令: ${command}（运行 haoyuan help 查看用法）`);
+  }
+
+  async function handleLine(line) {
+    const text = line.trim();
+    if (!text) {
+      prompt();
+      return;
+    }
+
+    if (state.approval) {
+      if (/^y(es)?$/i.test(text)) await resolveApproval(true);
+      else await resolveApproval(false);
+      prompt();
+      return;
+    }
+
+    if (text.startsWith("/")) {
+      const cmd = text.split(/\s+/, 1)[0].toLowerCase();
+      if (cmd === "/exit" || cmd === "/quit") return shutdown(0);
+      if (cmd === "/help") {
+        chatHelp();
+        return prompt();
+      }
+      if (cmd === "/new") {
+        try {
+          const session = await newSession();
+          log(`新会话: ${session.id}${session.title ? ` · ${session.title}` : ""}`);
+        } catch (err) {
+          warn(`新建会话失败: ${err.message}`);
+        }
+        return prompt();
+      }
+      if (cmd === "/web") {
+        openBrowser(`http://127.0.0.1:${port}/#/s/${state.sessionId}`);
+        return prompt();
+      }
+      if (cmd === "/cancel") {
+        await cancelRun();
+        return prompt();
+      }
+      warn(`未知命令: ${cmd}（/help 查看帮助）`);
+      return prompt();
+    }
+
+    if (state.busy) {
+      await sendMessage(text);
+      return;
+    }
+
+    await sendMessage(text);
+  }
+
+  rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    historySize: 300,
+    terminal: process.stdin.isTTY === true,
+  });
+
+  let session;
+  try {
+    session = await newSession();
+  } catch (err) {
+    if (!/auth/i.test(err.message)) die(`创建会话失败: ${err.message}`);
+    if (!process.stdin.isTTY) die(`需要登录：请先运行 haoyuan login（${err.message}）`);
+    try {
+      await loginAt(port, rl);
+      session = await newSession();
+    } catch (loginErr) {
+      die(`登录失败: ${loginErr.message}`);
+    }
+  }
+
+  const health = await fetch(`http://127.0.0.1:${port}/api/health`).then((r) => r.json());
+  const model = health && health.data ? `${health.data.default_provider}/${health.data.default_model}` : "unknown";
+
+  process.stdout.write(
+    [
+      "",
+      `${C.bold}豪源 HaoYuan v${VERSION}${C.reset} · 终端对话`,
+      `${C.dim}模型 ${model} · 工作区 ${process.cwd()}${C.reset}`,
+      `${C.dim}会话 ${session.id} · 网页 /web · 帮助 /help · 退出 /exit 或 Ctrl+C${C.reset}`,
+      "",
+    ].join("\n")
+  );
+
+  rl.on("line", (line) => {
+    handleLine(line).catch((err) => {
+      warn(err.message);
+      prompt();
+    });
+  });
+
+  rl.on("close", () => shutdown(0));
+
+  const onSigint = async () => {
+    if (state.busy) {
+      await cancelRun();
+      return;
+    }
+    shutdown(0);
+  };
+  rl.on("SIGINT", onSigint);
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", () => shutdown(0));
+
+  prompt();
 }
+
+function printVersion() {
+  process.stdout.write(`${VERSION}\n`);
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      `豪源 HaoYuan v${VERSION}`,
+      "",
+      "用法: haoyuan [命令] [选项]",
+      "",
+      "命令:",
+      "  haoyuan          终端对话（默认）",
+      "  haoyuan web      启动服务并打开网页",
+      "  haoyuan version  显示版本号",
+      "  haoyuan login    登录（账号保护开启时）",
+      "  haoyuan logout   清除本地登录令牌",
+      "  haoyuan setup    安装后端/前端依赖",
+      "  haoyuan build    仅构建前端",
+      "  haoyuan help     显示帮助",
+      "",
+      "选项:",
+      "  -V, --version    显示版本号",
+      "  --no-open        web 启动后不打开浏览器",
+      "  --no-build       setup 时跳过前端构建",
+      "",
+      "环境变量:",
+      "  HAOYUAN_TOKEN    账号保护开启后的访问令牌",
+      "  HAOYUAN_PORT     后端基准端口（默认 8030）",
+      "",
+    ].join("\n")
+  );
+}
+
+const argv = process.argv.slice(2);
+const command = argv[0] || "";
+const flags = new Set(argv.slice(1));
+const noOpen = flags.has("--no-open");
+const noBuild = flags.has("--no-build");
+
+async function main() {
+  if (command === "--version" || command === "-V" || command === "-v" || command === "version") {
+    printVersion();
+    return;
+  }
+  if (command === "--help" || command === "-h" || command === "help") {
+    printHelp();
+    return;
+  }
+  if (command === "" || command === "chat") {
+    await chat();
+    return;
+  }
+  if (command === "web" || command === "start" || command === "serve") {
+    await web({ noOpen });
+    return;
+  }
+  if (command === "setup") {
+    setup({ build: !noBuild });
+    return;
+  }
+  if (command === "login") {
+    await loginCommand();
+    return;
+  }
+  if (command === "logout") {
+    logoutCommand();
+    return;
+  }
+  if (command === "build") {
+    buildFrontend();
+    return;
+  }
+  if (command === "postinstall") {
+    postinstall();
+    return;
+  }
+  fail(`未知命令: ${command}（运行 haoyuan help 查看用法）`);
+}
+
+main().catch((err) => fail(err.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haoyuan",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "豪源 · HaoYuan — 个人指挥 AI 实现多个 AI 员工异步并行工作的 AI 工作室",
   "bin": {
     "haoyuan": "bin/haoyuan.js"