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

package/NPM_RELEASE.md

@@ -1,17 +1,16 @@
 # 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.3`，使用 `next` 标签。仅支持 Linux / Node.js 24；这是独立安装候选版，不代表公网、多人或真实模型执行已完成生产验收。`remote-wss-v1` 明确允许远端 WSS，继续使用固定 Noise 加密、TLS 校验及 Token 自动认证。项目尚未选定开源许可证，包暂保留 `UNLICENSED`；第三方代码许可见包内 `sdk/THIRD_PARTY_NOTICES.md`。
 
 ## 用户安装
 
 ```bash
 npm install -g @landh93/web-codex-client@next
 web-codex-client configure
-web-codex-client doctor
 web-codex-client run
 ```
 
-无需安装 pnpm、Rust 或构建工具。Codex 及其私有 Unix socket 必须在这台机器可用；本包不会安装或重启 Codex。交互配置依次输入 WSS Origin、Codex socket（回车使用默认值）、设备 token（隐藏输入）。设备 token 来自 Web 工作台的设备注册，**不是 npm 发布 token**。
+无需安装 pnpm、Rust 或构建工具。Codex 及其私有 Unix socket 必须在这台机器可用；本包不会安装或重启 Codex。交互配置只输入服务端 HTTPS/WSS 地址和连接 Token（隐藏输入）。Codex socket 自动发现；需要自定义时使用 `--socket`。网页输入同一个连接 Token，**不是 npm 发布 token**。
 
 配置默认位于 `${XDG_CONFIG_HOME:-$HOME/.config}/web-codex-client/config.json`，可用 `--config FILE` 或 `WEB_CODEX_CLIENT_CONFIG` 指定。状态目录和 token 文件分别为 0700/0600。重新配置保留身份和授权；运行中的 Client 需先停止再配置。升级包不改动用户配置；配置不会写入 npm 安装目录。
 
@@ -23,9 +22,13 @@ web-codex-client configure --relay wss://relay.example.com --token-stdin < /path
 
 `doctor` 检查配置及 token 权限、WASM 完整性、WSS 设备认证和 Codex 初始化，不读取历史或调用模型。已有本地 Client 在线时复用其状态，不抢占连接；没有运行时创建一次短暂的设备认证连接，**同一设备 token 不要在其他机器同时使用**。报告默认是配置目录中的 `doctor-report.json`，不含 token、私钥、历史或上游原始报错。支持 `--quiet`、`--report PRIVATE_PATH`。失败阶段落盘后退出非零。
 
-使用公开 CA 证书时通常无需额外设置；私有 CA 可在启动 Node 前设置 `NODE_EXTRA_CA_CERTS=/path/to/ca.pem`。禁止 `NODE_TLS_REJECT_UNAUTHORIZED=0`。Nginx 要正确代理 `/ws/v1/client`，token 经 Authorization 头发送。
+使用公开 CA 证书时通常无需额外设置；私有 CA 可在启动 Node 前设置 `NODE_EXTRA_CA_CERTS=/path/to/ca.pem`。禁止 `NODE_TLS_REJECT_UNAUTHORIZED=0`。Nginx 要正确代理 `/ws/v1/client`，Token 的 SHA-256 派生凭据经 Authorization 头发送，原始 Token 不发送给中继。
 
-Client 运行后，在另一终端执行 `web-codex-client pair-open`、`pair-list`，核对浏览器的完整指纹，再用 `pair-approve --fingerprint FULL_HASH --root /absolute/project` 授权。默认只读，需要执行任务时才加 `--write`。这些命令自动使用配置中的 stateDir；旧的 `--state` 用法仍有效。
+Client 运行后，在网页输入同一个 Token 即可：自动选择设备、建立端到端加密连接、加载项目与会话。打开会话即可输入消息；写租约自动取得和续期，只有另一个浏览器占用时才需要处理冲突。无需 `pair-open`、`pair`、指纹核对或“申请控制权”。网页刷新后在同一标签页自动重连；Token 只保存在该标签页的 sessionStorage，退出登录清除。
+
+默认授权本机 Codex 项目目录与活动/归档会话元数据识别出的已有项目读写，保留目录边界和 Codex 执行审批。授权在每次连接时重新读取，不持久保存临时浏览器身份。不同 token 对应不同设备，不能凭一个设备 Token 查看其他设备。
+
+此版本需要同时更新 Server 网关、网页和 Client（SDK rc.4）。旧 Server 不支持新的 Token 登录；应先部署 Server 再升级并重启 Client。原有设备 Token 可继续使用，无需重新注册。新部署的 Server 可通过 `CONNECTION_TOKEN_FILE=/private/path/token` 直接配置同一个 Token，无需先创建管理员账号；文件权限为 0600，Token 至少 32 个无空白字符。管理员口令和 `pairingMode:"manual"` 仅保留为兼容入口，不属于默认连接流程。
 
 后台常驻可使用 systemd 用户服务，将 `ExecStart` 设为实际安装的 `web-codex-client run --config /absolute/config.json`。npm 安装不会自动启用服务或打开配对窗口。
 
@@ -65,7 +68,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.3.tgz \
   --access public --tag next --ignore-scripts \
   --registry=https://registry.npmjs.org/ \
   --userconfig="$HOME/.config/web-codex-npm/npmrc"

package/README.md

@@ -13,13 +13,12 @@
 ```bash
 npm install -g @landh93/web-codex-client@next
 web-codex-client configure
-web-codex-client doctor
 web-codex-client run
 ```
 
-`configure` 交互输入 WSS 地址、Codex socket 和隐藏的设备 token，保存在用户配置目录。`doctor` 检查私有配置、WASM、WSS 认证和 Codex 初始化，失败退出非零；既有 Client 在线时不会抢占它的连接。支持 `--quiet`。安装和升级不会重启 Codex，也不会自动批准浏览器。
+`configure` 只需服务端 HTTPS/WSS 地址和连接 Token。启动后，在网页输入同一个 Token，就能查看项目、session 并发送对话；无需配对命令、指纹核对或申请控制权。Codex socket 自动发现，`doctor` 仅用于故障诊断。
 
