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

package/NPM_RELEASE.md

@@ -1,17 +1,16 @@
 # npm 客户端发布与安装
 
-包名：`@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`。
+包名：`@landh93/web-codex-client`。当前候选版为 `0.1.0-rc.4`，使用 `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,19 +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`**。对照终端与网页的完整指纹，在网页点击“与本机显示一致”，再在终端输入 `yes`。无需提前执行 `pair-open`，无需复制 64 位指纹或逐个配置已有项目目录。
+Client 运行后，在网页输入同一个 Token 即可：自动选择设备、建立端到端加密连接、加载项目与会话。打开会话即可输入消息；写租约自动取得和续期，只有另一个浏览器占用时才需要处理冲突。无需 `pair-open`、`pair`、指纹核对或“申请控制权”。网页刷新后在同一标签页自动重连；Token 只保存在该标签页的 sessionStorage，退出登录清除。
 
-核对并信任浏览器后，从本机 Codex 项目目录及活动/归档历史的 cwd 识别已有项目，自动授予这些目录的读写权限；扫描有分页、去重和数量上限，不会把浏览器任意指定的路径当作已有项目。系统根目录、用户家目录以及包含 Client 状态的父目录不自动授予。没有识别到项目时明确报错，可以使用 `pair --root /absolute/project` 在终端明确确认目录读写授权。
+默认授权本机 Codex 项目目录与活动/归档会话元数据识别出的已有项目读写，保留目录边界和 Codex 执行审批。授权在每次连接时重新读取，不持久保存临时浏览器身份。不同 token 对应不同设备，不能凭一个设备 Token 查看其他设备。
 
-新增目录执行 **`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 版本保持兼容。
+此版本需要同时更新 Server 网关、网页和 Client（SDK rc.4）。旧 Server 不支持新的 Token 登录；应先部署 Server 再升级并重启 Client。原有设备 Token 可继续使用，无需重新注册。新部署的 Server 可通过 `CONNECTION_TOKEN_FILE=/private/path/token` 直接配置同一个 Token，无需先创建管理员账号；文件权限为 0600，Token 至少 32 个无空白字符。管理员口令可登录并连接账号下所有在线设备；rc.4 通过管理员路由 v1 支持此流程。升级时保留配置和 Token，只重启 Client，无需重启 Codex。`pairingMode:"manual"` 仍是显式本机确认的兼容模式，不接受管理员自动授权。
 
 后台常驻可使用 systemd 用户服务，将 `ExecStart` 设为实际安装的 `web-codex-client run --config /absolute/config.json`。npm 安装不会自动启用服务或打开配对窗口。
 
@@ -75,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.2.tgz \
+npm publish .test-output/landh93-web-codex-client-0.1.0-rc.4.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`，核对完整指纹并在网页和终端确认。无需提前开启窗口；Codex 已有项目自动授予读写，新目录用 `web-codex-client authorize --root /absolute/path` 在本机确认。配置、身份和授权独立于 npm 安装目录，升级时保留。完整安装、token 标准输入、证书、后台运行与发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
+已有 Codex 项目自动允许读写，执行审批和目录边界仍保留。配置、Token 和身份与 npm 安装目录分开存放，升级保留。Client rc.4 增加管理员连接，需要支持管理员路由 v1 的 Server；SDK 保持 rc.4。请先更新 Server，再升级并重启 Client。完整安装和发布说明见 [NPM_RELEASE.md](./NPM_RELEASE.md)。
 
 ## 安装、构建、自测
 
@@ -42,44 +41,17 @@ 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 --config ~/.config/web-codex-client/config.json
-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
-```
-
-rc.2 配对等待 5 分钟，本机确认还要求浏览器已确认相同指纹；不再强制先执行 `pair-open`。默认对识别到的 Codex 项目授予读写，其他目录需要显式本机授权；`--read-only` 可指定只读。`pair-list` 显示剩余时间，失败返回白名单错误码和处理提示。撤销立即关闭该身份的会话并拒绝后续业务。浏览器身份默认仅存内存，刷新后重新配对；同一页面断线重连可以继续使用内存身份和固定公钥。
+只允许 WSS 并验证证书；私有 CA 使用 `NODE_EXTRA_CA_CERTS`。浏览器在当前标签页保存 Token 以支持刷新自动重连，退出登录清除。已识别项目每次连接重新扫描，根目录、用户主目录和 Client 私有状态的父目录不会自动授权。
 
-`status` 分别返回 relayOnline、handshakes、authorizedSessions、codexAvailable。Codex 连接按第一次已授权请求惰性建立，因此仅中继上线时 codexAvailable 仍为 false。上游断线后下一次请求重连，旧 epoch/订阅失效。后台服务无有限总工作量，不显示伪造百分比。
+管理员使用 Server 管理员口令登录后，可以连接该账号的所有在线设备，不需要逐台输入 Token。Client 信任配置的 Server 签发仅限当前路由的管理员凭据，并将其绑定到 Noise 握手验证；已识别项目范围、写租约及 Codex 审批仍生效。旧 Client rc.3 必须升级并重启才能接受管理员连接。
 
-`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");
@@ -1494,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) {
@@ -1572,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;
@@ -1585,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;
   }
 };
