@landh93/web-codex-client 0.1.0-rc.1 → 0.1.0-rc.2

package/NPM_RELEASE.md

@@ -1,6 +1,6 @@
 # npm 客户端发布与安装
 
-包名：`@landh93/web-codex-client`。首版为 `0.1.0-rc.1`，使用 `next` 标签。仅支持 Linux / Node.js 24；这是独立安装候选版，不代表公网、多人或真实模型执行已完成生产验收。`remote-wss-v1` 明确允许远端 WSS，继续使用固定 Noise 加密、TLS 校验及本机指纹授权，不新增任何加密实现。项目尚未选定开源许可证，包暂保留 `UNLICENSED`；第三方代码许可见包内 `sdk/THIRD_PARTY_NOTICES.md`。
+包名：`@landh93/web-codex-client`。当前候选版为 `0.1.0-rc.2`，使用 `next` 标签。仅支持 Linux / Node.js 24；这是独立安装候选版，不代表公网、多人或真实模型执行已完成生产验收。`remote-wss-v1` 明确允许远端 WSS，继续使用固定 Noise 加密、TLS 校验及本机指纹授权，不新增任何加密实现。项目尚未选定开源许可证，包暂保留 `UNLICENSED`；第三方代码许可见包内 `sdk/THIRD_PARTY_NOTICES.md`。
 
 ## 用户安装
 
@@ -25,7 +25,17 @@ web-codex-client configure --relay wss://relay.example.com --token-stdin < /path
 
 使用公开 CA 证书时通常无需额外设置；私有 CA 可在启动 Node 前设置 `NODE_EXTRA_CA_CERTS=/path/to/ca.pem`。禁止 `NODE_TLS_REJECT_UNAUTHORIZED=0`。Nginx 要正确代理 `/ws/v1/client`，token 经 Authorization 头发送。
 
-Client 运行后，在另一终端执行 `web-codex-client pair-open`、`pair-list`，核对浏览器的完整指纹，再用 `pair-approve --fingerprint FULL_HASH --root /absolute/project` 授权。默认只读，需要执行任务时才加 `--write`。这些命令自动使用配置中的 stateDir；旧的 `--state` 用法仍有效。
+Client 运行后，在网页选择设备，然后在另一终端执行 **`web-codex-client pair`**。对照终端与网页的完整指纹，在网页点击“与本机显示一致”，再在终端输入 `yes`。无需提前执行 `pair-open`，无需复制 64 位指纹或逐个配置已有项目目录。
+
+核对并信任浏览器后，从本机 Codex 项目目录及活动/归档历史的 cwd 识别已有项目，自动授予这些目录的读写权限；扫描有分页、去重和数量上限，不会把浏览器任意指定的路径当作已有项目。系统根目录、用户家目录以及包含 Client 状态的父目录不自动授予。没有识别到项目时明确报错，可以使用 `pair --root /absolute/project` 在终端明确确认目录读写授权。
+
+新增目录执行 **`web-codex-client authorize --root /absolute/directory`**：已有 Codex 项目直接授权读写，其他目录要求终端输入 `yes`。若有多个活动浏览器，使用 `--peer` 指定 `status` 中的浏览器公钥。权限按目录检查，新增写权限不会提升其他只读目录。Codex 执行任务仍使用工作区沙箱、操作审批及写租约；网页中的“申请控制权”管理同一对话的写入归属。
+
+自动授权是配对时的目录快照。配对后新建的 Codex 项目可使用上述 `authorize` 命令加入，无需重新配对。升级不会擅自提升已有只读授权。
+
+旧的 `pair-approve --fingerprint FULL_HASH`、`pair-list`、`--state` 用法仍有效。`pair-approve` 不传 `--root` 时采用已有项目；指定已有项目且不传权限参数时自动读写；`--read-only` 明确保持只读；未知目录可通过 `pair --root` 交互确认，或通过显式 `pair-approve --root PATH --write` 授权。重复批准同一已授权指纹返回成功，不会因为窗口已关闭而失败。
+
+配对等待最多 5 分钟，期间只能核对身份，不能读取内容。`pair-list` 返回网页是否确认、剩余时间和可否批准；本机错误响应区分指纹不存在、网页未确认、路由过期、目录不可访问、授权保存失败和授权数量上限，且不包含底层异常正文。网页刷新或重新连接后必须使用新的指纹。旧 Web 的 2 分钟等待仍可能先到期；更新 Server 前端后会显示新指引并使用 5 分钟等待。协议及固定 SDK 版本保持兼容。
 
 后台常驻可使用 systemd 用户服务，将 `ExecStart` 设为实际安装的 `web-codex-client run --config /absolute/config.json`。npm 安装不会自动启用服务或打开配对窗口。
 
@@ -65,7 +75,7 @@ npm whoami --registry=https://registry.npmjs.org/ --userconfig="$HOME/.config/we
 随后发布已通过验证的**具体 tgz**，不重新构建另一个包：
 
 ```bash
-npm publish .test-output/landh93-web-codex-client-0.1.0-rc.1.tgz \
+npm publish .test-output/landh93-web-codex-client-0.1.0-rc.2.tgz \
   --access public --tag next --ignore-scripts \
   --registry=https://registry.npmjs.org/ \
   --userconfig="$HOME/.config/web-codex-npm/npmrc"

package/README.md

@@ -19,7 +19,7 @@ web-codex-client run
 
 `configure` 交互输入 WSS 地址、Codex socket 和隐藏的设备 token，保存在用户配置目录。`doctor` 检查私有配置、WASM、WSS 认证和 Codex 初始化，失败退出非零；既有 Client 在线时不会抢占它的连接。支持 `--quiet`。安装和升级不会重启 Codex，也不会自动批准浏览器。
 
-另开终端运行 `web-codex-client pair-open`，浏览器连接后用 `pair-list` 核对完整指纹，再 `pair-approve --fingerprint FULL_HASH --root /absolute/project`。配置、身份和授权独立于 npm 安装目录，升级时保留。完整安装、token 标准输入、证书、后台运行与发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
+网页选择设备后，另开终端运行 `web-codex-client pair`，核对完整指纹并在网页和终端确认。无需提前开启窗口；Codex 已有项目自动授予读写，新目录用 `web-codex-client authorize --root /absolute/path` 在本机确认。配置、身份和授权独立于 npm 安装目录，升级时保留。完整安装、token 标准输入、证书、后台运行与发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
 
 ## 安装、构建、自测
 
@@ -64,7 +64,7 @@ node dist/cli.js run --config ~/.config/web-codex-client/config.json
 
 ```bash
 node dist/cli.js status --state ~/.config/web-codex-client/state
