agent-loft 0.0.0-stage → 0.2.8

package/src/channels/web/server.ts

@@ -0,0 +1,446 @@
+// Web 渠道：静态页面 + REST + WebSocket。
+//
+// WebSocket 上跑的是实时的东西：订阅某条会话的事件流（断线重连按 seq 补发）、
+// 发消息、点授权 / 作答。手机切到后台再回来，连接会断，重连后用 since 把错过的补上。
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer, type WebSocket } from "ws";
+import { config } from "../../core/config.js";
+import { parseCommand } from "../../core/commands.js";
+import { hub, type EventEnvelope } from "../../core/hub.js";
+import { interactions, type Interaction } from "../../core/interactions.js";
+import { getConversation } from "../../core/store.js";
+import type { Settlement } from "../../core/types.js";
+import { authed, handleApi, takeUploads } from "./api.js";
+import { authEvents, ensureSetupToken, validateSession } from "./auth.js";
+import { cookies } from "./http.js";
+import { COOKIE } from "./api.js";
+import { HttpError, sameOrigin, SECURITY_HEADERS, sendJson } from "./http.js";
+import { hasSubscriptions, pushToAll } from "./push.js";
+
+const require = createRequire(import.meta.url);
+const webRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../web");
+
+/** 包的根目录。有的包（dompurify）的 exports 没放出 package.json，只能从入口往上找。 */
+function pkgDir(pkg: string): string {
+  try {
+    return path.dirname(require.resolve(`${pkg}/package.json`));
+  } catch {
+    let dir = path.dirname(require.resolve(pkg));
+    while (!fs.existsSync(path.join(dir, "package.json")) && path.dirname(dir) !== dir) dir = path.dirname(dir);
+    return dir;
+  }
+}
+
+function pkgFile(pkg: string, rel: string): string {
+  return path.join(pkgDir(pkg), rel);
+}
+
+/** 前端依赖直接从 node_modules 里给，不走 CDN（国内访问 CDN 不稳定） */
+const VENDOR: Record<string, () => string> = {
+  "/vendor/marked.js": () => pkgFile("marked", "lib/marked.esm.js"),
+  "/vendor/purify.js": () => pkgFile("dompurify", "dist/purify.es.mjs"),
+  "/vendor/hljs.js": () => pkgFile("@highlightjs/cdn-assets", "es/highlight.min.js"),
+  "/vendor/hljs-light.css": () => pkgFile("@highlightjs/cdn-assets", "styles/github.min.css"),
+  "/vendor/hljs-dark.css": () => pkgFile("@highlightjs/cdn-assets", "styles/github-dark.min.css"),
+};
+
+const MIME: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".json": "application/json",
+  ".webmanifest": "application/manifest+json",
+};
+
+function serveFile(res: http.ServerResponse, file: string, cache: string): void {
+  fs.stat(file, (err, stat) => {
+    if (err || !stat.isFile()) {
+      res.writeHead(404, SECURITY_HEADERS);
+      res.end("not found");
+      return;
+    }
+    res.writeHead(200, {
+      ...SECURITY_HEADERS,
+      "Content-Type": MIME[path.extname(file)] ?? "application/octet-stream",
+      "Content-Length": stat.size,
+      "Cache-Control": cache,
+    });
+    fs.createReadStream(file).pipe(res);
+  });
+}
+
+function serveStatic(req: http.IncomingMessage, res: http.ServerResponse, url: URL): void {
+  const vendor = VENDOR[url.pathname];
+  if (vendor) {
+    try {
+      serveFile(res, vendor(), "public, max-age=86400");
+    } catch {
+      res.writeHead(404);
+      res.end();
+    }
+    return;
+  }
+  let rel: string;
+  try {
+    rel = decodeURIComponent(url.pathname);
+  } catch {
+    res.writeHead(400, SECURITY_HEADERS);
+    res.end("bad request");
+    return;
+  }
+  if (rel.includes("\0")) {
+    res.writeHead(400, SECURITY_HEADERS);
+    res.end("bad request");
+    return;
+  }
+  if (rel === "/" || !path.extname(rel)) rel = "/index.html"; // 单页应用
+  const file = path.resolve(webRoot, `.${rel}`);
+  if (!file.startsWith(webRoot + path.sep)) {
+    res.writeHead(403);
+    res.end();
+    return;
+  }
+  // 页面本身别缓存：升级后要立刻生效
+  serveFile(res, file, rel === "/index.html" || rel === "/sw.js" ? "no-cache" : "public, max-age=300");
+  void req;
+}
+
+// ---------- WebSocket ----------
+
+type Client = {
+  ws: WebSocket;
+  subs: Set<string>;
+  alive: boolean;
+  token: string;
+  /** 页面在前台，且正看着哪条会话（前端在切会话、切前后台时上报） */
+  visible: boolean;
+  viewing: string | null;
+};
+
+/** 每次进程启动换一个：客户端发现变了，就知道 seq 已经从头计数，得整页重拉 */
+const EPOCH = Math.random().toString(36).slice(2, 10);
+
+/** 登录态已失效的连接：断开。客户端收到 4401 会回到登录页 */
+function checkClient(client: Client): boolean {
+  if (validateSession(client.token)) return true;
+  client.ws.close(4401, "登录已失效");
+  clients.delete(client);
+  return false;
+}
+const clients = new Set<Client>();
+
+function send(client: Client, msg: unknown): void {
+  if (client.ws.readyState === client.ws.OPEN) client.ws.send(JSON.stringify(msg));
+}
+
+function broadcastEvent(env: EventEnvelope): void {
+  // 侧边栏需要知道哪条会话有动静；正文只推给订阅了的
+  const listChanged = ["user", "meta", "state", "result", "error"].includes(env.ev.type);
+  const info = listChanged ? hub.info(env.key) : undefined;
+  for (const client of [...clients]) {
+    if (client.subs.has(env.key)) send(client, { t: "ev", ...env });
+    if (info) send(client, { t: "conv", info });
+  }
+}
+
+function broadcastInteraction(i: Interaction): void {
+  for (const client of clients) send(client, { t: "ix", interaction: i });
+}
+
+// ---------- 系统通知（Web Push） ----------
+
+/** 有页面正在前台看着这条会话：人就在眼前，不用推 */
+function watching(key: string): boolean {
+  for (const client of clients) if (client.visible && client.viewing === key) return true;
+  return false;
+}
+
+/** 通知正文用：去掉 markdown 记号，压成一行 */
+export function plainPreview(text: string, max = 120): string {
+  const plain = text
+    .replace(/```[\s\S]*?```/g, " [代码] ")
+    .replace(/!\[[^\]]*\]\([^)]*\)/g, " [图片] ")
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
+    .replace(/[`*_~#>|]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return plain.length > max ? `${plain.slice(0, max - 1)}…` : plain;
+}
+
+function convName(key: string): string {
+  const conv = getConversation(key);
+  if (!conv) return "Agent Loft";
+  return conv.title?.trim() || hub.label(conv.agent);
+}
+
+/** 只推 Web 自己的会话：飞书会话的动静飞书已经会提醒 */
+function notifiable(key: string): boolean {
+  return getConversation(key)?.channel === "web" && hasSubscriptions() && !watching(key);
+}
+
+function pushEvent(env: EventEnvelope): void {
+  const ev = env.ev;
+  if (ev.type !== "result" && ev.type !== "error") return;
+  if (!notifiable(env.key)) return;
+  const name = convName(env.key);
+  const payload =
+    ev.type === "result"
+      ? { title: `${name} · 回复完成`, body: plainPreview(ev.text) || "（没有文字回复）" }
+      : { title: `${name} · 出错了`, body: plainPreview(ev.message) };
+  void pushToAll({ ...payload, tag: `reply:${env.key}`, url: `/#${encodeURIComponent(env.key)}` });
+}
+
+function pushInteraction(i: Interaction): void {
+  if (!notifiable(i.convKey)) return;
+  const name = convName(i.convKey);
+  const payload =
+    i.spec.kind === "approval"
+      ? { title: `${name} · 需要授权`, body: plainPreview(i.spec.title) }
+      : { title: `${name} · 有问题要你回答`, body: plainPreview(i.spec.questions[0]?.question ?? i.spec.title) };
+  void pushToAll({ ...payload, tag: `ix:${i.id}`, url: `/#${encodeURIComponent(i.convKey)}` });
+}
+
+const BY = "已在 Web 处理";
+
+function handleClientMessage(client: Client, raw: string): void {
+  // 每条消息都复查登录态：握手时有效不代表现在还有效（改了密码、被踢了）
+  if (!checkClient(client)) return;
+  let msg: Record<string, unknown>;
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+    msg = parsed as Record<string, unknown>;
+  } catch {
+    return;
+  }
+  const rid = msg.rid;
+  const ack = (ok: boolean, extra: Record<string, unknown> = {}) => send(client, { t: "ack", rid, ok, ...extra });
+  const key = typeof msg.key === "string" ? msg.key : "";
+
+  try {
+    switch (msg.t) {
+      case "ping":
+        send(client, { t: "pong" });
+        return;
+
+      case "sub": {
+        if (!getConversation(key)) return ack(false, { error: "会话不存在" });
+        client.subs.add(key);
+        const since = typeof msg.since === "number" ? msg.since : 0;
+        // 客户端的 seq 来自上一个进程（比现在的还大），或者换了实例：补不了，整页重拉
+        const staleEpoch = typeof msg.epoch === "string" && msg.epoch !== EPOCH;
+        // since=0：刚打开，历史由 REST 拉，这里只补正在进行的那一轮
+        const events =
+          staleEpoch || since > hub.currentSeq() ? null : since > 0 ? hub.eventsSince(key, since) : hub.liveTurn(key);
+        send(client, {
+          t: "replay",
+          epoch: EPOCH,
+          key,
+          reset: events === null,
+          events: events ?? [],
+          seq: hub.currentSeq(),
+          busy: hub.isBusy(key),
+          pending: interactions.listPending(key),
+        });
+        return ack(true);
+      }
+
+      case "presence":
+        client.visible = msg.visible === true;
+        client.viewing = typeof msg.key === "string" && msg.key ? msg.key : null;
+        return;
+
+      case "unsub":
+        client.subs.delete(key);
+        return ack(true);
+
+      case "send": {
+        if (!getConversation(key)) return ack(false, { error: "会话不存在" });
+        const text = typeof msg.text === "string" ? msg.text : "";
+        const attachments = takeUploads(key, msg.uploads);
+        if (!text.trim() && attachments.length === 0) return ack(false, { error: "空消息" });
+        // 和飞书一致：整条消息是 agent-loft 命令就由 hub 执行，结果随 ack 回给发命令的这个页面，
+        // 不进会话记录。带附件的一律当聊天。
+        const command = attachments.length > 0 ? null : parseCommand(text);
+        if (command && command.kind !== "chat") {
+          const allowedAgents = hub.enabledAgents().map((d) => d.id);
+          void hub
+            .command(key, command, { allowedAgents, by: "Web 命令" })
+            .then((reply) => ack(true, { reply, info: hub.info(key) }))
+            .catch((err) => ack(false, { error: err instanceof Error ? err.message : String(err) }));
+          return;
+        }
+        hub.send(key, { text, attachments }, { channel: "web", channelId: "web", name: "Web" });
+        return ack(true);
+      }
+
+      case "ix": {
+        const id = String(msg.id ?? "");
+        let ok = false;
+        let error: string | undefined;
+        switch (msg.op) {
+          case "decide":
+            ok = !!interactions.decide(id, String(msg.decision) as Settlement, BY);
+            break;
+          case "select":
+            ok = !!interactions.select(id, Number(msg.q), Number(msg.o), msg.v !== false, BY);
+            break;
+          case "submit": {
+            const r = interactions.submit(id, BY);
+            ok = !!r && !("missing" in r);
+            if (r && "missing" in r) error = "还有问题没选";
+            break;
+          }
+          case "skip":
+            ok = !!interactions.skip(id, "已在 Web 跳过，agent 会按合理的默认继续");
+            break;
+          case "text":
+            ok = interactions.answerWithText(id, String(msg.text ?? ""), BY);
+            break;
+        }
+        if (!ok && !error) {
+          const settled = interactions.get(id)?.settled;
+          error = settled ? `已经处理过了（${settled.by}）` : "请求已失效";
+        }
+        return ack(ok, error ? { error } : {});
+      }
+    }
+  } catch (err) {
+    ack(false, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+
+// ---------- 启动 ----------
+
+let server: http.Server | null = null;
+let wss: WebSocketServer | null = null;
+let heartbeat: NodeJS.Timeout | null = null;
+
+export async function startWeb(): Promise<void> {
+  const { host, port } = config().web;
+
+  server = http.createServer((req, res) => {
+    let url: URL;
+    try {
+      url = new URL(req.url ?? "/", "http://local");
+    } catch {
+      res.writeHead(400);
+      res.end();
+      return;
+    }
+    if (!url.pathname.startsWith("/api/")) {
+      try {
+        serveStatic(req, res, url);
+      } catch (err) {
+        console.error("[web] 静态文件出错:", err);
+        if (!res.headersSent) res.writeHead(500);
+        res.end();
+      }
+      return;
+    }
+    if (req.method !== "GET" && !sameOrigin(req)) {
+      sendJson(res, 403, { error: "跨站请求被拒绝" });
+      return;
+    }
+    for (const [k, v] of Object.entries(SECURITY_HEADERS)) res.setHeader(k, v);
+    handleApi(req, res, url).catch((err) => {
+      const status = err instanceof HttpError ? err.status : 500;
+      if (status === 500) console.error("[web] 接口出错:", err);
+      if (!res.headersSent) sendJson(res, status, { error: err instanceof Error ? err.message : String(err) });
+      else res.end();
+    });
+  });
+
+  wss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
+  server.on("upgrade", (req, socket, head) => {
+    try {
+      const url = new URL(req.url ?? "/", "http://local");
+      if (url.pathname !== "/ws" || !sameOrigin(req) || !authed(req)) {
+        socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+      const token = cookies(req)[COOKIE] ?? "";
+      wss!.handleUpgrade(req, socket, head, (ws) => {
+        const client: Client = { ws, subs: new Set(), alive: true, token, visible: false, viewing: null };
+        clients.add(client);
+        ws.on("pong", () => (client.alive = true));
+        ws.on("message", (data) => {
+          try {
+            handleClientMessage(client, data.toString());
+          } catch (err) {
+            console.error("[web] 处理 WebSocket 消息出错:", err);
+          }
+        });
+        ws.on("close", () => clients.delete(client));
+        ws.on("error", () => clients.delete(client));
+        send(client, { t: "hello", seq: hub.currentSeq(), epoch: EPOCH });
+      });
+    } catch (err) {
+      console.error("[web] WebSocket 握手出错:", err);
+      socket.destroy();
+    }
+  });
+  authEvents.on("revoked", onRevoked);
+
+  // 反代 / 手机网络会悄悄掐掉空闲连接，定期 ping 一下把死连接清掉
+  heartbeat = setInterval(() => {
+    for (const client of [...clients]) {
+      if (!checkClient(client)) continue;
+      if (!client.alive) {
+        client.ws.terminate();
+        clients.delete(client);
+        continue;
+      }
+      client.alive = false;
+      client.ws.ping();
+    }
+  }, 30_000);
+  heartbeat.unref();
+
+  hub.on("event", broadcastEvent);
+  hub.on("event", pushEvent);
+  interactions.on("created", broadcastInteraction);
+  interactions.on("created", pushInteraction);
+  interactions.on("updated", broadcastInteraction);
+  interactions.on("settled", broadcastInteraction);
+
+  await new Promise<void>((resolve, reject) => {
+    server!.once("error", reject);
+    server!.listen(port, host, () => resolve());
+  });
+  console.log(`[web] 已监听 http://${host}:${port}`);
+  const token = ensureSetupToken();
+  if (token) {
+    console.log("=".repeat(56));
+    console.log(`[web] 还没有设置登录密码。打开页面后输入设置码：${token}`);
+    console.log("=".repeat(56));
+  }
+}
+
+function onRevoked(): void {
+  for (const client of [...clients]) checkClient(client);
+}
+
+export async function stopWeb(): Promise<void> {
+  authEvents.off("revoked", onRevoked);
+  hub.off("event", broadcastEvent);
+  hub.off("event", pushEvent);
+  interactions.off("created", broadcastInteraction);
+  interactions.off("created", pushInteraction);
+  interactions.off("updated", broadcastInteraction);
+  interactions.off("settled", broadcastInteraction);
+  if (heartbeat) clearInterval(heartbeat);
+  for (const client of clients) client.ws.close(1001, "服务重启");
+  clients.clear();
+  wss?.close();
+  await new Promise<void>((resolve) => (server ? server.close(() => resolve()) : resolve()));
+  server = null;
+}

package/src/cli/doctor.ts

@@ -0,0 +1,39 @@
+// agent-loft doctor：配置 / agent / 飞书连通性体检。
+import { spawnSync } from "node:child_process";
+import { config, loadConfig } from "../core/config.js";
+import { FeishuClient } from "../channels/feishu/client.js";
+import { configPath } from "../home.js";
+
+loadConfig();
+const cfg = config();
+const ok = (s: string) => console.log(`  ✅ ${s}`);
+const bad = (s: string) => console.log(`  ❌ ${s}`);
+const warn = (s: string) => console.log(`  ⚠️  ${s}`);
+
+console.log(`配置文件：${configPath}`);
+console.log(`工作目录：${cfg.workspaceRoot}`);
+
+console.log("\nAgent");
+if (cfg.agents.claude.enabled) {
+  const r = spawnSync("claude", ["--version"], { encoding: "utf8" });
+  if (r.status === 0) ok(`Claude Code ${r.stdout.trim()}`);
+  else warn("没找到 claude 命令（SDK 自带运行时，通常不影响；登录态需要先在终端 claude 里登录过）");
+} else warn("Claude 未启用");
+if (cfg.agents.codex.enabled) {
+  const r = spawnSync(cfg.agents.codex.path, ["--version"], { encoding: "utf8" });
+  if (r.status === 0) ok(`Codex ${r.stdout.trim()}（沙箱 ${cfg.agents.codex.sandbox}）`);
+  else bad(`找不到 ${cfg.agents.codex.path}，到设置里填 codex 的绝对路径`);
+} else warn("Codex 未启用");
+
+console.log("\n飞书机器人");
+if (cfg.feishu.bots.length === 0) warn("还没有配置飞书机器人（Web 设置页可以扫码创建）");
+for (const bot of cfg.feishu.bots) {
+  const probe = await new FeishuClient(bot.appId, bot.appSecret, bot.domain, bot.name).probe();
+  const line = `${bot.name}（${bot.appId}，agent：${bot.agents.join("、")}）${bot.enabled ? "" : " [未启用]"}`;
+  if (probe.ok) ok(line);
+  else bad(`${line}：${probe.message}`);
+  if (bot.allowFrom.length === 0) warn(`${bot.name} 的白名单为空：只能靠配对使用`);
+}
+
+console.log("\nWeb");
+console.log(`  ${cfg.web.enabled ? `http://${cfg.web.host}:${cfg.web.port}` : "未启用"}${cfg.web.passwordHash ? "" : "（还没设密码，首次打开需要启动日志里的设置码）"}`);

package/src/cli/import.ts

@@ -0,0 +1,155 @@
+// 从旧桥接器导入：feishu-claude-bridge（~/.feishu-claude-bridge）和 feishu-codex-bridge（~/.feishu-codex-bridge）。
+//
+// 导入飞书机器人凭据、白名单、配对、会话绑定（飞书群里接着原来的会话聊）、
+// Claude 的「总是允许」名单，以及工作目录 / 默认模型 / 沙箱等设置。
+//
+// 用法：
+//   agent-loft import                        两个都导
+//   agent-loft import --only codex           只导其中一个
+//   agent-loft import --disabled             导入但先不启用机器人（新旧并行时避免抢同一个机器人的消息）
+//   agent-loft import --dry-run              只看会导入什么
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { config, loadConfig, saveConfig, type FeishuBotConfig } from "../core/config.js";
+import { getConversation, putConversation, type Conversation } from "../core/store.js";
+import { addApproved } from "../core/pairing.js";
+import { listAllowlist, setAllowlist } from "../agents/claude/permissions.js";
+import { readJson } from "../home.js";
+
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(`--${name}`);
+const value = (name: string) => {
+  const at = args.indexOf(`--${name}`);
+  return at >= 0 ? args[at + 1] : undefined;
+};
+const only = value("only");
+const dryRun = flag("dry-run");
+const disabled = flag("disabled");
+
+function parseEnv(file: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  let text: string;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return out;
+  }
+  for (const line of text.split("\n")) {
+    const m = /^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/.exec(line);
+    if (!m) continue;
+    out[m[1]!] = m[2]!.replace(/^["']|["']$/g, "");
+  }
+  return out;
+}
+
+type OldBinding = {
+  sessionId?: string;
+  threadId?: string;
+  cwd: string;
+  cwdExplicit?: boolean;
+  model?: string;
+  effort?: string;
+  updatedAt: number;
+};
+
+function importOne(kind: "claude" | "codex"): void {
+  const dir = path.join(os.homedir(), kind === "claude" ? ".feishu-claude-bridge" : ".feishu-codex-bridge");
+  const env = parseEnv(path.join(dir, ".env"));
+  if (!env.FEISHU_APP_ID || !env.FEISHU_APP_SECRET) {
+    console.log(`- ${dir} 没有可用的配置，跳过`);
+    return;
+  }
+  const cfg = structuredClone(config());
+  const botId = `${kind}_bot`;
+  const existing = cfg.feishu.bots.find((b) => b.appId === env.FEISHU_APP_ID);
+  const id = existing?.id ?? botId;
+  const bot: FeishuBotConfig = {
+    id,
+    name: existing?.name ?? (kind === "claude" ? "Claude 机器人" : "Codex 机器人"),
+    enabled: !disabled,
+    appId: env.FEISHU_APP_ID,
+    appSecret: env.FEISHU_APP_SECRET,
+    domain: env.FEISHU_DOMAIN === "lark" ? "lark" : "feishu",
+    allowFrom: (env.FEISHU_ALLOW_FROM ?? "")
+      .split(",")
+      .map((s) => s.trim().toLowerCase())
+      .filter((s) => s.startsWith("ou_")),
+    agents: existing?.agents ?? [kind],
+    defaultAgent: existing?.defaultAgent ?? kind,
+  };
+  console.log(`- 飞书机器人「${bot.name}」 appId=${bot.appId} agent=${bot.agents.join(",")} 白名单 ${bot.allowFrom.length} 人${disabled ? "（暂不启用）" : ""}`);
+
+  if (env.BRIDGE_WORKSPACE_ROOT) cfg.workspaceRoot = env.BRIDGE_WORKSPACE_ROOT;
+  if (env.BRIDGE_APPROVAL_TIMEOUT_MS) cfg.approvalTimeoutMs = Number(env.BRIDGE_APPROVAL_TIMEOUT_MS);
+  if (env.BRIDGE_SESSION_TTL_MS) cfg.sessionTtlMs = Number(env.BRIDGE_SESSION_TTL_MS);
+  if (kind === "claude") {
+    if (env.BRIDGE_DEFAULT_MODEL) cfg.agents.claude.defaultModel = env.BRIDGE_DEFAULT_MODEL;
+  } else {
+    if (env.BRIDGE_CODEX_PATH) cfg.agents.codex.path = env.BRIDGE_CODEX_PATH;
+    if (env.BRIDGE_CODEX_HOME) cfg.agents.codex.home = env.BRIDGE_CODEX_HOME;
+    if (env.BRIDGE_SANDBOX) cfg.agents.codex.sandbox = env.BRIDGE_SANDBOX as typeof cfg.agents.codex.sandbox;
+    if (env.BRIDGE_DEFAULT_MODEL) cfg.agents.codex.defaultModel = env.BRIDGE_DEFAULT_MODEL;
+    if (env.BRIDGE_DEFAULT_EFFORT) cfg.agents.codex.defaultEffort = env.BRIDGE_DEFAULT_EFFORT;
+  }
+  cfg.feishu.bots = [...cfg.feishu.bots.filter((b) => b.id !== id), bot];
+
+  const sessions = readJson<Record<string, OldBinding>>(path.join(dir, "data", "sessions.json"), {});
+  const pairing = readJson<{ approved?: string[] }>(path.join(dir, "data", "pairing.json"), {});
+  const allowlist = kind === "claude" ? readJson<string[]>(path.join(dir, "data", "allowlist.json"), []) : [];
+  console.log(`  会话 ${Object.keys(sessions).length} 条，配对用户 ${pairing.approved?.length ?? 0} 人${kind === "claude" ? `，总是允许 ${allowlist.length} 条` : ""}`);
+  if (dryRun) return;
+
+  saveConfig(cfg);
+  for (const [oldKey, b] of Object.entries(sessions)) {
+    const key = `feishu:${id}:${oldKey}`;
+    if (getConversation(key)) continue;
+    const sessionId = b.sessionId ?? b.threadId;
+    const conv: Conversation = {
+      key,
+      channel: "feishu",
+      channelId: id,
+      agent: kind,
+      cwd: b.cwd || config().workspaceRoot,
+      ...(b.cwdExplicit ? { cwdExplicit: true } : {}),
+      perAgent: {
+        [kind]: {
+          ...(sessionId ? { sessionId } : {}),
+          ...(b.model ? { model: b.model } : {}),
+          ...(b.effort ? { effort: b.effort } : {}),
+        },
+      },
+      activeAt: b.updatedAt || Date.now(),
+      createdAt: b.updatedAt || Date.now(),
+    };
+    putConversation(conv);
+  }
+  for (const userId of pairing.approved ?? []) addApproved(id, userId);
+  if (allowlist.length) setAllowlist([...listAllowlist(), ...allowlist]);
+}
+
+loadConfig();
+
+// 正在运行的实例内存里有一份会话缓存，下次写盘会把这里导入的覆盖掉
+async function instanceRunning(): Promise<boolean> {
+  const { host, port } = config().web;
+  if (!config().web.enabled) return false;
+  try {
+    await fetch(`http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}/api/me`, { signal: AbortSignal.timeout(1500) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+if (!dryRun && !flag("force") && (await instanceRunning())) {
+  throw new Error("agent-loft 正在运行。请先停止它再导入（agent-loft service 管理的话：systemctl --user stop agent-loft），导完再启动。");
+}
+
+console.log(dryRun ? "将要导入（dry-run，不落盘）：" : "导入中：");
+if (!only || only === "claude") importOne("claude");
+if (!only || only === "codex") importOne("codex");
+console.log(
+  dryRun
+    ? "\n去掉 --dry-run 正式导入。"
+    : "\n完成。注意：同一个飞书机器人不能被两个程序同时连接，正式切换前请先停掉旧的桥接器服务：\n  systemctl --user disable --now feishu-claude-bridge feishu-codex-bridge",
+);

package/src/cli/pair.ts

@@ -0,0 +1,35 @@
+// agent-loft pair list | approve <配对码> | revoke <机器人id> <open_id>
+import { approve, listApproved, listPending, revoke } from "../core/pairing.js";
+import { loadConfig } from "../core/config.js";
+
+loadConfig();
+const [sub, ...rest] = process.argv.slice(2);
+
+switch (sub) {
+  case "approve": {
+    const code = rest[0];
+    if (!code) throw new Error("用法：agent-loft pair approve <配对码>");
+    const result = approve(code);
+    if (!result.ok) throw new Error(`配对码 ${code} 不存在或已过期`);
+    console.log(`已批准 ${result.request.userId}（机器人 ${result.channelId}）。正在运行的 agent-loft 会通知对方。`);
+    break;
+  }
+  case "revoke": {
+    const [channelId, userId] = rest;
+    if (!channelId || !userId) throw new Error("用法：agent-loft pair revoke <机器人id> <open_id>");
+    console.log(revoke(channelId, userId) ? "已撤销" : "没有这个已配对用户");
+    break;
+  }
+  default: {
+    const pending = listPending();
+    console.log(pending.length ? "待批准：" : "没有待批准的请求。");
+    for (const { channelId, request } of pending) {
+      console.log(`  ${request.code}  ${request.userId}  机器人 ${channelId}  ${new Date(request.createdAt).toLocaleString()}`);
+    }
+    const approved = listApproved();
+    if (approved.length) {
+      console.log("已配对：");
+      for (const a of approved) console.log(`  ${a.userId}  机器人 ${a.channelId}`);
+    }
+  }
+}