@@ -1820,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(
@@ -1856,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"
     };
@@ -1889,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;
@@ -1915,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") {
@@ -2010,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,
@@ -2026,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();
@@ -2040,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",
@@ -2055,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,
@@ -2064,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");
@@ -2077,7 +2096,7 @@ var Bridge = class {
               seen,
               expires: Date.now() + 6e4
             });
-          return { data, nextCursor };
+          return { data: data2, nextCursor };
         }
       }
       case "projects.read":
@@ -2094,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) };
@@ -2311,6 +2330,7 @@ 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",
@@ -2408,12 +2428,15 @@ var ClientDaemon = class {
   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(() => {
@@ -2450,7 +2473,10 @@ 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,
+        ...this.config.pairingMode !== "manual" ? { "X-Web-Codex-Admin-Routes": "v1" } : {}
+      },
       perMessageDeflate: false,
       maxPayload: 128 * 1024,
       handshakeTimeout: 1e4
@@ -2462,9 +2488,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");
       }
@@ -2496,7 +2522,12 @@ var ClientDaemon = class {
         this.control({ type: "route.close", routeId: m.routeId });
         return;
       }
+      if (m.adminToken !== void 0 && (this.config.pairingMode === "manual" || typeof m.adminToken !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(m.adminToken))) {
+        this.control({ type: "route.close", routeId: m.routeId });
+        return;
+      }
       this.routes.set(m.routeId, {
+        proofToken: m.adminToken ?? this.token,
         confirmed: false,
         expires: Date.now() + PAIRING_MS,
         queue: Promise.resolve(),
@@ -2540,7 +2571,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(r.proofToken, r.session.fingerprint, "client")
+            });
+          } else if (grant) {
             r.session.trust(r.session.fingerprint);
             r.owner = grant.peer;
             this.send(frame.routeId, {
@@ -2561,9 +2599,21 @@ 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(r.proofToken, 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;
+        r.proofToken = "";
         return;
       }
       if (!r.owner || !this.grants.has(r.owner))
@@ -2584,13 +2634,13 @@ var ClientDaemon = class {
   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) {
@@ -2627,8 +2677,10 @@ var ClientDaemon = class {
     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) {
@@ -2645,7 +2697,7 @@ var ClientDaemon = class {
             (r) => r.owner
           ).length,
           pairingUntil: this.pairUntil,
-          pairingMode: "local-confirmation",
+          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 }))
@@ -2656,7 +2708,7 @@ var ClientDaemon = class {
         return { expiresAt: this.pairUntil };
       case "pair-list":
         return {
-          pairingMode: "local-confirmation",
+          pairingMode: this.config.pairingMode === "manual" ? "local-confirmation" : "token",
           windowRequired: false,
           pairingUntil: this.pairUntil,
           pairingRemainingMs: Math.max(0, this.pairUntil - Date.now()),
@@ -2671,6 +2723,7 @@ var ClientDaemon = class {
           }))
         };
       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).optional(),
@@ -2815,17 +2868,17 @@ var ClientDaemon = class {
     }
     this.admin = createServer((socket) => {
       socket.setTimeout(6e4, () => socket.destroy());
-      let data = "";
+      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(() => {
-          const request = JSON.parse(data);
+          const request = JSON.parse(data2);
           const result = this.adminQueue.then(() => this.adminCommand(request));
           this.adminQueue = result.then(() => {
           }, () => {
@@ -2869,17 +2922,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 = "";
+    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"));
       }
@@ -2936,6 +2989,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);
@@ -2981,10 +3041,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
@@ -3005,9 +3066,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 {
@@ -3054,7 +3115,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);
@@ -3103,7 +3164,7 @@ async function main() {
   }
   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 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()
+      "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;
   }
@@ -3111,12 +3172,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") {
@@ -3149,7 +3210,7 @@ async function main() {
     const daemon = new ClientDaemon(config, state.identity, state.grants);
     await daemon.start();
     console.log(
-      "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"
+      "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 = () => {
@@ -3170,6 +3231,10 @@ async function main() {
   };
   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"}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@landh93/web-codex-client",
-  "version": "0.1.0-rc.2",
-  "description": "Encrypted local Codex bridge with explicit browser pairing and workspace authorization",
+  "version": "0.1.0-rc.4",
+  "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"],