glasslink 0.0.0-stage → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentLink contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,207 @@
-# Temporary Holding Version
+# glasslink
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+戴着 NIMO 眼镜，遥控你自己电脑上的 coding agent：看它干到哪了、批准或拒绝它要做的操作、随时打断、用语音给它下新指令。
+
+`glasslink` 是装在**你自己电脑上**的那一半：它在本机启动你选的 agent（Claude Code、Codex、DeepSeek Harness、Kimi Code，或实验性的 Pi），把 agent 的进展发给中转服务，再把你在眼镜 / 手机上的操作转回给 agent。agent 用的是你自己的账号，代码一直在你自己的电脑上。
+
+## 三步接入
+
+1. **准备好你的 agent**：装好、登录好你要用的那一家（见下面「各家 agent 的准备步骤」）。电脑上还要有 Node.js 20 或更新版本（`node --version` 看一下）。
+2. **在终端运行**：进到你要让 agent 干活的项目目录，运行
+
+   ```sh
+   npx glasslink
+   ```
+
+   第一次运行会列出这台电脑上检测到的 agent，用 ↑↓ 或数字选一个，回车确认。
+3. **在手机上输码**：终端里会用大字显示一个 6 位码。打开手机上的 AgentLink 页面，输入这个码。终端显示「已连接」就好了，眼镜上就能看到 agent 的进展。
+
+以后再在这台电脑上运行 `npx glasslink`，会直接连上（用上次的配对和 agent），不用再输码。
+
+终端里大概是这样：
+
+```
+AgentLink 0.3.1 · 把电脑上的 coding agent 接到 NIMO 眼镜
+正在检查这台电脑上装了哪些 agent…
+选一个 agent（↑↓ 或数字选择，回车确认，Ctrl+C 退出）：
+    1. Claude Code       已安装 2.1.317 · 已登录
+  ❯ 2. Codex             已安装 0.158.0 · 已登录
+    3. DeepSeek Harness  未安装
+    4. Kimi Code         已安装 0.28.1
+    5. Pi 实验性         已安装 0.84.2 · 已配置
+    准备好了，回车选它
+
+  在手机 AgentLink 页面输入这个码：
+
+    ██████  ██████  ██████    ██████    ██    ██████
+        ██  ██  ██      ██    ██  ██  ████        ██
+        ██  ██  ██      ██    ██████    ██        ██
+        ██  ██  ██      ██    ██  ██    ██        ██
+        ██  ██████      ██    ██████  ██████      ██
+
+  配对码：707817
+  10 分钟内有效，过期会自动换新码 · 按 Ctrl+C 退出
+  等手机输码…（这个码还剩 9:41）
+```
+
+## 各家 agent 的准备步骤
+
+### Claude Code
+
+```sh
+npm i -g @anthropic-ai/claude-code            # 安装 Claude Code
+claude                                        # 运行一次，按提示登录（也可以用环境变量 ANTHROPIC_API_KEY）
+npm i -g @anthropic-ai/claude-agent-sdk       # AgentLink 用 Claude Agent SDK 驱动 Claude Code，只要装一次
+npx glasslink --agent claude
+```
+
+SDK 没有打进 glasslink 的包里（这样 `npx glasslink` 启动快，不用 Claude 的人也不用下载它）。glasslink 按这个顺序找 SDK：环境变量 `AGENTLINK_CLAUDE_SDK`（指向 SDK 目录或入口文件）→ 全局 node_modules → `~/.agentlink/node_modules`。不想全局安装，也可以：`npm i --prefix ~/.agentlink @anthropic-ai/claude-agent-sdk`。
+
+默认读你自己的 Claude Code 设置（`~/.claude/settings.json`、项目里的 `.claude/settings*.json` 和 `CLAUDE.md`）：你在设置里允许过的操作照样直接跑，Claude Code 本来会问你的，改成在手机 / 眼镜上问。读文件、搜索、`ls` / `cat` / `pwd` / `git status|log|diff` 这类只读操作自动放行。
+
+加 `--strict`：除了上面这些只读操作，其余一律先问，设置里的「允许」规则也跳不过。
+
+### Codex
+
+```sh
+npm i -g @openai/codex
+codex login
+npx glasslink --agent codex
+```
+
+glasslink 通过 Codex 自带的 `codex app-server` 驱动它。默认用你自己的 Codex 配置（`~/.codex/config.toml` 里的 `approval_policy`、`sandbox_mode`），glasslink 不改。
+
+加 `--strict`：`approvalPolicy=untrusted`（只有 Codex 认定安全的只读命令直接跑，其余命令和所有改文件都先问你）+ `sandbox=workspace-write`（批准以后也只能改工作目录里的文件）。也可以用环境变量 `AGENTLINK_CODEX_APPROVAL`（`untrusted` / `on-request` / `never`）和 `AGENTLINK_CODEX_SANDBOX`（`read-only` / `workspace-write` / `danger-full-access`）自己指定。
+
+### DeepSeek Harness
+
+```sh
+node --version                    # 需要 24.9 或更新
+npm i -g @deepseek-ai/dsh
+export DEEPSEEK_API_KEY=...       # 或者运行 dsh web，在网页里填 key（存在 ~/.dsh 里，glasslink 认得）
+npx glasslink --agent dsh
+```
+
+审批：默认是 dsh 自己的默认模式（`workspace-write`：工作目录里改文件、跑命令都不问，出了工作目录才问）。你自己设了环境变量 `DSH_PERMISSION_MODE` 的话照用。
+
+加 `--strict`：glasslink 用 `DSH_PERMISSION_MODE=read-only` 启动 dsh。dsh 先在只读沙箱里试，要写文件或执行会改东西的命令时被拦下，然后带着理由来问你能不能放宽，手机上会显示「写文件 c.txt（要放宽到「可写工作目录」：理由…）」。所以历史记录里会先看到一行「· 写文件 c.txt ✗」（第一次被沙箱拦下），批准后再出现一行 ✓，这是正常的。只读的命令（比如 `ls`）在只读沙箱里直接跑，不问。
+
+### Kimi Code
+
+按 Kimi Code 官方说明安装，装好后能运行 `kimi`（默认装在 `~/.kimi-code/bin/`）。然后：
+
+```sh
+kimi                              # 运行一次，按提示登录
+npx glasslink --agent kimi
+```
+
+审批由 Kimi Code 自己的设置决定。`kimi acp` 没有审批相关的启动参数，所以 `--strict` 对它不起作用（启动时会提示）。
+
+### Pi（实验性，待验证）
+
+```sh
+npm i -g --ignore-scripts @earendil-works/pi-coding-agent
+pi                                # 输入 /login 选一家登录，或者先设置好对应厂商的 API Key
+npx glasslink --agent pi
+```
+
+Pi 本身没有审批机制，默认什么都不问（跟你直接用 Pi 一样）。加 `--strict` 时，glasslink 启动它会挂一个很小的扩展（`pi --mode rpc -e <glasslink 自带的 pi-gate.mjs>`，不会写进你的 `~/.pi`）：执行命令、写文件、改文件前先问你；读文件、搜索直接放行。这一家目前只按 Pi 0.84 的文档实现，**还没有跟真的 Pi 跑过完整对话**，可能有不稳定的地方。
+
+### 其他支持 ACP 协议的 agent
+
+```sh
+npx glasslink --agent acp --acp-cmd "<启动 ACP 服务的命令>"
+```
+
+没有专门测试过。
+
+## 审批：默认跟随 agent，`--strict` 更严
+
+glasslink **默认不改你的 agent 的权限配置**：agent 平时会问你的操作，改成在手机 / 眼镜上问；agent 平时不问就直接做的，手机上也不会弹批准。
+
+想让写文件、执行命令都先问，加 `--strict`（或者设环境变量 `AGENTLINK_STRICT=1`）：
+
+```sh
+npx glasslink --strict
+```
+
+启动时终端里会写明这次是哪种：「审批：跟随 DeepSeek Harness 自己的设置」或「审批：严格（写文件、执行命令都先问）」。
+
+| agent | 默认（跟随它自己） | `--strict` |
+|---|---|---|
+| Claude Code | 读你的 Claude Code 设置；设置里允许过的直接跑 | 只读操作以外一律先问，设置里的允许规则也跳不过 |
+| Codex | 用 `~/.codex/config.toml` 的设置 | `untrusted` + `workspace-write` 沙箱 |
+| DeepSeek Harness | dsh 的默认 `workspace-write`：工作目录里改文件、跑命令不问 | `DSH_PERMISSION_MODE=read-only`：要写、要改都先来问 |
+| Pi | Pi 没有审批，什么都不问 | 挂上 glasslink 的审批扩展：执行命令、写文件、改文件先问 |
+| Kimi Code | Kimi Code 自己的设置 | 不起作用（`kimi acp` 没有对应参数） |
+| 其他 ACP agent | 它自己的设置 | 不起作用 |
+
+不管哪种模式，手机 / 眼镜上的「允许」都只对这一次操作生效。
+
+## 常用命令
+
+| 命令 | 做什么 |
+|---|---|
+| `npx glasslink` | 第一次：选 agent → 出码 → 手机输码；以后：直接启动 |
+| `npx glasslink --agent codex` | 指定 agent（下次默认用这次的）。可选：`claude` `codex` `dsh` `kimi` `pi` |
+| `npx glasslink --new` | 重新配对（换手机，或者想重新出码） |
+| `npx glasslink --cwd ~/projects/app` | 指定 agent 干活的目录（默认是当前目录） |
+| `npx glasslink --name 我的MacBook` | 手机上显示的电脑名（默认是主机名） |
+| `npx glasslink --strict` | 严格审批：写文件、执行命令都先问（见上面「审批」） |
+| `npx glasslink --verbose` | 多打印一些细节，比如和中转服务的每次短暂断线 |
+| `npx glasslink logout` | 删掉这台电脑上的配对 |
+| `npx glasslink status` | 看配对状态、中转服务能不能连上 |
+| `npx glasslink pair <6 位码>` | 用**眼镜上**显示的配对码配对（眼镜出码的老流程） |
+| `npx glasslink start` | 按已有配对启动，不交互（老流程） |
+
+运行期间终端要一直开着；按 Ctrl+C 退出。不想每次都用 npx，可以装成全局命令：`npm i -g glasslink`，以后直接运行 `glasslink`。
+
+中转服务地址默认是 `https://agent.quantkick.ai`，可以用 `--relay <URL>` 或环境变量 `AGENTLINK_RELAY` 改。
+
+## 安全说明
+
+- **电脑上不开端口。** glasslink 只主动连出去到中转服务，别人没办法从外面连进你的电脑。
+- **令牌只存你本机。** 配对后的令牌存在 `~/.agentlink/config.json`，文件权限 600（只有你自己能读），终端里不会打印。中转服务只存令牌的哈希。
+- **对话不落盘。** 代码和对话内容只在中转服务的内存里经过（每条链路最近 200 条），不写硬盘，日志里也不记内容。
+- **每次批准只管这一次。** 眼镜或手机上点「允许」只对当前这一个操作生效，glasslink 从不替你选「总是允许」；5 分钟没人答按拒绝。
+- **配对码一次性。** 6 位码 10 分钟内有效、只能用一次。如果你没在手机上输码，终端却显示「已连接」，立刻按 Ctrl+C，再运行 `npx glasslink logout`。
+- **agent 的权限照旧。** 默认 glasslink 不改 agent 的权限配置，只是把它的审批请求转到你的手机 / 眼镜上；想更严就加 `--strict`。
+- **检测只看本地。** 列 agent 时 glasslink 只在本机找命令、跑 `--version`、看登录配置文件在不在，不会替你发起任何对话，也不会花你的额度。
+
+## 常见问题
+
+**为什么有时手机上不弹批准，agent 就直接改了文件 / 跑了命令？** 因为默认审批跟随 agent 自己的设置，agent 平时不问的操作，手机上也不会问。比如 DeepSeek Harness 默认在工作目录里改文件、跑命令都不问；Claude Code 里你在设置中允许过的命令直接跑；Pi 本身就没有审批。想每次都先问，用 `npx glasslink --strict`（Kimi Code 和其他 ACP agent 除外，它们的审批只能在它们自己的设置里改）。
+
+**配对码过期了怎么办？** 不用管，终端会自动换一个新码，在手机上输新的就行。
+
+**手机上解除了配对 / 手机连了别的电脑，会怎样？** 这台电脑的配对作废，正在运行的 glasslink 会自动重新出一个码，不用重启。
+
+**终端关了会怎样？** 眼镜和手机上显示「电脑未连接」。再运行一次 `npx glasslink` 就恢复了，不用重新输码。
+
+**选了 Claude Code，提示没找到 Claude Agent SDK？** 运行 `npm i -g @anthropic-ai/claude-agent-sdk`，再重新启动。
+
+**提示「现在不是交互式终端，没法让你选 agent」？** 在脚本或 CI 里运行时没法弹出选择列表，用 `--agent` 指定，比如 `npx glasslink --agent codex`。
+
+**列表里显示「没看到登录信息」，但我明明登录过？** 有的 agent 把登录信息存在系统钥匙串里，glasslink 只看配置文件，可能看不到。直接选它试试；真没登录的话，agent 启动时会提示你。
+
+**连不上中转服务？** 电脑要能用 HTTPS 访问中转服务。公司网络如果拦了，换个网络试试。glasslink 断线后会自己重连：30 秒内自己恢复的短暂断线不打印（加 `--verbose` 才显示）；断开超过 30 秒会提示一次「连不上中转服务，正在重试…」，恢复时再提示一次。断线期间 agent 的进展先存在电脑上，连上后补发到手机。
+
+**支持 Windows 吗？** 目前只在 macOS 上测过，Linux 应该也能用，Windows 还没验证。
+
+## 环境变量
+
+| 变量 | 作用 |
+|---|---|
+| `AGENTLINK_RELAY` | 中转服务地址 |
+| `AGENTLINK_STRICT` | 设成 `1` 等于加 `--strict` |
+| `AGENTLINK_HOME` | 配置目录（默认 `~/.agentlink`） |
+| `AGENTLINK_CLAUDE_SDK` | Claude Agent SDK 的位置（目录或入口文件） |
+| `AGENTLINK_CODEX_CMD` / `AGENTLINK_CODEX_APPROVAL` / `AGENTLINK_CODEX_SANDBOX` | Codex 的启动命令（默认 `codex app-server`）、审批策略、沙箱 |
+| `AGENTLINK_PI_CMD` | Pi 的启动命令（默认 `pi`，glasslink 会在后面加 `--mode rpc -e …`） |
+| `AGENTLINK_DSH_CMD` / `AGENTLINK_KIMI_CMD` | DeepSeek Harness / Kimi Code 的 ACP 启动命令 |
+| `DSH_PERMISSION_MODE` | dsh 自己的权限模式；你设了 glasslink 照用（`--strict` 时固定 `read-only`） |
+| `NO_COLOR` | 不用颜色 |
+
+## 许可
+
+MIT