-node dist/cli.js pair-open --state ~/.config/web-codex-client/state
+node dist/cli.js pair --config ~/.config/web-codex-client/config.json
 node dist/cli.js pair-list --state ~/.config/web-codex-client/state
 # 浏览器完成握手后，与本地 pair-list 核对完整的 64 位指纹。
 # 在可信浏览器点击确认，再在本机明确授予目录权限：
@@ -75,7 +75,7 @@ node dist/cli.js revoke --state ~/.config/web-codex-client/state \
   --peer BROWSER_PUBLIC_KEY_FROM_PAIR_LIST
 ```
 
-配对窗口 120 秒，本机确认还要求浏览器已确认相同指纹。默认只读；`--write` 才允许执行和租约。撤销立即关闭该身份的会话并拒绝后续业务。浏览器身份默认仅存内存，刷新后重新配对；同一页面断线重连可以继续使用内存身份和固定公钥。
+rc.2 配对等待 5 分钟，本机确认还要求浏览器已确认相同指纹；不再强制先执行 `pair-open`。默认对识别到的 Codex 项目授予读写，其他目录需要显式本机授权；`--read-only` 可指定只读。`pair-list` 显示剩余时间，失败返回白名单错误码和处理提示。撤销立即关闭该身份的会话并拒绝后续业务。浏览器身份默认仅存内存，刷新后重新配对；同一页面断线重连可以继续使用内存身份和固定公钥。
 
 `status` 分别返回 relayOnline、handshakes、authorizedSessions、codexAvailable。Codex 连接按第一次已授权请求惰性建立，因此仅中继上线时 codexAvailable 仍为 false。上游断线后下一次请求重连，旧 epoch/订阅失效。后台服务无有限总工作量，不显示伪造百分比。
 

package/dist/cli.js

@@ -1356,15 +1356,18 @@ async function loadState(dir) {
     list = z4.array(
       z4.strictObject({
         peer: z4.string(),
-        roots: z4.array(z4.string()).min(1).max(32),
-        write: z4.boolean()
+        roots: z4.array(z4.string()).min(1).max(256),
+        write: z4.boolean(),
+        writeRoots: z4.array(z4.string()).max(256).optional()
       })
     ).max(256).parse(JSON.parse(await privateRead(dir + "/grants.json")));
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
-  for (const g of list)
+  for (const g of list) {
     g.roots = await Promise.all(g.roots.map((r) => realpath(r)));
+    if (g.writeRoots) g.writeRoots = await Promise.all(g.writeRoots.map((r) => realpath(r)));
+  }
   return { identity, grants: new Map(list.map((g) => [g.peer, g])) };
 }
 
@@ -1374,7 +1377,7 @@ import {
   createServer,
   createConnection
 } from "node:net";
-import { chmod, realpath as realpath3, unlink, lstat as lstat2 } from "node:fs/promises";
+import { chmod, realpath as realpath4, unlink, lstat as lstat2, stat as stat3 } from "node:fs/promises";
 import { z as z5 } from "zod";
 
 // src/bridge.ts
@@ -1772,6 +1775,11 @@ var Bridge = class {
     if (!grant) throw new BridgeError("NOT_PAIRED");
     return grant;
   }
+  async writable(owner, path) {
+    const grant = this.grant(owner);
+    if (!grant.write) throw new BridgeError("FORBIDDEN", "\u76EE\u5F55\u5C1A\u672A\u5141\u8BB8\u5199\u5165\uFF0C\u8BF7\u5728\u672C\u673A\u8FD0\u884C web-codex-client authorize --root \u76EE\u5F55\u3002");
+    await authorizedPath(grant.writeRoots ?? grant.roots, path);
+  }
   async project(owner, id2) {
     const g = this.grant(owner);
     if (id2.startsWith("cwd:")) {
@@ -1979,7 +1987,10 @@ var Bridge = class {
         historyFallback: "bounded",
         activeTakeover: "unverified"
       };
-    if ("threadId" in p) await this.thread(owner, p.threadId);
+    if ("threadId" in p) {
+      const thread2 = await this.thread(owner, p.threadId);
+      if (writes.has(method) || method === "leases.acquire") await this.writable(owner, thread2.cwd);
+    }
     if (writes.has(method) && "threadId" in p) {
       this.leases.assert(p.threadId, owner);
       if ((method === "turns.start" || method === "turns.interrupt") && p.connectionEpoch !== this.subscriptions.epoch)
@@ -2124,6 +2135,7 @@ var Bridge = class {
       }
       case "threads.start": {
         const project = await this.project(owner, p.projectId);
+        await this.writable(owner, project.cwd);
         const r = await this.upstream.call("thread/start", {
           cwd: project.cwd,
           sandbox: "workspace-write",
@@ -2237,7 +2249,8 @@ var Bridge = class {
       throw new BridgeError("APPROVAL_EXPIRED");
     if (!g.write) throw new BridgeError("FORBIDDEN");
     this.leases.assert(a.thread, owner);
-    await this.thread(owner, a.thread);
+    const thread2 = await this.thread(owner, a.thread);
+    await this.writable(owner, thread2.cwd);
     if (this.approvals.get(id2) !== a) throw new BridgeError("APPROVAL_EXPIRED");
     this.grant(owner);
     this.leases.assert(a.thread, owner);
@@ -2296,7 +2309,83 @@ var Bridge = class {
   }
 };
 
+// src/admin-errors.ts
+var adminMessages = {
+  FINGERPRINT_NOT_FOUND: "\u5F53\u524D\u6307\u7EB9\u4E0D\u5B58\u5728\u3002\u8BF7\u5728\u7F51\u9875\u91CD\u65B0\u8FDE\u63A5\uFF0C\u518D\u8FD0\u884C web-codex-client pair\u3002",
+  BROWSER_NOT_CONFIRMED: "\u8BF7\u5148\u5728\u7F51\u9875\u70B9\u51FB\u201C\u4E0E\u672C\u673A\u663E\u793A\u4E00\u81F4\u201D\uFF0C\u7136\u540E\u91CD\u8BD5\u3002",
+  PAIRING_ROUTE_EXPIRED: "\u6B64\u914D\u5BF9\u5DF2\u8FC7\u671F\u3002\u8BF7\u5728\u7F51\u9875\u91CD\u65B0\u8FDE\u63A5\u5E76\u6838\u5BF9\u65B0\u6307\u7EB9\u3002",
+  PAIRING_WINDOW_EXPIRED: "\u914D\u5BF9\u7A97\u53E3\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u8FDE\u63A5\u7F51\u9875\u3002",
+  DIRECTORY_UNAVAILABLE: "\u76EE\u5F55\u4E0D\u5B58\u5728\u3001\u4E0D\u662F\u76EE\u5F55\u6216\u5F53\u524D\u7528\u6237\u65E0\u6CD5\u8BBF\u95EE\u3002",
+  GRANT_SAVE_FAILED: "\u6388\u6743\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u72B6\u6001\u76EE\u5F55\u6743\u9650\u548C\u78C1\u76D8\u7A7A\u95F4\u3002",
+  GRANT_LIMIT: "\u6388\u6743\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u5148\u64A4\u9500\u4E0D\u518D\u4F7F\u7528\u7684\u6D4F\u89C8\u5668\u3002",
+  CODEX_UNAVAILABLE: "\u65E0\u6CD5\u8BFB\u53D6\u672C\u673A Codex \u9879\u76EE\uFF0C\u8BF7\u8FD0\u884C web-codex-client doctor\u3002",
+  PROJECT_DISCOVERY_LIMIT: "\u9879\u76EE\u76EE\u5F55\u626B\u63CF\u8FBE\u5230\u4E0A\u9650\uFF0C\u8BF7\u7528 --root \u660E\u786E\u6307\u5B9A\u9879\u76EE\u3002",
+  NO_KNOWN_PROJECTS: "\u6CA1\u6709\u627E\u5230\u53EF\u81EA\u52A8\u6388\u6743\u7684 Codex \u9879\u76EE\u3002\u8BF7\u7528 --root \u6307\u5B9A\u76EE\u5F55\u5E76\u786E\u8BA4\u6388\u6743\u3002",
+  DIRECTORY_APPROVAL_REQUIRED: "\u8BE5\u76EE\u5F55\u4E0D\u662F\u5DF2\u8BC6\u522B\u7684 Codex \u9879\u76EE\uFF1B\u9996\u6B21\u914D\u5BF9\u7528 pair --root \u8DEF\u5F84\uFF0C\u5DF2\u914D\u5BF9\u7528 authorize --root \u8DEF\u5F84\uFF0C\u5728\u672C\u673A\u786E\u8BA4\u3002",
+  PEER_REQUIRED: "\u5B58\u5728\u591A\u4E2A\u6D4F\u89C8\u5668\uFF0C\u8BF7\u7528 --peer \u6307\u5B9A pair-list \u6216 status \u4E2D\u7684\u6D4F\u89C8\u5668\u3002",
+  NOT_PAIRED: "\u5C1A\u672A\u4FE1\u4EFB\u6D4F\u89C8\u5668\uFF0C\u8BF7\u5148\u5728\u7F51\u9875\u8FDE\u63A5\u5E76\u8FD0\u884C web-codex-client pair\u3002",
+  INVALID_ADMIN_REQUEST: "\u547D\u4EE4\u53C2\u6570\u65E0\u6548\uFF0C\u8BF7\u67E5\u770B web-codex-client --help\u3002",
+  ADMIN_REQUEST_REJECTED: "\u672C\u673A\u63A7\u5236\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5 Client \u72B6\u6001\u3002"
+};
+var AdminError = class extends Error {
+  constructor(code) {
+    super(adminMessages[code]);
+    this.code = code;
+  }
+};
+function adminFailure(error) {
+  const code = error instanceof AdminError ? error.code : error instanceof Error && error.name === "ZodError" || error instanceof SyntaxError ? "INVALID_ADMIN_REQUEST" : "ADMIN_REQUEST_REJECTED";
+  return { error: code, message: adminMessages[code] };
+}
+
+// src/known-projects.ts
+import { realpath as realpath3, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute2 } from "node:path";
+async function knownProjects(upstream, stateDir) {
+  const roots = /* @__PURE__ */ new Set();
+  async function add(value) {
+    if (typeof value !== "string" || !isAbsolute2(value)) return;
+    try {
+      const root = await realpath3(value);
+      if (!(await stat2(root)).isDirectory() || root === "/" || root === homedir2() || within(root, stateDir)) return;
+      roots.add(root);
+      if (roots.size > 256) throw new AdminError("PROJECT_DISCOVERY_LIMIT");
+    } catch (error) {
+      if (error instanceof AdminError) throw error;
+    }
+  }
+  async function scan(method, extra, consume) {
+    let cursor;
+    const seen = /* @__PURE__ */ new Set();
+    for (let page2 = 0; page2 < 100; page2++) {
+      const result = await upstream.call(method, { ...extra, limit: 100, cursor });
+      if (!Array.isArray(result.data) || result.data.length > 100) throw new AdminError("CODEX_UNAVAILABLE");
+      for (const row of result.data) await consume(row);
+      if (!result.nextCursor) return;
+      if (typeof result.nextCursor !== "string" || seen.has(result.nextCursor)) throw new AdminError("PROJECT_DISCOVERY_LIMIT");
+      cursor = result.nextCursor;
+      seen.add(result.nextCursor);
+    }
+    throw new AdminError("PROJECT_DISCOVERY_LIMIT");
+  }
+  try {
+    await scan("project/list", {}, async (row) => {
+      for (const root of row.roots ?? []) await add(root.path);
+    });
+  } catch (error) {
+    if (!(error instanceof RpcError && error.code === -32601)) throw error;
+  }
+  for (const archived of [false, true]) {
+    await scan("thread/list", { useStateDbOnly: true, archived, sourceKinds: ["cli", "vscode", "exec", "appServer", "subAgent", "subAgentReview", "subAgentCompact", "subAgentThreadSpawn", "subAgentOther", "unknown"] }, async (row) => {
+      await add(row.cwd);
+    });
+  }
+  return [...roots].sort();
+}
+
 // src/daemon.ts
+var PAIRING_MS = 5 * 60 * 1e3;
 var ClientDaemon = class {
   constructor(config, identity, grants, connectUpstream = () => CodexRpc.connect(config.upstream)) {
     this.config = config;
@@ -2310,7 +2399,10 @@ var ClientDaemon = class {
   stopped = false;
   routes = /* @__PURE__ */ new Map();
   pairUntil = 0;
+  lastRouteClosure;
+  expiredFingerprints = /* @__PURE__ */ new Set();
   admin;
+  adminQueue = Promise.resolve();
   timer;
   retry;
   attempts = 0;
@@ -2333,7 +2425,7 @@ var ClientDaemon = class {
         }
       }
       for (const [id2, r] of this.routes)
-        if (Date.now() > r.expires && !r.owner) this.closeRoute(id2);
+        if (Date.now() > r.expires && !r.owner) this.closeRoute(id2, true, "PAIRING_ROUTE_EXPIRED");
     }, 1e4);
     this.timer.unref();
   }
@@ -2406,7 +2498,7 @@ var ClientDaemon = class {
       }
       this.routes.set(m.routeId, {
         confirmed: false,
-        expires: Date.now() + 12e4,
+        expires: Date.now() + PAIRING_MS,
         queue: Promise.resolve(),
         pending: 0,
         out: [],
@@ -2416,7 +2508,7 @@ var ClientDaemon = class {
       return;
     }
     if (m.type === "route.closed") {
-      this.closeRoute(m.routeId, false);
+      this.closeRoute(m.routeId, false, "RELAY_CLOSED");
       return;
     }
     if (m.type !== "secure") return;
@@ -2457,8 +2549,6 @@ var ClientDaemon = class {
               fingerprint: r.session.fingerprint
             });
           } else {
-            if (Date.now() > this.pairUntil)
-              throw new BridgeError("NOT_PAIRED");
             this.send(frame.routeId, {
               kind: "pairing",
               status: "pending",
@@ -2478,10 +2568,18 @@ var ClientDaemon = class {
       }
       if (!r.owner || !this.grants.has(r.owner))
         throw new BridgeError("NOT_PAIRED");
-      await this.ensureUpstream();
+      try {
+        await this.ensureUpstream();
+      } catch {
+        if (message.kind === "request") {
+          this.send(frame.routeId, { kind: "response", requestId: message.requestId, error: { code: "UPSTREAM_UNAVAILABLE", message: "\u672C\u673A Codex \u6682\u4E0D\u53EF\u7528\uFF0C\u8BF7\u8FD0\u884C web-codex-client doctor \u540E\u91CD\u8BD5\u3002", retryable: true } });
+          return;
+        }
+        throw new BridgeError("UPSTREAM_UNAVAILABLE");
+      }
       const response = await this.bridge.handle(r.owner, message);
       if (response) this.send(frame.routeId, response);
-    }).catch(() => this.closeRoute(frame.routeId)).finally(() => r.pending--);
+    }).catch((error) => this.closeRoute(frame.routeId, true, error instanceof BridgeError ? error.code : "PROTOCOL_ERROR")).finally(() => r.pending--);
   }
   send(id2, message) {
     const r = this.routes.get(id2);
@@ -2518,9 +2616,14 @@ var ClientDaemon = class {
       r.sending = false;
     }
   }
-  closeRoute(id2, notify = true) {
+  closeRoute(id2, notify = true, reason = "CLOSED") {
     const r = this.routes.get(id2);
     if (!r) return;
+    this.lastRouteClosure = { at: Date.now(), reason };
+    if (reason === "PAIRING_ROUTE_EXPIRED" && r.session?.fingerprint) {
+      if (this.expiredFingerprints.size >= 64) this.expiredFingerprints.delete(this.expiredFingerprints.values().next().value);
+      this.expiredFingerprints.add(r.session.fingerprint);
+    }
     this.routes.delete(id2);
     r.session?.close();
     r.out = [];
@@ -2541,50 +2644,65 @@ var ClientDaemon = class {
           authorizedSessions: Array.from(this.routes.values()).filter(
             (r) => r.owner
           ).length,
-          pairingUntil: this.pairUntil
+          pairingUntil: this.pairUntil,
+          pairingMode: "local-confirmation",
+          pairingRemainingMs: Math.max(0, this.pairUntil - Date.now()),
+          lastRouteClosure: this.lastRouteClosure,
+          grants: Array.from(this.grants.values()).map((g) => ({ peer: g.peer, rootCount: g.roots.length, write: g.write }))
         };
       case "pair-open":
-        this.pairUntil = Date.now() + 12e4;
+        this.pairUntil = Date.now() + PAIRING_MS;
+        for (const r of this.routes.values()) if (!r.owner) r.expires = this.pairUntil;
         return { expiresAt: this.pairUntil };
       case "pair-list":
         return {
+          pairingMode: "local-confirmation",
+          windowRequired: false,
+          pairingUntil: this.pairUntil,
+          pairingRemainingMs: Math.max(0, this.pairUntil - Date.now()),
           pending: Array.from(this.routes.entries()).filter(([, r]) => r.session?.ready && !r.owner).map(([routeId, r]) => ({
             routeId,
             fingerprint: r.session.fingerprint,
             peer: r.session.peerPublicKey,
             browserConfirmed: r.confirmed,
-            expiresAt: r.expires
+            expiresAt: r.expires,
+            remainingMs: Math.max(0, r.expires - Date.now()),
+            canApprove: r.confirmed && Date.now() <= r.expires
           }))
         };
       case "pair-approve": {
         const p = z5.object({
           fingerprint: z5.string().regex(/^[a-f0-9]{64}$/),
-          roots: z5.array(z5.string()).min(1).max(32),
-          write: z5.boolean().default(false)
+          roots: z5.array(z5.string()).min(1).max(32).optional(),
+          write: z5.boolean().optional(),
+          allowUnknown: z5.boolean().default(false)
         }).parse(m);
         const found = Array.from(this.routes.entries()).find(
           ([, r2]) => r2.session?.fingerprint === p.fingerprint
         );
-        if (!found || !found[1].confirmed || Date.now() > this.pairUntil || Date.now() > found[1].expires)
-          throw Error("PAIRING_EXPIRED_OR_UNCONFIRMED");
-        if (this.grants.size >= 256) throw Error("GRANT_LIMIT");
+        if (!found) throw new AdminError(this.expiredFingerprints.has(p.fingerprint) ? "PAIRING_ROUTE_EXPIRED" : "FINGERPRINT_NOT_FOUND");
         const [id2, r] = found;
+        if (r.owner) return { peer: r.owner, approved: true, alreadyApproved: true };
+        if (Date.now() > r.expires) throw new AdminError("PAIRING_ROUTE_EXPIRED");
+        if (!r.confirmed) throw new AdminError("BROWSER_NOT_CONFIRMED");
+        if (this.grants.size >= 256) throw new AdminError("GRANT_LIMIT");
         const peer = r.session.peerPublicKey;
+        const selectedRoots = p.roots ? await this.canonicalRoots(p.roots) : void 0;
+        let known = [];
+        if (p.write === void 0 || !p.roots) known = await this.discoverProjects();
+        const roots = selectedRoots ?? known;
+        if (!roots.length) throw new AdminError("NO_KNOWN_PROJECTS");
+        const unknown = roots.filter((root) => !known.includes(root));
+        if (unknown.length && p.write === void 0 && !p.allowUnknown) throw new AdminError("DIRECTORY_APPROVAL_REQUIRED");
+        const writeRoots = p.write === false ? [] : p.write || p.allowUnknown ? roots : roots.filter((root) => known.includes(root));
+        if (this.routes.get(id2) !== r || Date.now() > r.expires) throw new AdminError("PAIRING_ROUTE_EXPIRED");
         const grant = {
           peer,
-          roots: await Promise.all(p.roots.map((x) => realpath3(x))),
-          write: p.write
+          roots,
+          write: writeRoots.length > 0,
+          writeRoots
         };
-        this.grants.set(peer, grant);
-        try {
-          await atomicPrivate(
-            this.config.stateDir + "/grants.json",
-            Array.from(this.grants.values())
-          );
-        } catch (e) {
-          this.grants.delete(peer);
-          throw e;
-        }
+        await this.saveGrant(grant, () => this.routes.get(id2) === r && Date.now() <= r.expires);
         r.session.trust(p.fingerprint);
         r.owner = peer;
         this.pairUntil = 0;
@@ -2593,7 +2711,24 @@ var ClientDaemon = class {
           status: "ready",
           fingerprint: p.fingerprint
         });
-        return { peer, approved: true };
+        return { peer, approved: true, roots, write: grant.write, writeRoots };
+      }
+      case "projects-known":
+        return { roots: await this.discoverProjects() };
+      case "authorize": {
+        const p = z5.object({ peer: z5.string().optional(), roots: z5.array(z5.string()).min(1).max(32), allowUnknown: z5.boolean().default(false) }).parse(m);
+        const activePeers = [...new Set([...this.routes.values()].map((r) => r.owner).filter((peer2) => !!peer2))];
+        const peer = p.peer ?? (activePeers.length === 1 ? activePeers[0] : this.grants.size === 1 ? this.grants.keys().next().value : void 0);
+        if (!peer) throw new AdminError(this.grants.size ? "PEER_REQUIRED" : "NOT_PAIRED");
+        const old = this.grants.get(peer);
+        if (!old) throw new AdminError("NOT_PAIRED");
+        const roots = await this.canonicalRoots(p.roots), known = await this.discoverProjects();
+        if (!p.allowUnknown && roots.some((root) => !known.includes(root))) throw new AdminError("DIRECTORY_APPROVAL_REQUIRED");
+        const nextRoots = [.../* @__PURE__ */ new Set([...old.roots, ...roots])];
+        if (nextRoots.length > 256) throw new AdminError("GRANT_LIMIT");
+        const writeRoots = [.../* @__PURE__ */ new Set([...old.writeRoots ?? (old.write ? old.roots : []), ...roots])];
+        await this.saveGrant({ ...old, roots: nextRoots, write: true, writeRoots });
+        return { peer, approved: true, roots: nextRoots, writeRoots };
       }
       case "revoke": {
         const peer = z5.string().parse(m.peer);
@@ -2609,8 +2744,46 @@ var ClientDaemon = class {
         return { revoked: true };
       }
       default:
-        throw Error("ADMIN_COMMAND");
+        throw new AdminError("INVALID_ADMIN_REQUEST");
+    }
+  }
+  async canonicalRoots(roots) {
+    try {
+      return await Promise.all(roots.map(async (path) => {
+        const root = await realpath4(path);
+        if (!(await stat3(root)).isDirectory()) throw Error();
+        return root;
+      }));
+    } catch {
+      throw new AdminError("DIRECTORY_UNAVAILABLE");
+    }
+  }
+  async discoverProjects() {
+    try {
+      await this.ensureUpstream();
+      return await knownProjects(this.bridge.upstream, this.config.stateDir);
+    } catch (error) {
+      if (error instanceof AdminError) throw error;
+      throw new AdminError("CODEX_UNAVAILABLE");
+    }
+  }
+  async saveGrant(grant, stillValid) {
+    const values = new Map(this.grants);
+    values.set(grant.peer, grant);
+    try {
+      await atomicPrivate(this.config.stateDir + "/grants.json", [...values.values()]);
+    } catch {
+      throw new AdminError("GRANT_SAVE_FAILED");
+    }
+    if (stillValid && !stillValid()) {
+      try {
+        await atomicPrivate(this.config.stateDir + "/grants.json", [...this.grants.values()]);
+      } catch {
+        throw new AdminError("GRANT_SAVE_FAILED");
+      }
+      throw new AdminError("PAIRING_ROUTE_EXPIRED");
     }
+    this.grants.set(grant.peer, grant);
   }
   async startAdmin() {
     const path = this.config.stateDir + "/control.sock";
@@ -2641,7 +2814,7 @@ var ClientDaemon = class {
       if (e.code !== "ENOENT") throw e;
     }
     this.admin = createServer((socket) => {
-      socket.setTimeout(5e3, () => socket.destroy());
+      socket.setTimeout(6e4, () => socket.destroy());
       let data = "";
       socket.on("data", (chunk) => {
         data += chunk.toString();
@@ -2651,10 +2824,17 @@ var ClientDaemon = class {
         }
         if (!data.includes("\n")) return;
         socket.pause();
-        void Promise.resolve().then(() => this.adminCommand(JSON.parse(data))).then(
+        void Promise.resolve().then(() => {
+          const request = JSON.parse(data);
+          const result = this.adminQueue.then(() => this.adminCommand(request));
+          this.adminQueue = result.then(() => {
+          }, () => {
+          });
+          return result;
+        }).then(
           (result) => socket.end(JSON.stringify({ result }) + "\n"),
-          () => socket.end(
-            JSON.stringify({ error: "ADMIN_REQUEST_REJECTED" }) + "\n"
+          (error) => socket.end(
+            JSON.stringify(adminFailure(error)) + "\n"
           )
         );
       });
@@ -2690,7 +2870,7 @@ function control(stateDir, request) {
   return new Promise((resolve5, reject) => {
     const socket = createConnection2(join2(stateDir, "control.sock"));
     let data = "";
-    socket.setTimeout(5e3, () => socket.destroy(Error("ADMIN_TIMEOUT")));
+    socket.setTimeout(6e4, () => socket.destroy(Error("ADMIN_TIMEOUT: \u672C\u673A\u5904\u7406\u8D85\u65F6\uFF0C\u8BF7\u8FD0\u884C doctor \u540E\u91CD\u8BD5")));
     socket.on("connect", () => socket.write(JSON.stringify(request) + "\n"));
     socket.on("data", (chunk) => {
       data += chunk.toString();
@@ -2708,14 +2888,14 @@ function control(stateDir, request) {
 }
 
 // src/setup.ts
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { dirname as dirname3, join as join3, resolve as resolve3, basename as basename3 } from "node:path";
 import { mkdir as mkdir2, lstat as lstat3, writeFile as writeFile2, unlink as unlink2 } from "node:fs/promises";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { Writable } from "node:stream";
 function defaultConfigPath() {
-  return resolve3(process.env.WEB_CODEX_CLIENT_CONFIG ?? join3(process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config"), "web-codex-client", "config.json"));
+  return resolve3(process.env.WEB_CODEX_CLIENT_CONFIG ?? join3(process.env.XDG_CONFIG_HOME ?? join3(homedir3(), ".config"), "web-codex-client", "config.json"));
 }
 function validateToken(value) {
   const token = value.trim();
@@ -2891,37 +3071,39 @@ async function doctor(configPath, quiet = false, reportPath = join4(dirname4(con
 }
 
 // src/cli.ts
-var { values, positionals } = parseArgs({
-  allowPositionals: true,
-  options: {
-    config: { type: "string" },
-    state: { type: "string" },
-    socket: { type: "string" },
-    binary: { type: "string" },
-    standalone: { type: "boolean" },
-    transport: { type: "string" },
-    "codex-home": { type: "string" },
-    fingerprint: { type: "string" },
-    peer: { type: "string" },
-    root: { type: "string", multiple: true },
-    write: { type: "boolean" },
-    quiet: { type: "boolean" },
-    report: { type: "string" },
-    relay: { type: "string" },
-    "token-stdin": { type: "boolean" },
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" }
-  }
-});
-var command = positionals[0] ?? "help";
 async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      config: { type: "string" },
+      state: { type: "string" },
+      socket: { type: "string" },
+      binary: { type: "string" },
+      standalone: { type: "boolean" },
+      transport: { type: "string" },
+      "codex-home": { type: "string" },
+      fingerprint: { type: "string" },
+      peer: { type: "string" },
+      root: { type: "string", multiple: true },
+      write: { type: "boolean" },
+      "read-only": { type: "boolean" },
+      quiet: { type: "boolean" },
+      report: { type: "string" },
+      relay: { type: "string" },
+      "token-stdin": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const command = positionals[0] ?? "help";
+  if (values.write && values["read-only"]) throw Error("\u4E0D\u8981\u540C\u65F6\u4F7F\u7528 --write \u548C --read-only\uFF0C\u8BF7\u67E5\u770B --help\u3002");
   if (values.version) {
     console.log(JSON.parse(await readFile3(new URL("../package.json", import.meta.url), "utf8")).version);
     return;
   }
   if (command === "help" || values.help) {
     console.log(
-      "web-codex-client configure [--config FILE] [--relay wss://HOST --token-stdin] [--socket PATH]\nweb-codex-client doctor [--config FILE] [--quiet] [--report FILE]\nweb-codex-client run [--config FILE]\nweb-codex-client init [--state DIR]\nweb-codex-client status|pair-open|pair-list [--state DIR] [--config FILE]\nweb-codex-client pair-approve --fingerprint FULL_HASH --root PATH [--write] [--state DIR]\nweb-codex-client revoke --peer PUBLIC_KEY [--state DIR]\nweb-codex-client probe [--transport unix|proxy] [--socket PATH] [--binary PATH] [--quiet] [--report FILE] (default: unix; --standalone starts an isolated stdio server)\nDefault config: " + defaultConfigPath()
+      "web-codex-client configure [--config FILE] [--relay wss://HOST --token-stdin] [--socket PATH]\nweb-codex-client doctor [--config FILE] [--quiet] [--report FILE]\nweb-codex-client run [--config FILE]\nweb-codex-client pair [--root PATH] [--read-only] [--config FILE] (\u4EA4\u4E92\u6838\u5BF9\u6307\u7EB9\uFF1BCodex \u5DF2\u6709\u9879\u76EE\u9ED8\u8BA4\u8BFB\u5199)\nweb-codex-client authorize --root PATH [--peer PUBLIC_KEY] (\u65B0\u589E\u76EE\u5F55\uFF0C\u672C\u673A\u786E\u8BA4\u540E\u8BFB\u5199)\nweb-codex-client projects-known [--config FILE]\nweb-codex-client init [--state DIR]\nweb-codex-client status|pair-open|pair-list [--state DIR] [--config FILE]\nweb-codex-client pair-approve --fingerprint FULL_HASH [--root PATH] [--write|--read-only] [--state DIR]\nweb-codex-client revoke --peer PUBLIC_KEY [--state DIR]\nweb-codex-client probe [--transport unix|proxy] [--socket PATH] [--binary PATH] [--quiet] [--report FILE] (default: unix; --standalone starts an isolated stdio server)\nDefault config: " + defaultConfigPath()
     );
     return;
   }
@@ -2967,7 +3149,7 @@ async function main() {
     const daemon = new ClientDaemon(config, state.identity, state.grants);
     await daemon.start();
     console.log(
-      "Client running; use local status/pair-open/pair-list commands."
+      "Client running. \u5728\u7F51\u9875\u9009\u62E9\u8BBE\u5907\u540E\uFF0C\u53E6\u5F00\u7EC8\u7AEF\u6267\u884C web-codex-client pair \u6838\u5BF9\u5E76\u4FE1\u4EFB\u6D4F\u89C8\u5668\u3002"
     );
     let stopping = false;
     const stop = () => {
@@ -2979,21 +3161,55 @@ async function main() {
     process.on("SIGTERM", stop);
     return;
   }
-  if (!["status", "pair-open", "pair-list", "pair-approve", "revoke"].includes(command)) throw Error("UNKNOWN_COMMAND: use --help");
+  if (!["status", "pair", "pair-open", "pair-list", "pair-approve", "revoke", "authorize", "projects-known"].includes(command)) throw Error("UNKNOWN_COMMAND: use --help");
   const stateDir = values.state ? resolve4(values.state) : (await readConfig(configPath)).stateDir;
+  const send = async (request2) => {
+    const reply = await control(stateDir, request2);
+    if (reply.error) throw Error(reply.error + ": " + (reply.message ?? "\u672C\u673A Client \u62D2\u7EDD\u8BF7\u6C42\uFF0C\u8BF7\u68C0\u67E5 pair-list \u5E76\u786E\u8BA4 run \u4F7F\u7528\u540C\u4E00\u914D\u7F6E\u3002"));
+    return reply.result;
+  };
+  if (command === "pair") {
+    const list = await send({ command: "pair-list" });
+    const pending2 = list.pending.filter((p) => (p.remainingMs ?? p.expiresAt - Date.now()) > 0);
+    if (!pending2.length) throw Error("NO_PENDING_BROWSER: \u8BF7\u5148\u5728\u7F51\u9875\u9009\u62E9\u8BBE\u5907\u6216\u91CD\u65B0\u8FDE\u63A5\uFF0C\u7136\u540E\u518D\u6B21\u8FD0\u884C pair\u3002\u65E0\u9700\u5148\u6267\u884C pair-open\u3002");
+    for (let index = 0; index < pending2.length; index++) console.log(`${index + 1}. ${pending2[index].fingerprint}  \u7F51\u9875\u786E\u8BA4\uFF1A${pending2[index].browserConfirmed ? "\u662F" : "\u5426"}`);
+    const selected = pending2.length === 1 ? pending2[0] : pending2[Number(await question("\u9009\u62E9\u6D4F\u89C8\u5668\u7F16\u53F7\uFF1A")) - 1];
+    if (!selected) throw Error("INVALID_SELECTION");
+    console.log("\u8BF7\u6838\u5BF9\u7F51\u9875\u4E2D\u7684\u5B8C\u6574\u6307\u7EB9\uFF0C\u5E76\u5148\u70B9\u51FB\u7F51\u9875\u7684\u201C\u4E0E\u672C\u673A\u663E\u793A\u4E00\u81F4\u201D\u3002");
+    const access = values["read-only"] ? "\u53EA\u8BFB" : "\u8BFB\u5199";
+    console.log(values.root ? `\u5C06\u6388\u6743\u6307\u5B9A\u76EE\u5F55${access}\uFF1A` + values.root.map((root) => resolve4(root)).join(", ") : `\u786E\u8BA4\u540E\uFF0C\u4EC5\u5BF9\u672C\u673A Codex \u5DF2\u6709\u9879\u76EE\u6388\u4E88${access}\u6743\u9650\u3002`);
+    if ((await question("\u6307\u7EB9\u5B8C\u5168\u4E00\u81F4\u5E76\u4FE1\u4EFB\u6B64\u6D4F\u89C8\u5668\uFF1F\u8F93\u5165 yes\uFF1A")).trim().toLowerCase() !== "yes") throw Error("PAIRING_CANCELLED");
+    console.log("\u6B63\u5728\u8BFB\u53D6\u672C\u673A\u9879\u76EE\u5E76\u4FDD\u5B58\u6388\u6743\u2026");
+    const result2 = await send({ command: "pair-approve", fingerprint: selected.fingerprint, roots: values.root?.map((root) => resolve4(root)), ...values.root ? { write: !values["read-only"], allowUnknown: true } : values["read-only"] ? { write: false } : {} });
+    console.log(`\u5DF2\u4FE1\u4EFB\u6D4F\u89C8\u5668\uFF0C${result2.roots?.length ?? 0} \u4E2A\u9879\u76EE\u5DF2\u6388\u6743\u3002\u8FD4\u56DE\u7F51\u9875\u5373\u53EF\u4F7F\u7528\u3002`);
+    return;
+  }
+  if (command === "authorize") {
+    if (!values.root?.length) throw Error("ROOT_REQUIRED: \u8BF7\u7528 --root \u6307\u5B9A\u76EE\u5F55");
+    const request2 = { command, roots: values.root.map((root) => resolve4(root)), peer: values.peer };
+    let reply = await control(stateDir, request2);
+    if (reply.error === "DIRECTORY_APPROVAL_REQUIRED") {
+      console.log("Codex \u672A\u8BC6\u522B\u4E3A\u5DF2\u6709\u9879\u76EE\uFF0C\u9700\u8981\u4F60\u5728\u672C\u673A\u786E\u8BA4\u8BFB\u5199\u6388\u6743\uFF1A" + request2.roots.join(", "));
+      if ((await question("\u5141\u8BB8\u8BE5\u6D4F\u89C8\u5668\u8BBF\u95EE\u8FD9\u4E9B\u76EE\u5F55\uFF1F\u8F93\u5165 yes\uFF1A")).trim().toLowerCase() !== "yes") throw Error("AUTHORIZATION_CANCELLED");
+      reply = await control(stateDir, { ...request2, allowUnknown: true });
+    }
+    console.log(JSON.stringify(reply));
+    if (reply.error) process.exitCode = 1;
+    return;
+  }
   const request = {
     command,
     fingerprint: values.fingerprint,
     peer: values.peer,
-    roots: values.root,
-    write: values.write ?? false
+    roots: values.root?.map((root) => resolve4(root)),
+    write: values["read-only"] ? false : values.write
   };
   const result = await control(stateDir, request);
   console.log(JSON.stringify(result));
   if (result.error) process.exitCode = 1;
 }
 main().catch((e) => {
-  console.error(e?.code === "ENOENT" ? "CONFIG_OR_FILE_MISSING: run configure; check the configured paths" : e?.name === "ZodError" ? "CONFIG_INVALID: check the configuration fields" : e instanceof Error ? e.message : "CLIENT_FAILED");
+  console.error(e?.code?.startsWith("ERR_PARSE_ARGS") ? "\u53C2\u6570\u4E0D\u53D7\u652F\u6301\u6216\u683C\u5F0F\u65E0\u6548\uFF08\u6CA1\u6709 --admin \u53C2\u6570\uFF09\uFF1B\u8BF7\u67E5\u770B web-codex-client --help\u3002" : e?.code === "ENOENT" ? "CONFIG_OR_FILE_MISSING: run configure; check the configured paths" : e?.name === "ZodError" ? "CONFIG_INVALID: check the configuration fields" : e instanceof Error ? e.message : "CLIENT_FAILED");
   process.exitCode = 1;
 });
 //# sourceMappingURL=cli.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@landh93/web-codex-client",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.0-rc.2",
   "description": "Encrypted local Codex bridge with explicit browser pairing and workspace authorization",
   "license": "UNLICENSED",
   "bin": { "web-codex-client": "dist/cli.js" },