alink-cli 0.6.2 → 0.7.0

package/bin/agentlink.js

@@ -1,488 +1,193 @@
 #!/usr/bin/env node
-// bin/agentlink.js — `npx alink-cli` 的薄入口。
-//
-// 它自己几乎不做事：把命令行参数补齐默认值后，直接 import 打好的 daemon
-// bundle（dist/daemon.js），由 daemon 完成探测 agent、连 hub、跑任务这套完整
-// 流程。daemon 在被 import 时会读 `process.argv` / `AGENTLINK_TOKEN`，所以这里
-// 必须在 import 之前把 argv 和 env 准备好。
-//
-// 相对 daemon 收敛的默认值（让工作机上一条命令即接入官方 hub）：
-//   --hub   缺省 wss://link.harmopath.com（daemon 裸跑缺省是 localhost，只适合开发）
-//   --dir   缺省 process.cwd()（daemon 本就如此，无需干预）
-//   --token 缺省依次取 AGENTLINK_TOKEN 环境变量 → ~/.agentlink/credential 落盘凭证
-//
-// 凭证落盘：首次带 `--token` 成功连上 hub 后，把整串 token 写到
-// ~/.agentlink/credential（0600）。之后裸跑 `npx alink-cli` 直接复用——命令行
-// 上的 token 只需出现一次。al1. 多租户凭证的第四段（E2EE 主密钥）也一并存进这
-// 个文件，从不上网；daemon 另会把它单独归档进 enckeys.json 供 E2EE 层使用。
-
 import { spawn } from "node:child_process";
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { hostname, homedir } from "node:os";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
 
 const OFFICIAL_HUB = process.env.AGENTLINK_DEFAULT_HUB || "wss://link.harmopath.com";
-
-// 凭证文件与 daemon 的状态目录同根（默认 ~/.agentlink，可用 AGENTLINK_STATE_DIR
-// 覆盖，测试用），文件名固定为 credential。
 const STATE_DIR = process.env.AGENTLINK_STATE_DIR || join(homedir(), ".agentlink");
 const CREDENTIAL_FILE = join(STATE_DIR, "credential");
+const args = process.argv.slice(2);
 
-const rawArgs = process.argv.slice(2);
-
-// --help / -h：打印简洁中文用法后退出，不启动 daemon。
-if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-  printHelp();
-  process.exit(0);
+function value(name) {
+  const index = args.findIndex((arg) => arg === `--${name}` || arg.startsWith(`--${name}=`));
+  if (index < 0) return undefined;
+  return args[index].includes("=") ? args[index].slice(name.length + 3) : args[index + 1];
 }
 
-// 判断某个具名参数是否已由用户给出（同时认 `--name value` 与 `--name=value`）。
-function hasFlag(name, args = rawArgs) {
-  return args.some((a) => a === `--${name}` || a.startsWith(`--${name}=`));
-}
-
-// 读取具名参数的值（用于取出用户显式给的 --token 整串）。
-function flagValue(name, args = rawArgs) {
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === `--${name}`) return args[i + 1];
-    if (a.startsWith(`--${name}=`)) return a.slice(name.length + 3);
-  }
-  return undefined;
+function normalizeHub(hub) {
+  const url = new URL(hub);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  if (url.protocol === "https:") url.protocol = "wss:";
+  url.hash = "";
+  url.search = "";
+  url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+  return url.toString();
 }
 