-另开终端运行 `web-codex-client pair-open`，浏览器连接后用 `pair-list` 核对完整指纹，再 `pair-approve --fingerprint FULL_HASH --root /absolute/project`。配置、身份和授权独立于 npm 安装目录，升级时保留。完整安装、token 标准输入、证书、后台运行与发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
+已有 Codex 项目自动允许读写，执行审批和目录边界仍保留。配置、Token 和身份与 npm 安装目录分开存放，升级保留。Client rc.3 需要新版 Server 与 SDK rc.4；请先更新 Server，再升级 Client。完整安装和发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
 
 ## 安装、构建、自测
 
@@ -42,44 +41,15 @@ NODE_EXTRA_CA_CERTS=/tmp/web-codex-tls/cert.pem pnpm test:cli
 
 Chromium 已装在其他位置时可设置 `CHROMIUM_EXECUTABLE=/absolute/path/to/chrome`。本次实测使用 `/tmp/web-codex-browsers/chromium-1187/chrome-linux/chrome`。浏览器测试基于真实完成的四个阶段显示百分比、耗时、速率和 ETA；只使用合成数据。
 
-已发布 SDK：`artifacts/web-codex-bridge-sdk-0.1.0-rc.3.tgz`。Server 复制该文件到自己的 `vendor/` 后安装并固定锁文件，核对同名 `.sha256`。不要覆盖已发布文件，也不要通过 link: 指向本目录源码。构建后 `pnpm pack:sdk` 会拒绝覆盖已有版本；修改 SDK 需先调整 `scripts/build.mjs` 中的版本。
+已发布 SDK：`artifacts/web-codex-bridge-sdk-0.1.0-rc.4.tgz`。Server 复制该文件到自己的 `vendor/` 后安装并固定锁文件，核对同名 `.sha256`。不要覆盖已发布文件，也不要通过 link: 指向本目录源码。构建后 `pnpm pack:sdk` 会拒绝覆盖已有版本；修改 SDK 需先调整 `scripts/build.mjs` 中的版本。
 
-## 启动与本机授权
+## 连接与授权
 
-先取得 Server 提供的设备中继凭据和 WSS 地址。配置实例见 `deploy/config.example.json`。本机使用 `cryptoPolicy:"local-reviewed-v1"`，只允许回环 WSS；远端使用 `cryptoPolicy:"remote-wss-v1"`，示例见 `deploy/config.remote.example.json`。远端策略只明确放行 WSS 主机，不代表新增生产安全审查；TLS、固定 Noise 套件、完整指纹与本机授权照常执行。`experimentalCrypto:true` 保留兼容已有开发联调配置。工程审查与第三方审计边界见 [CRYPTO_REVIEW.md](./CRYPTO_REVIEW.md)。
+默认使用 Token 自动认证。Client 与网页分别持有相同 Token，通过 Noise 握手哈希和角色绑定的 HMAC 验证对端；中继只接收 Token 哈希凭据，不处理会话明文。Token 持有者可访问该设备已经在 Codex 中打开过的项目并读写。
 
-```bash
-mkdir -p ~/.config/web-codex-client
-chmod 700 ~/.config/web-codex-client
-cp deploy/config.example.json ~/.config/web-codex-client/config.json
-# 修改 relayUrl、upstream.socket；把 Server 给出的 token 写入 device-token 文件。
-chmod 600 ~/.config/web-codex-client/device-token
-node dist/cli.js init --state ~/.config/web-codex-client/state
-node dist/cli.js run --config ~/.config/web-codex-client/config.json
-```
-
-中继仅允许 WSS；不会禁用 TLS 验证。自签名开发证书使用 `NODE_EXTRA_CA_CERTS`。长期 token 不放 URL 或命令参数。设备身份私钥存于 0700 state 目录中的 0600 identity.json；这是磁盘明文身份文件，需要 OS/磁盘保护。授权表只含公钥、规范化工作区路径和读写权限，不含对话。
-
-另开本机终端进行配对：
-
-```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-list --state ~/.config/web-codex-client/state
-# 浏览器完成握手后，与本地 pair-list 核对完整的 64 位指纹。
-# 在可信浏览器点击确认，再在本机明确授予目录权限：
-node dist/cli.js pair-approve --state ~/.config/web-codex-client/state \
-  --fingerprint FULL_64_CHARACTER_FINGERPRINT --root /absolute/project
-# 需要通过 Codex 执行任务时，审批命令额外加 --write。
-node dist/cli.js revoke --state ~/.config/web-codex-client/state \
-  --peer BROWSER_PUBLIC_KEY_FROM_PAIR_LIST
-```
-
-配对窗口 120 秒，本机确认还要求浏览器已确认相同指纹。默认只读；`--write` 才允许执行和租约。撤销立即关闭该身份的会话并拒绝后续业务。浏览器身份默认仅存内存，刷新后重新配对；同一页面断线重连可以继续使用内存身份和固定公钥。
-
-`status` 分别返回 relayOnline、handshakes、authorizedSessions、codexAvailable。Codex 连接按第一次已授权请求惰性建立，因此仅中继上线时 codexAvailable 仍为 false。上游断线后下一次请求重连，旧 epoch/订阅失效。后台服务无有限总工作量，不显示伪造百分比。
+只允许 WSS 并验证证书；私有 CA 使用 `NODE_EXTRA_CA_CERTS`。浏览器在当前标签页保存 Token 以支持刷新自动重连，退出登录清除。已识别项目每次连接重新扫描，根目录、用户主目录和 Client 私有状态的父目录不会自动授权。
 