package/bin/agentlink.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+// agentlink：把电脑上的 coding agent 接到 NIMO 眼镜 / 手机。约定见 CONTRACT.md（§1–§3、§8）。
+//   glasslink              交互式：选 agent → 终端显示 6 位码 → 手机输码 → 进入运行状态（已配对就直接启动）
+//   glasslink pair <码>    老流程：用眼镜上显示的配对码配对
+//   glasslink start        老流程：按已有配对启动
+//   glasslink status / logout
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadConfig, saveConfig, clearConfig, resolveRelay, configPath } from '../src/config.js';
+import { createClient } from '../src/relay-client.js';
+import { Bridge } from '../src/runner.js';
+import { createAdapter, AGENTS, CATALOG, detectAll, installHint, catalogEntry, approvalLine, strictFromEnv } from '../src/adapters/index.js';
+import { pairByCode } from '../src/pairing.js';
+import { select, makeColors, padEnd } from '../src/ui.js';
+import { VERSION } from '../src/version.js';
+
+const c = makeColors(process.stdout);
+const ce = makeColors(process.stderr);
+// 提示里怎么称呼自己：通过 npx 跑的就写 npx glasslink
+const CMD = process.env.npm_command === 'exec' && !process.env.AGENTLINK_PLAIN_CMD ? 'npx glasslink' : 'glasslink';
+
+const HELP = `AgentLink ${VERSION} · 戴着 NIMO 眼镜遥控你电脑上的 coding agent
+
+用法：
+  ${CMD}                      第一次：选 agent → 终端显示 6 位码 → 在手机 AgentLink 页面输入
+                                 以后：直接启动（用上次的配对和 agent）
+      --agent <名字>             直接指定 agent，不用选：${CATALOG.map((x) => x.id).join(' / ')}（还有 acp、fake）
+      --new                      重新配对（换手机，或者想重新出码）
+      --cwd <目录>               agent 在哪个目录干活（默认当前目录）
+      --name <电脑名>            手机上显示的电脑名（默认主机名）
+      --strict                   严格审批：写文件、执行命令都先在手机 / 眼镜上问你（也可用环境变量 AGENTLINK_STRICT=1）
+                                 不加时审批跟随 agent 自己的设置，agent 平时不问的操作手机上也不会弹批准
+      --verbose                  打印更多细节（比如和中转服务的每一次短暂断线）
+      --acp-cmd "<命令>"         配合 --agent acp：任意 ACP 服务的启动命令
+      --relay <URL>              中转服务地址（默认 https://agent.quantkick.ai，也可用环境变量 AGENTLINK_RELAY）
+  ${CMD} logout               删掉这台电脑上的配对
+  ${CMD} status               看配对状态、中转服务能不能连上
+  ${CMD} pair <6 位码>        用眼镜上显示的配对码配对（眼镜出码的老流程）
+  ${CMD} start                按已有配对启动（老流程，和不带参数一样，但不会交互）
+  ${CMD} --version | --help
+
+审批：默认跟随 agent 自己的设置（glasslink 不改它的权限配置）；加 --strict 切到各家最严的模式，
+写文件、执行命令都先问。Kimi Code 和 --agent acp 没法从外面切，--strict 对它们不起作用。
+
+按 Ctrl+C 退出。配置存在 ${configPath()}（权限 600）。
+
+agent：
+${Object.entries(AGENTS).map(([k, v]) => `  ${k.padEnd(7)}${v}`).join('\n')}`;
+
+const BOOL = new Set(['new', 'help', 'version', 'yes', 'strict', 'verbose']);
+function parseArgs(argv) {
+  const o = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '-h') o.help = true;
+    else if (a === '-v' || a === '-V') o.version = true;
+    else if (a.startsWith('--')) {
+      const [k, v] = a.slice(2).split(/=(.*)/s);
+      if (v !== undefined) o[k] = v;
+      else if (!BOOL.has(k) && i + 1 < argv.length && !argv[i + 1].startsWith('--')) o[k] = argv[++i];
+      else o[k] = true;
+    } else o._.push(a);
+  }
+  return o;
+}
+
+const die = (msg, code = 1) => { process.stderr.write(`${ce.red('✗')} ${msg}\n`); process.exit(code); };
+const stamp = () => new Date().toTimeString().slice(0, 8);
+const print = (l) => console.log(`${c.dim(stamp())} ${l}`);
+const hostName = (args) => (typeof args.name === 'string' && args.name.trim() ? args.name.trim() : os.hostname().replace(/\.local$/, ''));
+
+function resolveCwd(args) {
+  const cwd = path.resolve(typeof args.cwd === 'string' ? args.cwd.replace(/^~(?=$|\/)/, os.homedir()) : process.cwd());
+  if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) die(`工作目录不存在：${cwd}`);
+  return cwd;
+}
+
+function checkAgentId(id) {
+  if (!Object.hasOwn(AGENTS, id)) die(`不认识的 agent：「${id}」。可选：${Object.keys(AGENTS).join(' / ')}`);
+  return id;
+}
+
+const isStrict = (args) => args.strict === true || args.strict === 'true' || strictFromEnv();
+
+function makeAdapter(agentId, args) {
+  try {
+    return createAdapter(agentId, { acpCmd: typeof args['acp-cmd'] === 'string' ? args['acp-cmd'] : undefined, print, stepMs: args['step-ms'] ? Number(args['step-ms']) : undefined, strict: isStrict(args) });
+  } catch (e) { return die(e.message); }
+}
+
+// 跑起来，直到退出。返回退出码：0 正常退出，2 配对失效
+async function runBridge({ relay, token, adapter, cwd, args, unauthorizedHint }) {
+  const bridge = new Bridge({ client: createClient(relay, token), adapter, cwd, print, pollWait: args['poll-wait'] ? Number(args['poll-wait']) : 25, unauthorizedHint, verbose: !!args.verbose });
+  console.log(`AgentLink 启动中\n  中转服务：${relay}\n  agent：${adapter.name}\n  工作目录：${cwd}\n  ${approvalLine(adapter, isStrict(args))}`);
+  try { await bridge.start(); } catch (e) { die(`agent 启动失败：\n${e.message}`); }
+  let stopping = false;
+  const onSig = () => { if (stopping) process.exit(130); stopping = true; print('正在退出…（再按一次 Ctrl+C 强制退出）'); bridge.stop(0); };
+  process.on('SIGINT', onSig); process.on('SIGTERM', onSig);
+  const code = await bridge.done;
+  process.off('SIGINT', onSig); process.off('SIGTERM', onSig);
+  return code;
+}
+
+// ---- 交互式主命令 ----
+function statusText(d) {
+  if (!d.installed) return c.dim('未安装');
+  const parts = [c.green('已安装') + (d.version ? ` ${d.version}` : '')];
+  if (d.id === 'claude' && !d.sdk) parts.push(c.yellow('缺 Claude Agent SDK'));
+  else if (d.loggedIn === true) parts.push(d.id === 'claude' || d.id === 'codex' ? '已登录' : '已配置');
+  else if (d.loggedIn === false) parts.push(c.yellow('没看到登录信息'));
+  return parts.join(' · ');
+}
+
+function detailText(d) {
+  const entry = catalogEntry(d.id);
+  if (!d.installed) return `还没装。${entry.install.length ? `安装：${entry.install.join('；')}` : entry.installText || ''}`;
+  if (d.notes.length) return d.notes.join('；');
+  return d.loggedIn === null ? `第一次用请先确认：${entry.login}` : '准备好了，回车选它';
+}
+
+async function chooseAgent(dets, preferred) {
+  const nameW = Math.max(...dets.map((d) => d.name.length + (d.experimental ? 6 : 0))) + 2;
+  const items = dets.map((d, i) => ({ label: `${i + 1}. ${padEnd(d.name + (d.experimental ? ' 实验性' : ''), nameW)}${statusText(d)}`, detail: detailText(d) }));
+  let initial = dets.findIndex((d) => d.id === preferred);
+  if (initial < 0) initial = Math.max(0, dets.findIndex((d) => d.ready));
+  const i = await select({ title: c.bold('选一个 agent') + c.dim('（↑↓ 或数字选择，回车确认，Ctrl+C 退出）：'), items, initial,
+    footer: c.dim(`  其他 ACP agent：${CMD} --agent acp --acp-cmd "<命令>"`), doneText: (k) => `agent：${c.bold(dets[k].name)}${c.dim(`（下次可以直接 ${CMD} --agent ${dets[k].id}）`)}` });
+  if (i === null) { console.log('已退出。'); process.exit(130); }
+  return dets[i].id;
+}
+
+// 选好的 agent 能不能用：没装 / Claude 缺 SDK → 给安装命令并退出；其余问题只提醒
+async function checkReady(agentId) {
+  if (!catalogEntry(agentId)) return;
+  const [d] = await detectAll({ ids: [agentId] });
+  if (!d.installed) die(`${d.name} 还没装。\n${installHint(agentId)}\n装好后重新运行 ${CMD}。`);
+  if (agentId === 'claude' && !d.sdk) die(`还差一步：AgentLink 用 Claude Agent SDK 驱动 Claude Code，这台电脑上还没有。请运行：\n  npm i -g @anthropic-ai/claude-agent-sdk\n装好后重新运行 ${CMD}。`);
+  for (const n of d.notes) console.log(`${c.yellow('!')} ${n}`);
+  if (d.experimental) console.log(`${c.yellow('!')} ${d.name} 是实验性支持，可能有不稳定的地方。`);
+}
+
+async function cmdMain(args) {
+  const tty = !!(process.stdin.isTTY && process.stdout.isTTY);
+  let cfg = loadConfig();
+  const fresh = !!args.new || !cfg.bridgeToken;
+  let relay;
+  try { relay = resolveRelay(args.relay, fresh ? {} : cfg); } catch (e) { die(e.message); }
+  const cwd = resolveCwd(args);
+  console.log(`${c.bold(`AgentLink ${VERSION}`)} · 把电脑上的 coding agent 接到 NIMO 眼镜`);
+
+  let agentId = typeof args.agent === 'string' ? checkAgentId(args.agent) : null;
+  if (!agentId && !fresh && cfg.agent && Object.hasOwn(AGENTS, cfg.agent)) agentId = cfg.agent;
+  if (!agentId && !fresh && !tty) agentId = 'claude'; // 老版本（0.1）配的，没记 agent：和以前的 start 一样默认 claude
+  if (!agentId) {
+    if (!tty) die(`现在不是交互式终端，没法让你选 agent。请用 --agent 指定，比如：${CMD} --agent claude\n可选：${CATALOG.map((x) => x.id).join(' / ')}`);
+    console.log(c.dim(`各家的准备步骤：${relay}/link`));
+    console.log('正在检查这台电脑上装了哪些 agent…');
+    const dets = await detectAll();
+    agentId = await chooseAgent(dets, cfg.agent);
+  }
+  await checkReady(agentId);
+
+  for (;;) {
+    if (!cfg.bridgeToken || args.new) {
+      if (args.new && cfg.bridgeToken) console.log(c.dim('重新配对：手机输入新码后，这台电脑原来的配对就作废了。'));
+      const ac = new AbortController();
+      const onSig = () => ac.abort();
+      process.on('SIGINT', onSig); process.on('SIGTERM', onSig);
+      let r;
+      try {
+        r = await pairByCode({ base: relay, name: hostName(args), agent: agentId, signal: ac.signal, cmd: CMD, pollWait: args['poll-wait'] ? Number(args['poll-wait']) : 25 });
+      } catch (e) {
+        if (e.code === 'aborted') { console.log('\n已退出，还没配对。'); process.exit(130); }
+        die(e.message);
+      } finally { process.off('SIGINT', onSig); process.off('SIGTERM', onSig); }
+      cfg = { relay, bridgeToken: r.bridgeToken, linkId: r.linkId, name: hostName(args), agent: agentId, pairedAt: new Date().toISOString() };
+      saveConfig(cfg);
+      args.new = false;
+      console.log(`\n${c.green('✓ 已连接')} 手机已经配对好了。以后在这台电脑上运行 ${CMD} 会直接连上，不用再输码。\n`);
+    } else if (cfg.agent !== agentId) {
+      cfg = { ...cfg, agent: agentId };
+      saveConfig(cfg);
+    }
+    const code = await runBridge({ relay, token: cfg.bridgeToken, adapter: makeAdapter(agentId, args), cwd, args, unauthorizedHint: null });
+    if (code !== 2) process.exit(code);
+    console.log(`\n${c.yellow('!')} 这台电脑的配对失效了（手机上解除了配对，或者手机连了别的电脑）。重新申请一个配对码…`);
+    cfg = { ...cfg, bridgeToken: undefined, linkId: undefined };
+    saveConfig(cfg);
+  }
+}
+
+// ---- 子命令 ----
+async function cmdPair(args) {
+  const code = String(args._[1] || '').trim();
+  if (!/^\d{6}$/.test(code)) die(`配对码是眼镜上显示的 6 位数字，比如：${CMD} pair 123456\n（用手机配对的话不用这条，直接运行 ${CMD}）`);
+  const cfg = loadConfig();
+  let relay;
+  try { relay = resolveRelay(args.relay, {}); } catch (e) { die(e.message); } // 配对时不沿用旧配置里的 relay，按参数 / 环境变量 / 默认
+  const name = hostName(args);
+  try {
+    const r = await createClient(relay).pair(code, name);
+    saveConfig({ ...cfg, relay, bridgeToken: r.bridgeToken, linkId: r.linkId, name, pairedAt: new Date().toISOString(), ...(typeof args.agent === 'string' ? { agent: checkAgentId(args.agent) } : {}) });
+    console.log(`配对成功（${name} ⇄ 眼镜，中转服务：${relay}）。现在运行：${CMD} start（或直接 ${CMD}）`);
+  } catch (e) {
+    if (e.status === 403) die('配对码不对或已经过期（10 分钟内有效、只能用一次）。请看眼镜上最新的配对码再试。');
+    if (e.status === 429) die('试太多次了，请过 1 分钟再试。');
+    if (e.status === 400) die('配对码格式不对，应该是 6 位数字。');
+    die(`配对失败：${e.message}（中转服务：${relay}）`);
+  }
+}
+
+async function cmdStatus(args) {
+  const cfg = loadConfig();
+  const file = configPath();
+  if (!cfg.bridgeToken) { console.log(`还没配对。运行 ${CMD}，按提示在手机 AgentLink 页面输入终端里显示的 6 位码。\n配置文件：${file}`); return; }
+  let relay;
+  try { relay = resolveRelay(args.relay, cfg); } catch (e) { die(e.message); }
+  let mode = '';
+  try { mode = (fs.statSync(file).mode & 0o777).toString(8); } catch { /* 忽略 */ }
+  console.log(`已配对：${cfg.name || '（没名字）'}，链路 ${cfg.linkId}，配对时间 ${cfg.pairedAt || '未知'}`);
+  console.log(`agent：${cfg.agent ? (catalogEntry(cfg.agent) || { name: cfg.agent }).name : '（没记，启动时默认 claude）'}`);
+  console.log(`中转服务：${relay}${cfg.relay && cfg.relay !== relay ? `（注意：配对时用的是 ${cfg.relay}）` : ''}`);
+  console.log(`配置文件：${file}（权限 ${mode}）`);
+  try { await createClient(relay).health(); console.log('中转服务能连上。'); } catch (e) { console.log(`中转服务连不上：${e.message}`); }
+}
+
+async function cmdStart(args) {
+  const cfg = loadConfig();
+  if (!cfg.bridgeToken) die(`还没配对：运行 ${CMD}（在手机上输码），或者用眼镜上的配对码运行 ${CMD} pair <配对码>`);
+  let relay;
+  try { relay = resolveRelay(args.relay, cfg); } catch (e) { die(e.message); }
+  if (cfg.relay && cfg.relay !== relay) console.log(`注意：配对时用的中转服务是 ${cfg.relay}，现在连的是 ${relay}，token 可能不认。`);
+  const cwd = resolveCwd(args);
+  const agentId = checkAgentId(typeof args.agent === 'string' ? args.agent : cfg.agent || 'claude');
+  const code = await runBridge({ relay, token: cfg.bridgeToken, adapter: makeAdapter(agentId, args), cwd, args,
+    unauthorizedHint: `配对已失效（可能在眼镜上点了「重新配对」，或手机连了别的电脑）。用眼镜上的新配对码运行：${CMD} pair <配对码>；用手机的话直接运行 ${CMD}` });
+  process.exit(code);
+}
+
+async function cmdLogout() {
+  const cfg = loadConfig();
+  const had = clearConfig();
+  if (!had) { console.log('这台电脑上本来就没有配对。'); return; }
+  console.log(`已删除这台电脑上的配对（${cfg.name || '这台电脑'}，${configPath()}）。`);
+  console.log(`手机 / 眼镜上会显示「电脑未连接」。下次运行 ${CMD} 会重新出码配对。`);
+}
+
+const args = parseArgs(process.argv.slice(2));
+const cmd = args._[0];
+if (args.version) { console.log(VERSION); process.exit(0); }
+const run = { pair: cmdPair, start: cmdStart, status: cmdStatus, logout: cmdLogout }[cmd];
+if (args.help || cmd === 'help') { console.log(HELP); process.exit(0); }
+if (cmd && !run) { console.error(`不认识的命令：${cmd}\n\n${HELP}`); process.exit(1); }
+(run || cmdMain)(args).catch((e) => die(e.message || String(e)));

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "glasslink",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.1",
+  "description": "戴着 NIMO AR 眼镜遥控你电脑上的 coding agent（Claude Code / Codex / DeepSeek Harness / Kimi Code / Pi）：看进展、批准操作、打断、语音下指令",
+  "type": "module",
+  "bin": {
+    "glasslink": "bin/agentlink.js",
+    "agentlink": "bin/agentlink.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test --test-timeout=60000 test/*.test.mjs",
+    "demo": "node demo-local.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "glasslink",
+    "agentlink",
+    "nimo",
+    "ar-glasses",
+    "smart-glasses",
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "kimi",
+    "deepseek",
+    "acp",
+    "remote-control",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "AgentLink contributors"
+}