-function readCredentialFile() {
+function savedCredential(hub = OFFICIAL_HUB) {
   try {
-    const t = readFileSync(CREDENTIAL_FILE, "utf-8").trim();
-    return t || undefined;
+    const raw = readFileSync(CREDENTIAL_FILE, "utf8").trim();
+    if (!raw) return undefined;
+    if (!raw.startsWith("{")) {
+      return normalizeHub(hub) === normalizeHub(OFFICIAL_HUB) ? raw : undefined;
+    }
+    const saved = JSON.parse(raw);
+    return saved.hub === normalizeHub(hub) && typeof saved.credential === "string"
+      ? saved.credential
+      : undefined;
   } catch {
-    return undefined; // 文件不存在或不可读——当作没有凭证
+    return undefined;
   }
 }
 
-function persistCredential(token) {
+function saveCredential(credential, hub = OFFICIAL_HUB) {
   mkdirSync(STATE_DIR, { recursive: true });
-  // 先写再 chmod，确保即便文件是新建也是 0600（mode 选项只在创建时生效）。
-  writeFileSync(CREDENTIAL_FILE, token, { mode: 0o600 });
+  writeFileSync(CREDENTIAL_FILE, JSON.stringify({ hub: normalizeHub(hub), credential }), {
+    mode: 0o600,
+  });
   chmodSync(CREDENTIAL_FILE, 0o600);
 }
 
-if (rawArgs[0] === "credential" || rawArgs[0] === "cred") {
-  ctlCredential(rawArgs.slice(1));
-  process.exit(0);
-}
-
-function ctlCredential(args) {
-  const cmd = args[0] || "status";
-  if (cmd === "path") {
-    console.log(CREDENTIAL_FILE);
-    return;
-  }
-  if (cmd === "status") {
-    console.log(`[agentlink] 凭证文件: ${CREDENTIAL_FILE}`);
-    console.log(readCredentialFile() ? "[agentlink] 已保存凭证。用 credential show 查看，credential set 修改。" : "[agentlink] 未保存凭证。用 credential set <凭证> 写入。");
-    return;
-  }
-  if (cmd === "show") {
-    const token = readCredentialFile();
-    if (!token) {
-      console.error("[agentlink] 还没有保存凭证。");
-      process.exit(1);
-    }
-    console.log(token);
-    return;
-  }
-  if (cmd === "set") {
-    const raw = args[1] === "-" ? readFileSync(0, "utf-8") : args[1];
-    const token = raw?.trim();
-    if (!token || /\s/.test(token)) {
-      console.error("[agentlink] 用法: alink-cli credential set <al1.…>  或  alink-cli credential set - < token.txt");
-      process.exit(1);
-    }
-    persistCredential(token);
-    console.log(`[agentlink] 凭证已保存到 ${CREDENTIAL_FILE}（0600）。`);
-    return;
-  }
-  if (cmd === "clear") {
-    rmSync(CREDENTIAL_FILE, { force: true });
-    console.log(`[agentlink] 已删除 ${CREDENTIAL_FILE}。`);
-    return;
-  }
-  console.error("[agentlink] 用法: alink-cli credential [status|path|show|set|clear]");
-  process.exit(1);
+function parseCredential(credential) {
+  const parts = credential.split(".");
+  if (parts.length === 3 && parts[0] === "als1" && parts.slice(1).every(Boolean)) {
+    if (!/^[A-Za-z0-9_-]{43}$/.test(parts[2])) throw new Error("机器凭证中的加密密钥无效。");
+    return { machineToken: parts[1], enckey: parts[2] };
+  }
+  if (parts.length !== 4 || parts[0] !== "al1" || !parts.slice(1).every(Boolean)) {
+    throw new Error("机器凭证必须是完整的 al1.<payload>.<sig>.<enckey>。");
+  }
+  if (!/^[A-Za-z0-9_-]{43}$/.test(parts[3])) throw new Error("机器凭证中的加密密钥无效。");
+  return { machineToken: parts.slice(0, 3).join("."), enckey: parts[3] };
+}
+
+async function hubMode(hub) {
+  const url = new URL("/api/config", hub);
+  if (url.protocol === "ws:") url.protocol = "http:";
+  if (url.protocol === "wss:") url.protocol = "https:";
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Hub 配置读取失败 (${response.status})。`);
+  return (await response.json()).mode;
+}
+
+async function createSingleCredential(hub) {
+  const token = randomBytes(24).toString("base64url");
+  const enckey = randomBytes(32).toString("base64url");
+  const credential = `als1.${token}.${enckey}`;
+  saveCredential(credential, hub);
+  const url = new URL("/pair", hub);
+  if (url.protocol === "ws:") url.protocol = "http:";
+  if (url.protocol === "wss:") url.protocol = "https:";
+  url.searchParams.set("token", token);
+  url.hash = new URLSearchParams({ enckey }).toString();
+  console.log("\n在 AgentLink 网页扫码，或打开下面的链接：\n");
+  await printQr(credential);
+  console.log(`\n${url}\n`);
+  return credential;
+}
+
+async function printQr(text) {
+  const { renderQr } = await import(new URL("../dist/qr.js", import.meta.url));
+  renderQr(text);
+}
+
+async function pair(hub) {
+  const enckey = randomBytes(32).toString("base64url");
+  const code = randomBytes(16).toString("base64url");
+  const pairing = `alp1.${code}.${enckey}`;
+  const url = new URL(hub);
+  if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol === "http:") url.protocol = "ws:";
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/daemon`;
+  url.searchParams.set("pair", code);
+  url.searchParams.set("host", hostname());
+  url.searchParams.set("v", "1");
+
+  return new Promise((resolve, reject) => {
+    const socket = new WebSocket(url);
+    const timer = setTimeout(() => {
+      socket.close();
+      reject(new Error("配对超时，请检查 Hub 是否在线后重试。"));
+    }, 10 * 60_000);
+    socket.on("message", async (raw) => {
+      let message;
+      try {
+        message = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (message.type === "pair_pending") {
+        console.log("\n用 AgentLink 网页或手机扫描二维码：\n");
+        await printQr(pairing);
+        console.log(`\n无法扫码时粘贴：\n${pairing}\n`);
+      }
+      if (message.type === "claimed" && typeof message.token === "string") {
+        clearTimeout(timer);
+        socket.close();
+        const credential = `${message.token}.${enckey}`;
+        saveCredential(credential, hub);
+        console.log(`[agentlink] 配对成功，凭证已保存到 ${CREDENTIAL_FILE}（0600）。`);
+        resolve(credential);
+      }
+    });
+    socket.on("error", reject);
+  });
 }
 
-// `qr` 子命令：在终端打印本机凭证的二维码（含 E2EE 密钥段）+ 指纹——给新手机
-// 的「录入密钥」扫。凭证从 --token / AGENTLINK_TOKEN / 落盘文件取，不联网。
-if (rawArgs[0] === "qr") {
-  const token = flagValue("token") || process.env.AGENTLINK_TOKEN || readCredentialFile();
-  if (!token) {
-    console.error("这台电脑上还没有凭证。先在手机 AgentLink 的「添加机器」里生成命令并运行一次。");
-    process.exit(1);
-  }
-  const parts = token.split(".");
-  if (parts.length < 4) {
-    console.log("此凭证不含加密密钥（明文接入），其他设备无需录入密钥，直接使用即可。");
-    process.exit(0);
-  }
-  const { renderQr } = await import(join(dirname(fileURLToPath(import.meta.url)), "../dist/qr.js"));
-  const { createHash } = await import("node:crypto");
-  const enckey = parts[3];
-  const fp = createHash("sha256").update(Buffer.from(enckey, "base64url")).digest("hex").slice(0, 8);
-  console.log("用手机 AgentLink 的「录入密钥」扫下面的二维码：\n");
-  renderQr(token);
-  console.log("\n凭证信息（无法扫码时可手动粘贴）：\n");
-  console.log(token);
-  console.log("");
-  console.log(`密钥指纹 ${fp} —— 与手机上显示的一致即可放心保存。`);
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(
+    `用法: npx alink-cli [--hub <wss://…>] [--dir <目录>] [--pair]\n\n首次运行会显示配对二维码；之后直接复用 ~/.agentlink/credential。\n--legacy 运行旧 daemon；credential status|path|show|set|clear 管理凭证。`,
+  );
   process.exit(0);
 }
 
-// ---------------------------------------------------------------------
-// 后台管理子命令：start / stop / status / logs / restart。
-// `start` 把 daemon 挂到后台（detached，日志写 ~/.agentlink/daemon.log，进程
-// 元数据写 daemon.json），其余子命令围着这两个文件 + daemon 自己维护的
-// status.json 转。首次无凭证裸跑仍是前台——扫码配对必须能看见终端里的二维码；
-// 已有凭证的裸跑默认转后台。
-
-const DAEMON_JSON = join(STATE_DIR, "daemon.json");
-const DAEMON_LOG = join(STATE_DIR, "daemon.log");
-const STATUS_JSON = join(STATE_DIR, "status.json");
-
-if (["start", "stop", "status", "logs", "restart"].includes(rawArgs[0])) {
-  const [cmd, ...rest] = rawArgs;
-  if (cmd === "start") await ctlStart(rest);
-  else if (cmd === "stop") await ctlStop();
-  else if (cmd === "status") ctlStatus();
-  else if (cmd === "logs") await ctlLogs(rest);
-  else await ctlRestart(rest);
+if (args[0] === "credential") {
+  const hub = value("hub") || OFFICIAL_HUB;
+  const command = args[1] || "status";
+  if (command === "path") console.log(CREDENTIAL_FILE);
+  else if (command === "status") console.log(savedCredential(hub) ? "已保存凭证" : "未保存凭证");
+  else if (command === "show") console.log(savedCredential(hub) || "");
+  else if (command === "set" && args[2] && !/\s/.test(args[2])) saveCredential(args[2], hub);
+  else if (command === "clear") rmSync(CREDENTIAL_FILE, { force: true });
+  else throw new Error("用法: alink-cli credential status|path|show|set <credential>|clear");
   process.exit(0);
 }
 
-function readJsonFile(path) {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-function pidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// start 记录的后台进程（daemon.json）——pid 还活着才算数。
-function runningDaemon() {
-  const meta = readJsonFile(DAEMON_JSON);
-  return meta && typeof meta.pid === "number" && pidAlive(meta.pid) ? meta : null;
-}
-
-function fmtUptime(ms) {
-  const s = Math.max(0, Math.floor(ms / 1000));
-  const h = Math.floor(s / 3600);
-  const m = Math.floor((s % 3600) / 60);
-  return h > 0 ? `${h}h${m}m` : m > 0 ? `${m}m${s % 60}s` : `${s}s`;
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-async function ctlStart(args, { alreadyOk = false } = {}) {
-  if (hasFlag("tunnel", args)) {
-    console.error("[agentlink] --tunnel 模式带着 cloudflared 子进程，请前台运行（不支持 start）。");
-    process.exit(1);
-  }
-  if (hasFlag("pair", args)) {
-    console.error("[agentlink] 配对需要扫终端里的二维码，请先前台跑一次 `npx alink-cli` 完成绑定，再 start。");
-    process.exit(1);
-  }
-  const already = runningDaemon();
-  if (already) {
-    const msg = `[agentlink] 已在后台运行 (pid ${already.pid})。要重启用 alink-cli restart。`;
-    if (alreadyOk) {
-      console.log(msg);
-      console.log(`[agentlink] 日志: ${DAEMON_LOG}`);
-      return;
-    }
-    console.error(msg);
-    process.exit(1);
-  }
-  // 凭证前置检查：后台进程没法扫码配对（二维码只会写进日志文件），所以
-  // 无凭证 + 官方 hub 直接拒绝，指引先前台配对。
-  const hubArg = flagValue("hub", args);
-  const hasCredential = hasFlag("token", args) || process.env.AGENTLINK_TOKEN || readCredentialFile();
-  if (!hasCredential && (!hubArg || hubArg === OFFICIAL_HUB)) {
-    console.error("[agentlink] 这台电脑还没绑定。先前台跑一次 `npx alink-cli`，用手机扫码完成配对，再 start。");
-    process.exit(1);
-  }
-
-  // 每次 start 换新日志（旧日志随进程一起翻篇），元数据记下参数供 restart 复用。
-  mkdirSync(STATE_DIR, { recursive: true });
-  writeFileSync(DAEMON_LOG, "");
-  const logFd = openSync(DAEMON_LOG, "a");
-  const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...args], {
-    detached: true,
-    stdio: ["ignore", logFd, logFd],
-    env: { ...process.env, AGENTLINK_FOREGROUND: "1" },
-  });
-  child.unref();
-  writeFileSync(DAEMON_JSON, JSON.stringify({ pid: child.pid, args, startedAt: Date.now() }));
-
-  // 等到 daemon 报告连上（status.json state=connected）再回话；起不来就把
-  // 日志尾巴打出来。连不上但还在重试（网络/hub 抖动）不算失败。
-  const deadline = Date.now() + 12_000;
-  for (;;) {
-    await sleep(250);
-    if (!pidAlive(child.pid)) {
-      console.error("[agentlink] 后台 daemon 启动即退出。日志尾部：");
-      printLogTail(30);
-      rmSync(DAEMON_JSON, { force: true });
-      process.exit(1);
-    }
-    const st = readJsonFile(STATUS_JSON);
-    if (st && st.pid === child.pid && st.state === "connected") {
-      console.log(`[agentlink] 已在后台启动并连上 hub (pid ${child.pid})。`);
-      console.log(`[agentlink] 日志: ${DAEMON_LOG}`);
-      console.log(`[agentlink] 常用命令: alink-cli status / logs -f / stop`);
-      return;
-    }
-    if (Date.now() > deadline) {
-      console.log(`[agentlink] 已在后台启动 (pid ${child.pid})，但还没连上 hub——会按退避自动重试。`);
-      console.log(`[agentlink] 用 alink-cli status 或 alink-cli logs -f 观察进展。`);
-      return;
-    }
-  }
-}
-
-async function ctlStop() {
-  const meta = runningDaemon();
-  if (!meta) {
-    rmSync(DAEMON_JSON, { force: true }); // 清掉可能残留的陈旧记录
-    console.log("[agentlink] 没有在后台运行的 daemon。");
-    return;
-  }
-  process.kill(meta.pid, "SIGTERM");
-  for (let i = 0; i < 20 && pidAlive(meta.pid); i++) await sleep(250);
-  if (pidAlive(meta.pid)) {
-    console.error(`[agentlink] pid ${meta.pid} 不理会 SIGTERM，改发 SIGKILL。`);
-    process.kill(meta.pid, "SIGKILL");
-    for (let i = 0; i < 8 && pidAlive(meta.pid); i++) await sleep(250);
-  }
-  rmSync(DAEMON_JSON, { force: true });
-  console.log(`[agentlink] 已停止 (pid ${meta.pid})。`);
-}
-
-function ctlStatus() {
-  const meta = runningDaemon();
-  const st = readJsonFile(STATUS_JSON);
-  // 不是 start 管的，但 status.json 里的 pid 还活着 → 前台/别处跑着的 daemon。
-  if (!meta && st && typeof st.pid === "number" && pidAlive(st.pid)) {
-    console.log(`● 运行中 (pid ${st.pid}，非后台托管——大概率是前台在跑)`);
-    printStatusDetail(st);
-    return;
-  }
-  if (!meta) {
-    console.log("● 未运行");
-    if (st && st.state === "stopped") console.log(`  上次退出码 ${st.code ?? "?"}`);
-    if (existsSync(DAEMON_LOG)) console.log(`  日志: ${DAEMON_LOG}`);
-    process.exit(1);
-  }
-  const stateLabel =
-    st && st.pid === meta.pid
-      ? { starting: "启动中", pairing: "配对中", connected: "已连接", reconnecting: `重连中（第 ${st.attempt ?? "?"} 次）`, stopped: "已停止" }[st.state] ?? st.state
-      : "未知";
-  console.log(`● 运行中 (pid ${meta.pid}, 已运行 ${fmtUptime(Date.now() - meta.startedAt)})`);
-  console.log(`  状态: ${stateLabel}`);
-  printStatusDetail(st && st.pid === meta.pid ? st : null);
-}
-
-function printStatusDetail(st) {
-  if (st) {
-    console.log(`  hub: ${st.hub}`);
-    if (st.machineId) console.log(`  machine: ${st.machineId}`);
-    if (st.daemonVersion) console.log(`  版本: ${st.daemonVersion}`);
-  }
-  console.log(`  日志: ${DAEMON_LOG}`);
-}
-
-function printLogTail(n) {
-  try {
-    const lines = readFileSync(DAEMON_LOG, "utf-8").trimEnd().split("\n");
-    for (const line of lines.slice(-n)) console.error(`  ${line}`);
-  } catch {
-    console.error("  （没有日志）");
-  }
-}
-
-async function ctlLogs(args) {
-  const follow = args.includes("-f") || args.includes("--follow");
-  const nIdx = args.indexOf("-n");
-  const n = nIdx >= 0 ? Number(args[nIdx + 1]) || 50 : 50;
-  if (!existsSync(DAEMON_LOG)) {
-    console.error(`[agentlink] 还没有日志（${DAEMON_LOG}）。先 alink-cli start。`);
-    process.exit(1);
-  }
-  const content = readFileSync(DAEMON_LOG, "utf-8");
-  const lines = content.split("\n");
-  if (lines[lines.length - 1] === "") lines.pop();
-  if (lines.length > 0) process.stdout.write(lines.slice(-n).join("\n") + "\n");
-  if (!follow) return;
-  // 跟随：轮询文件增量（够用且零依赖；Ctrl+C 退出）。
-  let offset = Buffer.byteLength(content);
-  for (;;) {
-    await sleep(500);
-    let size;
-    try {
-      size = statSync(DAEMON_LOG).size;
-    } catch {
-      continue; // 日志被轮换/删除，等它回来
-    }
-    if (size < offset) offset = 0; // start 截断了日志——从头跟
-    if (size > offset) {
-      const fd = openSync(DAEMON_LOG, "r");
-      const buf = Buffer.alloc(size - offset);
-      readSync(fd, buf, 0, buf.length, offset);
-      closeSync(fd);
-      process.stdout.write(buf.toString("utf-8"));
-      offset = size;
-    }
-  }
-}
-
-async function ctlRestart(args) {
-  const prev = readJsonFile(DAEMON_JSON);
-  const startArgs = args.length > 0 ? args : (prev?.args ?? []);
-  await ctlStop();
-  await ctlStart(startArgs);
-}
-
-if (rawArgs.length === 0 && !process.env.AGENTLINK_FOREGROUND && (process.env.AGENTLINK_TOKEN || readCredentialFile())) {
-  await ctlStart([], { alreadyOk: true });
+if (args[0] === "qr") {
+  const credential =
+    value("token") || process.env.AGENTLINK_TOKEN || savedCredential(value("hub") || OFFICIAL_HUB);
+  if (!credential) throw new Error("这台电脑还没有凭证，请先运行 npx alink-cli 完成配对。");
+  await printQr(credential);
   process.exit(0);
 }
 
-// `local` 子命令 = 同机驾驶舱：本地起 single 模式 hub + daemon，自动开浏览器，
-// 不遥控。归一成 daemon 认的 --local flag（daemon 参数不收 positional）。既接受
-// `npx alink-cli local`，也接受 `npx alink-cli --local`。
-if (rawArgs[0] === "local") rawArgs[0] = "--local";
-
-// --tunnel / --local 模式下 daemon 会自起本地 hub，且与 --hub 互斥，此时绝不注入 --hub。
-const tunnelMode = hasFlag("tunnel");
-const localMode = hasFlag("local");
-
-// 1) 补 --hub 默认值：官方 hub。本地模式（tunnel/local）自带 localhost hub，跳过。
-if (!hasFlag("hub") && !tunnelMode && !localMode) {
-  rawArgs.push("--hub", OFFICIAL_HUB);
-}
-
-// 2) 解析 token 来源，并决定是否需要“成功连接后落盘”。
-//    优先级：显式 --pair（重新配对）> 命令行 --token > AGENTLINK_TOKEN 环境变量
-//    > 凭证文件 > （官方 hub）扫码配对。
-let tokenToPersist; // 仅当用户这次显式给了新 --token 时，连上后写盘
-const explicitToken = hasFlag("token") ? flagValue("token") : undefined;
-if (hasFlag("pair")) {
-  // 显式 --pair：忽略已存凭证，重新走扫码配对（换账号/重绑）。凭证由 daemon
-  // 配对成功后自行落盘；--pair 与 --token 的互斥由 daemon 的参数校验把关。
-} else if (explicitToken) {
-  // 用户显式给了 token——daemon 会直接用 argv 里的 --token。若它和已存凭证不同，
-  // 安排在成功连上 hub 后落盘（避免把连不上的坏 token 也存下来）。
-  if (explicitToken !== readCredentialFile()) tokenToPersist = explicitToken;
-} else if (process.env.AGENTLINK_TOKEN) {
-  // 环境变量已给——daemon 自己会读 AGENTLINK_TOKEN，这里什么都不用做。
-} else if (localMode) {
-  // --local：single 模式本地 hub，daemon 自己现生成一个 UUID token 并打印/开浏览器。
-  // 不复用落盘凭证（那多半是官方 al1. 多租户串，喂给本地 single hub 是错的），也不配对。
+if (args.includes("--legacy")) {
+  process.argv = process.argv.filter((arg) => arg !== "--legacy");
+  await import(new URL("../dist/daemon.js", import.meta.url));
 } else {
-  // 命令行和环境变量都没有——回落到落盘凭证（若有），塞进 AGENTLINK_TOKEN 供
-  // daemon 读取。
-  const saved = readCredentialFile();
-  if (saved) {
-    process.env.AGENTLINK_TOKEN = saved;
-  } else if (!tunnelMode && (!hasFlag("hub") || flagValue("hub") === OFFICIAL_HUB)) {
-    // 什么凭证都没有且连的是官方 hub：进入扫码配对模式——daemon 本地生成
-    // E2EE 密钥 + 配对码，终端打二维码，手机 AgentLink「添加机器」扫码即绑定。
-    // 密钥只走二维码这条光学通道，不经过网络与服务器。
-    // （--tunnel 与自建 --hub 的 single 模式仍保留旧行为：daemon 自己生成
-    // token 并打印链接。自建 multi hub 可显式 `--pair --hub wss://…` 配对。）
-    rawArgs.push("--pair");
-  }
-}
-
-// 3) 把补好默认值的 argv 交还给 daemon（daemon 读 process.argv.slice(2)）。
-process.argv = [process.argv[0], process.argv[1], ...rawArgs];
-
-// 4) 若需要落盘：daemon 用 console.log 打印进度，成功连上时会输出
-//    "[daemon] registered. …"。在 import daemon 前挂一个一次性的 stdout 嗅探器，
-//    看到该标记即把 token 写盘，然后还原 stdout。这样只有真正连上的凭证才落盘。
-if (tokenToPersist) {
-  const original = process.stdout.write.bind(process.stdout);
-  let filed = false;
-  process.stdout.write = (chunk, ...rest) => {
-    if (!filed && typeof chunk === "string" && chunk.includes("[daemon] registered.")) {
-      filed = true;
-      try {
-        persistCredential(tokenToPersist);
-        original(`[agentlink] 凭证已保存到 ${CREDENTIAL_FILE}（0600）——之后可直接裸跑 \`npx alink-cli\`\n`);
-      } catch {
-        original(`[agentlink] 警告：凭证写入 ${CREDENTIAL_FILE} 失败——下次仍需 --token\n`);
-      }
-      process.stdout.write = original; // 还原，之后正常输出
-    }
-    return original(chunk, ...rest);
-  };
-}
-
-// 5) 启动 daemon。import 求值时它就会解析 argv 并开始连 hub。
-const daemon = new URL("../dist/daemon.js", import.meta.url);
-await import(daemon.href);
-
-function printHelp() {
-  const self = "alink-cli";
-  process.stdout.write(
-    [
-      `用法: npx ${self} [--hub <wss://…>] [--dir <目录>]…`,
-      `      npx ${self} local [--dir …]    # 同机驾驶舱：本地起 hub 并自动开浏览器，不遥控`,
-      `      npx ${self} qr                 # 终端打印本机凭证二维码（给新手机录密钥）`,
-      `      npx ${self} credential set <凭证> # 手动写入 / 修改本机保存的凭证`,
-      `      npx ${self} start [--dir …]    # 后台运行（先前台配对过一次）`,
-      `      npx ${self} status|logs [-f]|stop|restart`,
-      ``,
-      `把当前这台工作机接入 AgentLink，随时随地遥控本机的编码 agent。`,
-      `首次裸跑会进入扫码配对：加密密钥在这台电脑上生成，终端打出二维码，`,
-      `用手机 AgentLink 的「添加机器」扫一下即绑定——密钥只走二维码，不经过服务器。`,
-      `绑定后裸跑会默认挂到后台（日志 ~/.agentlink/daemon.log），status 看连接`,
-      `状态，logs -f 跟日志，stop/restart 停止或重启。`,
-      ``,
-      `参数:`,
-      `  --pair           强制重新扫码配对（换账号 / 重绑这台机器）。`,
-      `  --token <token>  直接给机器凭证（al1.… 整串，如从别处迁移）。首次成功连上后`,
-      `                   存到 ~/.agentlink/credential（0600），之后裸跑自动复用。`,
-      `                   也可用环境变量 AGENTLINK_TOKEN 提供（--token 优先）。`,
-      `  credential       管理本机保存的凭证：status/path/show/set/clear。show 会明文打印`,
-      `                   凭证；set 直接覆盖 ~/.agentlink/credential。`,
-      `  --hub <url>      hub 地址，缺省官方 hub ${OFFICIAL_HUB}。`,
-      `  --dir <path>     工作目录根，可重复；缺省当前目录。运行时可用其下任意子目录。`,
-      `  --tunnel         不连任何 hub：本地起 hub + 免费 Cloudflare 隧道并打印公网链接`,
-      `                   （需已安装 cloudflared）。与 --hub 互斥。`,
-      `  local            同机场景：本地起 single 模式 hub + daemon，自动用浏览器打开`,
-      `                   控制台（localhost），把这台电脑上的多个 agent 统一管起来。`,
-      `                   不遥控、不联网、无需扫码。--port 可改本地 hub 端口（默认 8080）。`,
-      `  --help, -h       显示本帮助。`,
-      ``,
-      `示例:`,
-      `  npx ${self}                        # 首次：终端出二维码，手机扫码绑定；`,
-      `                                     # 之后裸跑复用已存凭证，直接上线`,
-      ``,
-      `连接是出站的（走 NAT/防火墙无需端口转发），断线自动重连。加密密钥只留在`,
-      `本机和扫码的手机上、从不上网（端到端加密）。`,
-      ``,
-    ].join("\n"),
-  );
+  const hub = value("hub") || OFFICIAL_HUB;
+  const explicit = value("token") || process.env.AGENTLINK_TOKEN;
+  const credential =
+    explicit ||
+    (!args.includes("--pair") && savedCredential(hub)) ||
+    ((await hubMode(hub)) === "multi" ? await pair(hub) : await createSingleCredential(hub));
+  if (explicit && explicit !== savedCredential(hub)) saveCredential(explicit, hub);
+  const { machineToken, enckey } = parseCredential(credential);
+  const daemon = fileURLToPath(new URL("../dist/bin.mjs", import.meta.url));
+  const cwd = value("dir") || process.cwd();
+  const child = spawn(process.execPath, [daemon, "serve", cwd], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      T3CODE_HUB_URL: hub,
+      T3CODE_HUB_MACHINE_TOKEN: machineToken,
+      T3CODE_HUB_ENCKEY: enckey,
+    },
+  });
+  for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => child.kill(signal));
+  process.exitCode = await new Promise((resolve) => child.on("exit", (code) => resolve(code ?? 1)));
 }