alink-cli 0.4.2 → 0.6.0

package/bin/agentlink.js

@@ -16,7 +16,8 @@
 // 上的 token 只需出现一次。al1. 多租户凭证的第四段（E2EE 主密钥）也一并存进这
 // 个文件，从不上网；daemon 另会把它单独归档进 enckeys.json 供 E2EE 层使用。
 
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+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 { fileURLToPath } from "node:url";
@@ -37,15 +38,15 @@ if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
 }
 
 // 判断某个具名参数是否已由用户给出（同时认 `--name value` 与 `--name=value`）。
-function hasFlag(name) {
-  return rawArgs.some((a) => a === `--${name}` || a.startsWith(`--${name}=`));
+function hasFlag(name, args = rawArgs) {
+  return args.some((a) => a === `--${name}` || a.startsWith(`--${name}=`));
 }
 
 // 读取具名参数的值（用于取出用户显式给的 --token 整串）。
-function flagValue(name) {
-  for (let i = 0; i < rawArgs.length; i++) {
-    const a = rawArgs[i];
-    if (a === `--${name}`) return rawArgs[i + 1];
+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;
@@ -90,24 +91,254 @@ if (rawArgs[0] === "qr") {
   process.exit(0);
 }
 
-// --tunnel 模式下 daemon 会自起本地 hub，且与 --hub 互斥，所以此时绝不注入 --hub。
+// ---------------------------------------------------------------------
+// 后台管理子命令：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);
+  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) {
+  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) {
+    console.error(`[agentlink] 已在后台运行 (pid ${already.pid})。要重启用 alink-cli restart。`);
+    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,
+  });
+  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);
+}
+
+// `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。
-if (!hasFlag("hub") && !tunnelMode) {
+// 1) 补 --hub 默认值：官方 hub。本地模式（tunnel/local）自带 localhost hub，跳过。
+if (!hasFlag("hub") && !tunnelMode && !localMode) {
   rawArgs.push("--hub", OFFICIAL_HUB);
 }
 
 // 2) 解析 token 来源，并决定是否需要“成功连接后落盘”。
-//    优先级：命令行 --token > AGENTLINK_TOKEN 环境变量 > 凭证文件。
+//    优先级：显式 --pair（重新配对）> 命令行 --token > AGENTLINK_TOKEN 环境变量
+//    > 凭证文件 > （官方 hub）扫码配对。
 let tokenToPersist; // 仅当用户这次显式给了新 --token 时，连上后写盘
 const explicitToken = hasFlag("token") ? flagValue("token") : undefined;
-if (explicitToken) {
+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 是错的），也不配对。
 } else {
   // 命令行和环境变量都没有——回落到落盘凭证（若有），塞进 AGENTLINK_TOKEN 供
   // daemon 读取。
@@ -115,14 +346,12 @@ if (explicitToken) {
   if (saved) {
     process.env.AGENTLINK_TOKEN = saved;
   } else if (!tunnelMode && (!hasFlag("hub") || flagValue("hub") === OFFICIAL_HUB)) {
-    // --tunnel 与自建 --hub 不需要预铸凭证：daemon 自己生成 token 并打印链接。
-    // 什么凭证都没有且连的是官方 hub：直接给指引并退出——否则 daemon 会生成
-    // 随机 token 去连 multi hub 然后被 4401 拒，报错对新用户完全不可解。
-    // （自建 --hub 的 single 模式仍保留旧行为：daemon 自己生成 token 并打印。）
-    console.error("还没有这台电脑的凭证。");
-    console.error("请在手机 AgentLink App（或电脑控制台）的「添加机器」里生成命令，");
-    console.error("复制到这里运行：npx alink-cli --token al1.…");
-    process.exit(1);
+    // 什么凭证都没有且连的是官方 hub：进入扫码配对模式——daemon 本地生成
+    // E2EE 密钥 + 配对码，终端打二维码，手机 AgentLink「添加机器」扫码即绑定。
+    // 密钥只走二维码这条光学通道，不经过网络与服务器。
+    // （--tunnel 与自建 --hub 的 single 模式仍保留旧行为：daemon 自己生成
+    // token 并打印链接。自建 multi hub 可显式 `--pair --hub wss://…` 配对。）
+    rawArgs.push("--pair");
   }
 }
 
@@ -158,28 +387,38 @@ function printHelp() {
   const self = "alink-cli";
   process.stdout.write(
     [
-      `用法: npx ${self} [--token <al1.…>] [--hub <wss://…>] [--dir <目录>]…`,
+      `用法: npx ${self} [--hub <wss://…>] [--dir <目录>]…`,
+      `      npx ${self} local [--dir …]    # 同机驾驶舱：本地起 hub 并自动开浏览器，不遥控`,
       `      npx ${self} qr                 # 终端打印本机凭证二维码（给新手机录密钥）`,
+      `      npx ${self} start [--dir …]    # 后台运行（先前台配对过一次）`,
+      `      npx ${self} status|logs [-f]|stop|restart`,
       ``,
       `把当前这台工作机接入 AgentLink，随时随地遥控本机的编码 agent。`,
+      `首次裸跑会进入扫码配对：加密密钥在这台电脑上生成，终端打出二维码，`,
+      `用手机 AgentLink 的「添加机器」扫一下即绑定——密钥只走二维码，不经过服务器。`,
+      `绑定后可用 start 挂到后台（日志 ~/.agentlink/daemon.log），status 看连接`,
+      `状态，logs -f 跟日志，stop/restart 停止或重启。`,
       ``,
       `参数:`,
-      `  --token <token>  机器凭证（控制台里“添加机器”生成的 al1.… 整串）。`,
-      `                   首次成功连上后会存到 ~/.agentlink/credential（0600），`,
-      `                   之后裸跑 npx ${self} 自动复用。也可用环境变量`,
-      `                   AGENTLINK_TOKEN 提供（--token 优先）。`,
+      `  --pair           强制重新扫码配对（换账号 / 重绑这台机器）。`,
+      `  --token <token>  直接给机器凭证（al1.… 整串，如从别处迁移）。首次成功连上后`,
+      `                   存到 ~/.agentlink/credential（0600），之后裸跑自动复用。`,
+      `                   也可用环境变量 AGENTLINK_TOKEN 提供（--token 优先）。`,
       `  --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} --token al1.xxxxx      # 首次接入，token 只需给这一次`,
-      `  npx ${self}                        # 之后裸跑，复用已存凭证`,
+      `  npx ${self}                        # 首次：终端出二维码，手机扫码绑定；`,
+      `                                     # 之后裸跑复用已存凭证，直接上线`,
       ``,
-      `连接是出站的（走 NAT/防火墙无需端口转发），断线自动重连。al1. 凭证的加密`,
-      `密钥段只留在本机、从不上网（端到端加密）。`,
+      `连接是出站的（走 NAT/防火墙无需端口转发），断线自动重连。加密密钥只留在`,
+      `本机和扫码的手机上、从不上网（端到端加密）。`,
       ``,
     ].join("\n"),
   );