-`deploy/web-codex-client.service` 是 systemd --user 模板；调整 Node/项目绝对路径后自行安装启用。本次未修改或启用用户 systemd 服务。每个 stateDir 只运行一个实例；启动时拒绝已有活动控制 socket，并清理同用户拥有的失效 socket。
+旧的人工配对仅在配置显式设置 `pairingMode:"manual"` 时启用，不再是默认流程。每个 stateDir 只运行一个 Client；`status` 和 `doctor` 可诊断连接，`deploy/web-codex-client.service` 提供后台运行模板。
 
 ## Codex 接入与只读诊断
 

package/dist/cli.js

@@ -83,7 +83,7 @@ var CodexRpc = class _CodexRpc extends EventEmitter {
         this.ws.once("open", resolve5);
         this.ws.once("error", reject);
       });
-      this.ws.on("message", (data) => this.parse(data.toString()));
+      this.ws.on("message", (data2) => this.parse(data2.toString()));
       this.ws.on("error", () => this.fail());
       this.ws.on("close", () => this.fail());
       return;
@@ -124,10 +124,10 @@ var CodexRpc = class _CodexRpc extends EventEmitter {
         this.emit(m.id === void 0 ? "notification" : "serverRequest", m);
         return;
       }
-      const key = String(m.id);
-      const p = this.pending.get(key);
+      const key2 = String(m.id);
+      const p = this.pending.get(key2);
       if (!p) return;
-      this.pending.delete(key);
+      this.pending.delete(key2);
       clearTimeout(p.timer);
       if (m.error) p.reject(new RpcError(m.error.code, m.error.message));
       else p.resolve(m.result);
@@ -137,14 +137,14 @@ var CodexRpc = class _CodexRpc extends EventEmitter {
   }
   send(value) {
     if (this.ended) throw new BridgeError("UPSTREAM_UNAVAILABLE");
-    const data = JSON.stringify(value);
+    const data2 = JSON.stringify(value);
     if (this.ws) {
       if (this.ws.bufferedAmount > 1024 * 1024) throw new BridgeError("BUSY");
-      this.ws.send(data);
+      this.ws.send(data2);
     } else {
       if (!this.child || this.child.stdin.writableLength > 1024 * 1024)
         throw new BridgeError("BUSY");
-      this.child.stdin.write(data + "\n");
+      this.child.stdin.write(data2 + "\n");
     }
   }
   call(method, params) {
@@ -603,8 +603,8 @@ async function __wbg_load(module, imports) {
         }
       }
     }
-    const bytes = await module.arrayBuffer();
-    return await WebAssembly.instantiate(bytes, imports);
+    const bytes2 = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes2, imports);
   } else {
     const instance = await WebAssembly.instantiate(module, imports);
     if (instance instanceof WebAssembly.Instance) {
@@ -750,10 +750,10 @@ function aad(f) {
 var WASM_SHA256 = "1ac97442f8b0fd8ef20b31d46d2e4cbc30b6d877346f0cf2438eb08026330490";
 
 // sdk/src/noise-provider.ts
-async function initializeNoise(bytes) {
-  const digest = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes))), (n) => n.toString(16).padStart(2, "0")).join("");
+async function initializeNoise(bytes2) {
+  const digest = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes2))), (n) => n.toString(16).padStart(2, "0")).join("");
   if (digest !== WASM_SHA256) throw Error("CRYPTO_ARTIFACT_MISMATCH");
-  initSync({ module: bytes });
+  initSync({ module: bytes2 });
   return {
     constants: { NOISE_DH_CURVE25519: 1, NOISE_ROLE_INITIATOR: 1, NOISE_ROLE_RESPONDER: 2, NOISE_ACTION_WRITE_MESSAGE: 1, NOISE_ACTION_READ_MESSAGE: 2, NOISE_ACTION_SPLIT: 3 },
     CreateKeyPair(algorithm) {
@@ -771,9 +771,9 @@ async function initializeNoise(bytes) {
         if (suite !== SUITE || ![1, 2].includes(role)) throw Error("UNSUPPORTED_SUITE");
       }
       inner;
-      Initialize(prologue2, key) {
+      Initialize(prologue2, key2) {
         if (this.inner) throw Error("HANDSHAKE_STATE");
-        this.inner = new Handshake(this.role === 1, prologue2, key);
+        this.inner = new Handshake(this.role === 1, prologue2, key2);
       }
       get state() {
         if (!this.inner) throw Error("HANDSHAKE_STATE");
@@ -929,7 +929,8 @@ var messageSchema = z2.union([
   z2.strictObject({
     kind: z2.literal("pairing"),
     status: z2.enum(["pending", "confirmed", "ready", "rejected"]),
-    fingerprint: z2.string().regex(/^[a-f0-9]{64}$/)
+    fingerprint: z2.string().regex(/^[a-f0-9]{64}$/),
+    proof: z2.string().regex(/^[a-f0-9]{64}$/).optional()
   }),
   z2.strictObject({
     kind: z2.literal("ack"),
@@ -944,9 +945,9 @@ function parseMessage(value) {
   return m;
 }
 function encodeMessage(value) {
-  const bytes = new TextEncoder().encode(JSON.stringify(parseMessage(value)));
-  if (bytes.length > MAX_MESSAGE_BYTES) throw Error("RESOURCE_TOO_LARGE");
-  return bytes;
+  const bytes2 = new TextEncoder().encode(JSON.stringify(parseMessage(value)));
+  if (bytes2.length > MAX_MESSAGE_BYTES) throw Error("RESOURCE_TOO_LARGE");
+  return bytes2;
 }
 var opaque = z2.object({ id: z2.string() }).passthrough();
 var projectDto = z2.strictObject({
@@ -1168,8 +1169,8 @@ var SecureSession = class {
     this.guard();
     if (!this.ready || !this.trusted && message.kind !== "pairing")
       throw Error("NOT_PAIRED");
-    const bytes = encodeMessage(message);
-    const total = Math.ceil(bytes.length / CHUNK_BYTES);
+    const bytes2 = encodeMessage(message);
+    const total = Math.ceil(bytes2.length / CHUNK_BYTES);
     const id2 = randomId();
     for (let index = 0; index < total; index++) {
       this.guard();
@@ -1178,9 +1179,9 @@ var SecureSession = class {
           id: id2,
           index,
           total,
-          size: bytes.length,
+          size: bytes2.length,
           data: b64(
-            bytes.subarray(index * CHUNK_BYTES, (index + 1) * CHUNK_BYTES)
+            bytes2.subarray(index * CHUNK_BYTES, (index + 1) * CHUNK_BYTES)
           )
         })
       );
@@ -1268,6 +1269,23 @@ var SecureSession = class {
   }
 };
 
+// sdk/src/token.ts
+var bytes = (value) => new TextEncoder().encode(value);
+async function relayCredential(token) {
+  return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes(token))));
+}
+var data = (fingerprint, role) => bytes(JSON.stringify(["web-codex-token-v1", role, fingerprint]));
+async function key(token) {
+  return crypto.subtle.importKey("raw", bytes(token), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+}
+async function tokenProof(token, fingerprint, role) {
+  return hex(new Uint8Array(await crypto.subtle.sign("HMAC", await key(token), data(fingerprint, role))));
+}
+async function verifyTokenProof(token, fingerprint, role, proof) {
+  if (!proof || !/^[a-f0-9]{64}$/.test(proof)) return false;
+  return crypto.subtle.verify("HMAC", await key(token), Uint8Array.from(proof.match(/../g), (value) => parseInt(value, 16)), data(fingerprint, role));
+}
+
 // sdk/src/node.ts
 var pending;
 function loadNoise() {
@@ -1288,6 +1306,7 @@ var configSchema = z4.strictObject({
     return u.protocol === "wss:" && !u.username && !u.password && !u.search && !u.hash && u.pathname === "/";
   }, "Relay requires WSS without URL credentials"),
   deviceTokenFile: z4.string(),
+  pairingMode: z4.enum(["token", "manual"]).optional(),
   stateDir: z4.string(),
   experimentalCrypto: z4.literal(true).optional(),
   cryptoPolicy: z4.enum(["local-reviewed-v1", "remote-wss-v1"]).optional(),
@@ -1336,10 +1355,10 @@ async function loadState(dir) {
   const path = dir + "/identity.json";
   let identity;
   try {
-    const data = JSON.parse(await privateRead(path));
+    const data2 = JSON.parse(await privateRead(path));
     identity = {
-      privateKey: unb64(data.privateKey),
-      publicKey: unb64(data.publicKey)
+      privateKey: unb64(data2.privateKey),
+      publicKey: unb64(data2.publicKey)
     };
     if (identity.privateKey.length !== 32 || identity.publicKey.length !== 32)
       throw Error("IDENTITY");
@@ -1356,15 +1375,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 +1396,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
@@ -1491,15 +1513,15 @@ var FileResources = class {
     };
     try {
       await verify();
-      const bytes = Buffer.alloc(Math.min(length, h.size - offset));
-      const { bytesRead } = await h.fd.read(bytes, 0, bytes.length, offset);
+      const bytes2 = Buffer.alloc(Math.min(length, h.size - offset));
+      const { bytesRead } = await h.fd.read(bytes2, 0, bytes2.length, offset);
       await verify();
-      if (bytesRead !== bytes.length) throw new BridgeError("RESOURCE_CHANGED");
+      if (bytesRead !== bytes2.length) throw new BridgeError("RESOURCE_CHANGED");
       return {
         resourceId: id2,
         offset,
-        data: bytes.toString("base64url"),
-        sha256: createHash("sha256").update(bytes).digest("hex"),
+        data: bytes2.toString("base64url"),
+        sha256: createHash("sha256").update(bytes2).digest("hex"),
         eof: offset + bytesRead === h.size
       };
     } catch (e) {
@@ -1569,9 +1591,9 @@ var Dedup = class {
   bytes = 0;
   entries = /* @__PURE__ */ new Map();
   run(owner, id2, body, fn) {
-    const key = owner + ":" + id2;
+    const key2 = owner + ":" + id2;
     const digest = createHash2("sha256").update(JSON.stringify(body)).digest("hex");
-    const old = this.entries.get(key);
+    const old = this.entries.get(key2);
     if (old) {
       if (old.digest !== digest) throw new BridgeError("REQUEST_ID_REUSED");
       return old.promise;
@@ -1582,16 +1604,16 @@ var Dedup = class {
         "Dedup budget exhausted; reconnect after a deliberate client restart and reconcile outcomes"
       );
     const promise = Promise.resolve().then(fn).then((result) => {
-      const bytes = Buffer.byteLength(JSON.stringify(result));
-      if (bytes > 1024 * 1024 || this.bytes + bytes > 8 * 1024 * 1024)
+      const bytes2 = Buffer.byteLength(JSON.stringify(result));
+      if (bytes2 > 1024 * 1024 || this.bytes + bytes2 > 8 * 1024 * 1024)
         throw new BridgeError(
           "OUTCOME_UNKNOWN",
           "Write executed; response exceeds retained dedup budget; reconcile upstream"
         );
-      this.bytes += bytes;
+      this.bytes += bytes2;
       return result;
     });
-    this.entries.set(key, { digest, promise, at: Date.now() });
+    this.entries.set(key2, { digest, promise, at: Date.now() });
     return promise;
   }
 };
@@ -1772,6 +1794,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:")) {
@@ -1812,12 +1839,12 @@ var Bridge = class {
       const h = this.histories.get(p.cursor);
       if (!h || h.owner !== owner || h.thread !== p.threadId || h.kind !== method + ":" + (p.turnId ?? "") || h.expires < Date.now())
         throw new BridgeError("RESYNC_REQUIRED");
-      const data2 = h.data.slice(h.offset, h.offset + p.limit);
-      h.offset += data2.length;
+      const data3 = h.data.slice(h.offset, h.offset + p.limit);
+      h.offset += data3.length;
       this.histories.delete(p.cursor);
       const nextCursor2 = h.offset < h.data.length ? "fallback:" + randomUUID4() : null;
       if (nextCursor2) this.histories.set(nextCursor2, h);
-      return { data: data2, nextCursor: nextCursor2, source: "bounded-fallback" };
+      return { data: data3, nextCursor: nextCursor2, source: "bounded-fallback" };
     }
     try {
       const r2 = await this.upstream.call(
@@ -1848,31 +1875,31 @@ var Bridge = class {
       threadId: p.threadId,
       includeTurns: true
     });
-    const bytes = Buffer.byteLength(JSON.stringify(r));
-    if (bytes > 8 * 1024 * 1024 || Array.from(this.histories.values()).reduce((n, h) => n + h.bytes, 0) + bytes > 8 * 1024 * 1024)
+    const bytes2 = Buffer.byteLength(JSON.stringify(r));
+    if (bytes2 > 8 * 1024 * 1024 || Array.from(this.histories.values()).reduce((n, h) => n + h.bytes, 0) + bytes2 > 8 * 1024 * 1024)
       throw new BridgeError(
         "RESOURCE_TOO_LARGE",
         "Legacy history exceeds bounded fallback budget"
       );
     const turns = (r.thread.turns ?? []).slice().reverse();
-    const data = method === "turns.list" ? turns.map((t) => ({ ...t, items: [] })) : turns.filter((t) => !p.turnId || p.turnId === t.id).flatMap(
+    const data2 = method === "turns.list" ? turns.map((t) => ({ ...t, items: [] })) : turns.filter((t) => !p.turnId || p.turnId === t.id).flatMap(
       (t) => (t.items ?? []).slice().reverse().map((item) => ({ turnId: t.id, item }))
     );
-    const nextCursor = data.length > p.limit ? "fallback:" + randomUUID4() : null;
+    const nextCursor = data2.length > p.limit ? "fallback:" + randomUUID4() : null;
     if (nextCursor) {
       if (this.histories.size >= 32) throw new BridgeError("BUSY");
       this.histories.set(nextCursor, {
         owner,
         thread: p.threadId,
         kind: method + ":" + (p.turnId ?? ""),
-        data,
+        data: data2,
         offset: p.limit,
-        bytes,
+        bytes: bytes2,
         expires: Date.now() + 6e4
       });
     }
     return {
-      data: data.slice(0, p.limit),
+      data: data2.slice(0, p.limit),
       nextCursor,
       source: "bounded-fallback"
     };
@@ -1881,25 +1908,25 @@ var Bridge = class {
    * Buffer at most one turn; never load a whole long conversation for this path. */
   async turnItems(owner, p, previous) {
     const h = previous ? { ...previous } : { owner, thread: p.threadId, kind: "items.list:" + (p.turnId ?? ""), data: [], offset: 0, bytes: 0, expires: Date.now() + 6e4 };
-    const data = [];
+    const data2 = [];
     let pages = 0;
     const visited = /* @__PURE__ */ new Set();
-    while (data.length < p.limit) {
-      const part = h.data.slice(h.offset, h.offset + p.limit - data.length);
-      data.push(...part);
+    while (data2.length < p.limit) {
+      const part = h.data.slice(h.offset, h.offset + p.limit - data2.length);
+      data2.push(...part);
       h.offset += part.length;
-      if (data.length >= p.limit || h.upstream === null || pages >= 10) break;
+      if (data2.length >= p.limit || h.upstream === null || pages >= 10) break;
       if (h.upstream && visited.has(h.upstream)) throw new BridgeError("RESYNC_REQUIRED");
       if (h.upstream) visited.add(h.upstream);
       const r = await this.upstream.call("thread/turns/list", { threadId: p.threadId, cursor: h.upstream, limit: 1, sortDirection: "desc", itemsView: "full" });
       pages++;
-      const bytes = Buffer.byteLength(JSON.stringify(r));
+      const bytes2 = Buffer.byteLength(JSON.stringify(r));
       const retained = Array.from(this.histories.values()).reduce((sum, entry) => sum + (entry === previous ? 0 : entry.bytes), 0);
-      if (bytes > 8 * 1024 * 1024 || retained + bytes > 8 * 1024 * 1024) throw new BridgeError("RESOURCE_TOO_LARGE");
+      if (bytes2 > 8 * 1024 * 1024 || retained + bytes2 > 8 * 1024 * 1024) throw new BridgeError("RESOURCE_TOO_LARGE");
       if (r.data.some((turn) => turn.itemsView && turn.itemsView !== "full")) throw new BridgeError("UNSUPPORTED_CAPABILITY", "Upstream did not return full turn items");
       h.data = r.data.filter((turn) => !p.turnId || turn.id === p.turnId).flatMap((turn) => (turn.items ?? []).slice().reverse().map((item) => ({ turnId: turn.id, item })));
       h.offset = 0;
-      h.bytes = bytes;
+      h.bytes = bytes2;
       h.upstream = r.nextCursor ?? null;
     }
     const more = h.offset < h.data.length || h.upstream !== null;
@@ -1907,7 +1934,7 @@ var Bridge = class {
     if (previous) this.histories.delete(p.cursor);
     const nextCursor = more ? "turn-items:" + randomUUID4() : null;
     if (nextCursor) this.histories.set(nextCursor, h);
-    return { data, nextCursor, source: "bounded-fallback" };
+    return { data: data2, nextCursor, source: "bounded-fallback" };
   }
   async handle(owner, message) {
     if (message.kind === "serverResponse") {
@@ -1979,7 +2006,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)
@@ -1999,12 +2029,12 @@ var Bridge = class {
           const r = await this.upstream.call("project/list", p);
           if (!p.cursor && r.data.length === 0 && !r.nextCursor)
             throw new RpcError(-32601, "Empty project catalog; discover history roots");
-          const data = [];
+          const data2 = [];
           for (const item of r.data) {
             for (const root of item.roots ?? []) {
               try {
                 const cwd = await authorizedPath(g.roots, root.path);
-                data.push({
+                data2.push({
                   id: item.id,
                   name: item.name,
                   cwd,
@@ -2015,10 +2045,10 @@ var Bridge = class {
               }
             }
           }
-          return { data, nextCursor: r.nextCursor ?? null };
+          return { data: data2, nextCursor: r.nextCursor ?? null };
         } catch (e) {
           if (!unsupported(e)) throw e;
-          const data = [];
+          const data2 = [];
           const seen = new Set(previous?.seen);
           let upstreamCursor = previous?.upstream ?? p.cursor;
           const visited = /* @__PURE__ */ new Set();
@@ -2029,7 +2059,7 @@ var Bridge = class {
             }
             const r = await this.upstream.call("thread/list", {
               cursor: upstreamCursor,
-              limit: (p.limit ?? 50) - data.length,
+              limit: (p.limit ?? 50) - data2.length,
               useStateDbOnly: true,
               sourceKinds: sources,
               sortKey: "updated_at",
@@ -2044,7 +2074,7 @@ var Bridge = class {
               }
               if (!seen.has(cwd)) {
                 seen.add(cwd);
-                data.push({
+                data2.push({
                   id: "cwd:" + Buffer.from(cwd).toString("base64url"),
                   name: basename2(cwd),
                   cwd,
@@ -2053,7 +2083,7 @@ var Bridge = class {
               }
             }
             upstreamCursor = r.nextCursor ?? void 0;
-            if (!upstreamCursor || data.length >= (p.limit ?? 50)) break;
+            if (!upstreamCursor || data2.length >= (p.limit ?? 50)) break;
           }
           if (seen.size > 1024 || this.projectCursors.size >= 128)
             throw new BridgeError("RESOURCE_TOO_LARGE");
@@ -2066,7 +2096,7 @@ var Bridge = class {
               seen,
               expires: Date.now() + 6e4
             });
-          return { data, nextCursor };
+          return { data: data2, nextCursor };
         }
       }
       case "projects.read":
@@ -2083,14 +2113,14 @@ var Bridge = class {
           sortKey: "updated_at",
           sortDirection: "desc"
         });
-        const data = [];
+        const data2 = [];
         for (const t of r.data)
           try {
             await authorizedPath(g.roots, t.cwd);
-            data.push(t);
+            data2.push(t);
           } catch {
           }
-        return { data, nextCursor: r.nextCursor ?? null };
+        return { data: data2, nextCursor: r.nextCursor ?? null };
       }
       case "threads.read":
         return { thread: await this.thread(owner, p.threadId) };
@@ -2124,6 +2154,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 +2268,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 +2328,84 @@ var Bridge = class {
   }
 };
 
+// src/admin-errors.ts
+var adminMessages = {
+  TOKEN_PAIRING_AUTOMATIC: "\u4F7F\u7528\u4E0E Client \u76F8\u540C\u7684 Token \u767B\u5F55\u7F51\u9875\u5373\u53EF\uFF0C\u65E0\u9700\u8FD0\u884C pair \u6216 pair-approve\u3002",
+  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,18 +2419,24 @@ var ClientDaemon = class {
   stopped = false;
   routes = /* @__PURE__ */ new Map();
   pairUntil = 0;
+  lastRouteClosure;
+  expiredFingerprints = /* @__PURE__ */ new Set();
   admin;
+  adminQueue = Promise.resolve();
   timer;
   retry;
   attempts = 0;
   noise;
   token = "";
+  relayToken = "";
+  tokenPeers = /* @__PURE__ */ new Set();
   alive = true;
   connecting;
   async start() {
     this.noise = await loadNoise();
     this.token = (await privateRead(this.config.deviceTokenFile)).trim();
     if (!this.token || /[\r\n]/.test(this.token)) throw Error("DEVICE_TOKEN");
+    this.relayToken = await relayCredential(this.token);
     await this.startAdmin();
     this.connect();
     this.timer = setInterval(() => {
@@ -2333,7 +2448,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();
   }
@@ -2358,7 +2473,7 @@ var ClientDaemon = class {
   connect() {
     if (this.stopped) return;
     this.ws = new WebSocket2(new URL("/ws/v1/client", this.config.relayUrl), {
-      headers: { Authorization: "Bearer " + this.token },
+      headers: { Authorization: this.config.pairingMode === "manual" ? "Bearer " + this.token : "TokenHash " + this.relayToken },
       perMessageDeflate: false,
       maxPayload: 128 * 1024,
       handshakeTimeout: 1e4
@@ -2370,9 +2485,9 @@ var ClientDaemon = class {
     this.ws.on("pong", () => this.alive = true);
     this.ws.on("error", () => {
     });
-    this.ws.on("message", (data) => {
+    this.ws.on("message", (data2) => {
       try {
-        this.receive(data.toString());
+        this.receive(data2.toString());
       } catch {
         this.ws?.close(1008, "Protocol violation");
       }
@@ -2406,7 +2521,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 +2531,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;
@@ -2448,7 +2563,14 @@ var ClientDaemon = class {
         if (reply) this.ws.send(encodeFrame(reply));
         if (r.session.ready) {
           const grant = this.grants.get(r.session.peerPublicKey);
-          if (grant) {
+          if (this.config.pairingMode !== "manual") {
+            this.send(frame.routeId, {
+              kind: "pairing",
+              status: "pending",
+              fingerprint: r.session.fingerprint,
+              proof: await tokenProof(this.token, r.session.fingerprint, "client")
+            });
+          } else if (grant) {
             r.session.trust(r.session.fingerprint);
             r.owner = grant.peer;
             this.send(frame.routeId, {
@@ -2457,8 +2579,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",
@@ -2471,28 +2591,47 @@ var ClientDaemon = class {
       const message = r.session.open(frame);
       if (!message) return;
       if (message.kind === "pairing") {
-        if (message.fingerprint !== r.session.fingerprint || message.status !== "confirmed" || Date.now() > r.expires)
+        if (r.confirmed || message.fingerprint !== r.session.fingerprint || message.status !== "confirmed" || Date.now() > r.expires)
           throw Error("PAIRING_MISMATCH");
+        if (this.config.pairingMode !== "manual") {
+          if (!await verifyTokenProof(this.token, r.session.fingerprint, "browser", message.proof)) throw new BridgeError("TOKEN_AUTH_FAILED");
+          const roots = await this.discoverProjects();
+          if (this.routes.get(frame.routeId) !== r || Date.now() > r.expires) return;
+          const peer = r.session.peerPublicKey;
+          this.grants.set(peer, { peer, roots, write: true, writeRoots: roots });
+          this.tokenPeers.add(peer);
+          r.session.trust(r.session.fingerprint);
+          r.owner = peer;
+          this.send(frame.routeId, { kind: "pairing", status: "ready", fingerprint: r.session.fingerprint });
+        }
         r.confirmed = true;
         return;
       }
       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);
     if (!r?.session?.ready) return;
-    const bytes = Buffer.byteLength(JSON.stringify(message));
-    if (r.bytes + bytes > 1024 * 1024 || this.ws.bufferedAmount > 4 * 1024 * 1024) {
+    const bytes2 = Buffer.byteLength(JSON.stringify(message));
+    if (r.bytes + bytes2 > 1024 * 1024 || this.ws.bufferedAmount > 4 * 1024 * 1024) {
       this.closeRoute(id2);
       return;
     }
     r.out.push(message);
-    r.bytes += bytes;
+    r.bytes += bytes2;
     if (!r.sending) void this.flush(id2, r);
   }
   async flush(id2, r) {
@@ -2518,14 +2657,21 @@ 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 = [];
-    if (r.owner && !Array.from(this.routes.values()).some((x) => x.owner === r.owner))
+    if (r.owner && !Array.from(this.routes.values()).some((x) => x.owner === r.owner)) {
       this.bridge?.disconnect(r.owner);
+      if (this.tokenPeers.delete(r.owner)) this.grants.delete(r.owner);
+    }
     if (notify) this.control({ type: "route.close", routeId: id2 });
   }
   async adminCommand(value) {
@@ -2541,50 +2687,66 @@ var ClientDaemon = class {
           authorizedSessions: Array.from(this.routes.values()).filter(
             (r) => r.owner
           ).length,
-          pairingUntil: this.pairUntil
+          pairingUntil: this.pairUntil,
+          pairingMode: this.config.pairingMode === "manual" ? "local-confirmation" : "token",
+          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: this.config.pairingMode === "manual" ? "local-confirmation" : "token",
+          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": {
+        if (this.config.pairingMode !== "manual") throw new AdminError("TOKEN_PAIRING_AUTOMATIC");
         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 +2755,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,9 +2788,47 @@ 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";
     try {
@@ -2641,20 +2858,27 @@ var ClientDaemon = class {
       if (e.code !== "ENOENT") throw e;
     }
     this.admin = createServer((socket) => {
-      socket.setTimeout(5e3, () => socket.destroy());
-      let data = "";
+      socket.setTimeout(6e4, () => socket.destroy());
+      let data2 = "";
       socket.on("data", (chunk) => {
-        data += chunk.toString();
-        if (data.length > 16384) {
+        data2 += chunk.toString();
+        if (data2.length > 16384) {
           socket.destroy();
           return;
         }
-        if (!data.includes("\n")) return;
+        if (!data2.includes("\n")) return;
         socket.pause();
-        void Promise.resolve().then(() => this.adminCommand(JSON.parse(data))).then(
+        void Promise.resolve().then(() => {
+          const request = JSON.parse(data2);
+          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"
           )
         );
       });
@@ -2689,17 +2913,17 @@ import { join as join2 } from "node:path";
 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")));
+    let data2 = "";
+    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();
-      if (Buffer.byteLength(data) > 65536) socket.destroy(Error("ADMIN_TOO_LARGE"));
+      data2 += chunk.toString();
+      if (Buffer.byteLength(data2) > 65536) socket.destroy(Error("ADMIN_TOO_LARGE"));
     });
     socket.on("error", reject);
     socket.on("end", () => {
       try {
-        resolve5(JSON.parse(data));
+        resolve5(JSON.parse(data2));
       } catch {
         reject(Error("ADMIN_INVALID_RESPONSE"));
       }
@@ -2708,14 +2932,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();
@@ -2756,6 +2980,13 @@ async function question(prompt, secret = false) {
 async function saveConfiguration(path, relayUrl, token, socket) {
   path = resolve3(path);
   const directory = dirname3(path);
+  try {
+    const url = new URL(relayUrl);
+    if (url.protocol === "https:") url.protocol = "wss:";
+    relayUrl = url.toString();
+  } catch {
+    throw Error("RELAY_URL_INVALID: use an HTTPS or WSS server address");
+  }
   const parsed = configSchema.safeParse({ relayUrl, deviceTokenFile: "placeholder", stateDir: "./state", cryptoPolicy: "remote-wss-v1", upstream: { mode: "unix", ...socket ? { socket: resolve3(socket) } : {} } });
   if (!parsed.success) throw Error("RELAY_URL_INVALID: use a WSS origin without path, credentials, query or fragment");
   token = validateToken(token);
@@ -2801,10 +3032,11 @@ async function saveConfiguration(path, relayUrl, token, socket) {
 import { join as join4, dirname as dirname4 } from "node:path";
 import WebSocket3 from "ws";
 import { SingleBar, Presets } from "cli-progress";
-async function authenticateRelay(relayUrl, token) {
+async function authenticateRelay(relayUrl, token, manual = false) {
+  const credential = manual ? "Bearer " + token : "TokenHash " + await relayCredential(token);
   await new Promise((resolve5, reject) => {
     const ws = new WebSocket3(new URL("/ws/v1/client", relayUrl), {
-      headers: { Authorization: "Bearer " + token },
+      headers: { Authorization: credential },
       perMessageDeflate: false,
       maxPayload: 4096,
       handshakeTimeout: 1e4
@@ -2825,9 +3057,9 @@ async function authenticateRelay(relayUrl, token) {
       finish(Error(response.statusCode === 401 ? "RELAY_UNAUTHORIZED: replace the device token" : "RELAY_HTTP_REJECTED: check the reverse proxy"));
     });
     ws.on("close", () => finish(Error("RELAY_CLOSED")));
-    ws.on("message", (bytes) => {
+    ws.on("message", (bytes2) => {
       try {
-        const frame = JSON.parse(bytes.toString());
+        const frame = JSON.parse(bytes2.toString());
         if (frame.type === "device.ready" && typeof frame.deviceId === "string") finish();
         else finish(Error("RELAY_PROTOCOL"));
       } catch {
@@ -2874,7 +3106,7 @@ async function doctor(configPath, quiet = false, reportPath = join4(dirname4(con
       } catch (e) {
         if (!["ENOENT", "ECONNREFUSED"].includes(e.code ?? "")) throw e;
       }
-      await authenticateRelay(config.relayUrl, token);
+      await authenticateRelay(config.relayUrl, token, config.pairingMode === "manual");
     });
     await check("Codex initialization (no model request)", async () => {
       const rpc = await CodexRpc.connect(config.upstream);
@@ -2891,37 +3123,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 https://HOST --token-stdin]\nweb-codex-client run [--config FILE]\nweb-codex-client status [--config FILE]\nweb-codex-client doctor [--config FILE] [--quiet]\n\n\u914D\u7F6E\u670D\u52A1\u7AEF\u5730\u5740\u548C Token\uFF0C\u8FD0\u884C Client\uFF1B\u7F51\u9875\u4F7F\u7528\u540C\u4E00\u4E2A Token \u5373\u53EF\u8BBF\u95EE\u9879\u76EE\u4E0E\u5BF9\u8BDD\u3002\nDefault config: " + defaultConfigPath()
     );
     return;
   }
@@ -2929,12 +3163,12 @@ async function main() {
   if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === "0") throw Error("TLS_VERIFICATION_REQUIRED: remove NODE_TLS_REJECT_UNAUTHORIZED=0");
   const configPath = resolve4(values.config ?? defaultConfigPath());
   if (command === "configure") {
-    const relay = values.relay ?? (await question("Relay WSS origin (e.g. wss://relay.example.com): ")).trim();
+    const relay = values.relay ?? (await question("\u670D\u52A1\u7AEF\u5730\u5740\uFF08https:// \u6216 wss://\uFF09\uFF1A")).trim();
     if (values["token-stdin"] && !values.relay) throw Error("--token-stdin requires --relay");
-    const socket = values.socket ?? (values["token-stdin"] ? void 0 : (await question("Codex socket [" + controlSocketPath({ mode: "unix" }) + "]: ")).trim() || void 0);
-    const token = values["token-stdin"] ? await tokenFromStdin() : await question("Device token (hidden): ", true);
+    const socket = values.socket;
+    const token = values["token-stdin"] ? await tokenFromStdin() : await question("\u8FDE\u63A5 Token\uFF08\u9690\u85CF\u8F93\u5165\uFF09\uFF1A", true);
     const result2 = await saveConfiguration(configPath, relay, token, socket);
-    console.log("Configuration saved: " + result2.path + "\nRun web-codex-client doctor, then web-codex-client run. Pairing and directory approval are still required.");
+    console.log("Configuration saved: " + result2.path + "\n\u8FD0\u884C web-codex-client run\uFF0C\u7136\u540E\u5728\u7F51\u9875\u8F93\u5165\u540C\u4E00\u4E2A Token \u5373\u53EF\u4F7F\u7528\u3002");
     return;
   }
   if (command === "doctor") {
@@ -2967,7 +3201,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. \u7F51\u9875\u8F93\u5165\u76F8\u540C Token \u5373\u53EF\u67E5\u770B\u9879\u76EE\u3001\u4F1A\u8BDD\u5E76\u53D1\u9001\u6D88\u606F\u3002"
     );
     let stopping = false;
     const stop = () => {
@@ -2979,21 +3213,59 @@ 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" });
+    if (list.pairingMode === "token") {
+      console.log("\u7F51\u9875\u8F93\u5165\u4E0E Client \u76F8\u540C\u7684 Token \u5373\u53EF\uFF0C\u65E0\u9700\u914D\u5BF9\u547D\u4EE4\u3002");
+      return;
+    }
+    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,7 +1,7 @@
 {
   "name": "@landh93/web-codex-client",
-  "version": "0.1.0-rc.1",
-  "description": "Encrypted local Codex bridge with explicit browser pairing and workspace authorization",
+  "version": "0.1.0-rc.3",
+  "description": "Encrypted local Codex bridge with automatic token authentication and workspace access",
   "license": "UNLICENSED",
   "bin": { "web-codex-client": "dist/cli.js" },
   "files": ["dist/cli.js", "dist/assets/noise.wasm", "README.md", "NPM_RELEASE.md", "sdk/THIRD_PARTY_NOTICES.md", "deploy/config.example.json", "deploy/config.remote.example.json", "deploy/web-codex-client.service"],