@walkhi/code-relax 0.1.0-beta.10 → 0.1.0-beta.12

package/README.md

@@ -1,9 +1,9 @@
-# Code Relax Bridge（Windows 私测包）
-
-Bridge 让 HarmonyOS 客户端控制 Windows 上的 Codex Desktop。当前要求 Windows x64、Node >=22.12 和已登录的 Codex Desktop；npm 包不包含 Node，也不修改官方程序文件。
-
-## 安装
-
+# Code Relax Bridge（Windows 私测包）
+
+Bridge 让 HarmonyOS 客户端控制 Windows 上的受管 Codex 内核。当前要求 Windows x64、Node >=22.12，以及已登录的 Codex Desktop 配套内核或独立 Codex CLI；npm 包不包含 Node，也不修改官方程序文件。
+
+## 安装
+
 公开 beta 已发布到 npm，安装或更新使用：
 
 ```powershell
@@ -11,72 +11,62 @@ npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax --foreground
 ```
 
 首次安装前先保存工作，并从 Codex 菜单或 Windows 托盘完全退出 Codex。更新无需先停止正在运行的 Bridge；安装器会短暂停止、替换并恢复服务。npm 全局安装会自动执行 `setup` 和 Skill 安装。`setup` 将完整服务部署到 `%LOCALAPPDATA%\Programs\CodexRemote\service`，记录安装所用 Node 的绝对路径，不复制 Node。配置、日志和二维码以 `installation.json.stateRoot` 为准，通常位于 `%LOCALAPPDATA%\CodexRemote`，MSIX 环境可能解析到包缓存目录；附件位于 `%ProgramData%\CodexRemote\attachments`。
-
-`setup` 立即启动 Bridge 和固定 45839 受管 app-server，并启用当前用户登录自启；自启不打开 Codex。受管实例健康后配置当前用户 `CODEX_APP_SERVER_WS_URL`，之后正常启动的 Desktop 自动接入。若安装时 Desktop 仍在运行，不中断现有任务，允许两个 app-server 暂时共存，并在手机提示立即或稍后重启。
-
+
+`setup` 立即启动 Bridge 和固定 45839 受管 app-server，并启用当前用户登录自启；自启不打开 Codex。受管实例健康后配置当前用户 `CODEX_APP_SERVER_WS_URL`，之后正常启动的 Desktop 自动接入。若安装时 Desktop 仍未接入，安装器会关闭并重新打开 Desktop；安装前应保存工作。普通更新无接入或启动链迁移需求时复用现有内核。
+
 ## Codex 内核
-
-```powershell
-relax shortcuts       # 创建 Codex 内核桌面快捷方式
-relax shared-start    # Codex 内核、Desktop、Bridge
-relax start           # 启动/复用常驻 Bridge 和已配置中继
+
+```powershell
+relax start           # 启动/复用 Bridge、受管 Codex 内核和已配置中继
 relax pair            # 启动/复用服务并打开配对二维码
 relax status
 relax stop
-```
-
+```
+
 Codex 内核由官方 `codex app-server --listen ws://127.0.0.1:45839` 提供执行服务，Desktop 和 Bridge 均可连接；它只监听回环地址。Bridge 独立报告内核健康、Desktop 接入和手机可写状态；Desktop 退出后，手机仍可操作内核中的任务。同一 thread 已被另一个实例持有时，手机只读且可重新检测。
-
-手机工作站详情可确认让 Desktop 接入 Codex 内核，独立进程逐步执行并保留 Bridge/中继连接，见[启用流程](../docs/shared-recovery.md)。本地 `shared-start` 在 Desktop 未接入受管服务时要求先自行退出 Desktop，不强制结束任务。Bridge 状态匹配且健康时直接复用；未知进程占用 45831/45839 时拒绝接管。`stop` 只停止 Bridge，不停止 Desktop 或受管 app-server。
-
+
+手机工作站详情可确认让 Desktop 接入 Codex 内核，独立进程逐步执行并保留 Bridge/中继连接，见[启用流程](../docs/shared-recovery.md)。本机恢复命令为 `relax shared-recover --confirm`，查看恢复结果用 `relax shared-recovery-status`。Bridge 状态匹配且健康时直接复用；未知进程占用 45831/45839 时拒绝接管。`stop` 只停止 Bridge，不停止 Desktop 或受管 app-server。
+
 受管 app-server 通过隐藏控制台启动，使后续控制台子进程继承隐藏窗口。手机的项目、任务列表和新建任务均使用受管内核，不依赖 Desktop 工具管道；项目和任务 ID 保持原生值。
-
+
 受管 app-server 未就绪时，手机停留在连接界面并显示“Codex 内核未就绪”；Bridge 保留健康和恢复接口，聊天请求返回错误。
-
-## Code Relax 中继
-
-私有中继仍需要本机 Bridge：
-
-```powershell
-relax relay-shared-start --json
+
+## Code Relax 中继
+
+私有中继仍需要本机 Bridge：
+
+```powershell
+relax start --json
 relax relay-start --json
 relax relay-status --json
 relax pair --json
 relax relay-stop --json
 relax relay-revoke --json
-```
-
-`relay-shared-start` 先准备 Codex 内核和 Bridge，再连接公网私有中继。每台移动设备通过 `pair` 配对一次；新增设备不替换已有设备。连接器把 Windows hostname 和当前 Wi-Fi/有线网络候选经已认证 WebSocket 临时发送给手机，手机本地保存电脑名，只在设备身份验证通过后保存可达地址；服务器不持久化这些 Code Relax 中继 hostname、IP 或网络名。OpenAI 官方认证和设备配对仍直接访问 OpenAI；完成后，手机使用统一配对产生的设备凭据，通过独立元数据 WebSocket 把官方环境 ID、名称和 hostname 写入设备记录，不上传 OpenAI access token、配对码或登录态。停止连接器不撤销授权。
-
-## Bridge 调试页面
-
-```powershell
-relax dev --json
-relax dev-status --json
-relax dev-stop --json
-```
-
-调试页面与 Bridge 共用进程和端口（默认 45831），只额外提供白名单静态资源，用于局域网页面调试。`dev-stop` 只关闭静态页面，不影响 Bridge WebSocket。Code Relax 中继和 OpenAI 中继均使用 HAP 内置页面。
-
-## 更新与卸载
-
-更新固定服务：
-
+```
+
+`start` 启动内核和 Bridge，并恢复已配置中继；`relay-start` 单独管理中继连接器。每台移动设备通过 `pair` 配对一次；新增设备不替换已有设备。连接器把 Windows hostname 和当前 Wi-Fi/有线网络候选经已认证 WebSocket 临时发送给手机，手机本地保存电脑名，只在设备身份验证通过后保存可达地址；服务器不持久化这些 Code Relax 中继 hostname、IP 或网络名。OpenAI 官方认证和设备配对仍直接访问 OpenAI；完成后，手机使用统一配对产生的设备凭据，通过独立元数据 WebSocket 把官方环境 ID、名称和 hostname 写入设备记录，不上传 OpenAI access token、配对码或登录态。停止连接器不撤销授权。
+
+Bridge 的局域网端口仅提供鉴权 WebSocket，普通 HTTP 请求返回 404；手机聊天页面随 HAP 安装。
+
+## 更新与卸载
+
+更新固定服务：
+
 ```powershell
 npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax --foreground-scripts
 ```
 
 `setup` 先暂存并校验新版本，再短暂停止 Bridge/中继完成切换；原服务此前正在运行时会自动恢复，新版本启动失败则回滚并启动旧版本。无需提前执行 `stop`。Node 路径变化或原 Node 被删除后需重新 setup。升级可能因 Node 可执行文件路径变化而再次触发 Windows 防火墙授权。
-
-卸载：
-
-```powershell
+
+卸载：
+
+```powershell
 relax uninstall
 npm uninstall -g @walkhi/code-relax
-```
-
+```
+
 `uninstall` 停止 Bridge 后先核对并清理 Code Relax 所有的当前用户 `CODEX_APP_SERVER_WS_URL`；用户后来修改或不归属 Code Relax 的值会保留。随后删除固定程序和本包管理且未修改的 Skill；保留其他配置、Token、日志、长期设备凭据、附件和自定义 Skill。它不卸载 Node、Codex Desktop，也不强制结束完整控制的执行进程。
-
-## 发布边界
-
+
+## 发布边界
+
 registry 测试包使用 `@walkhi/code-relax@beta`，主 CLI 为 `relax`，并保留 `code-relax` 兼容入口。安装摘要通过 `--foreground-scripts` 显示，首次安装或启动链迁移时干净重启 Desktop，分别报告已安装与实际运行版本；登录启动使用当前用户任务计划。通信协议仍为 7。详细规则见 [npm 分发](../docs/npm-distribution.md)。

package/dist/bin/codex-remote.mjs

@@ -7,8 +7,7 @@ import { installService, uninstallService, packageRoot } from '../src/service-in
 import { installSkill, removeSkill, inspectSkill } from '../src/skill-install.mjs';
 import { doctor } from '../src/service-doctor.mjs';
 import { launchDesktop } from '../src/desktop-launcher.mjs';
-import { desktopHost, desktopShortcuts, residentStartup, resolveStateRoot } from '../src/platform/windows/desktop-host.mjs';
-import { debugUi } from '../src/debug-ui.mjs';
+import { desktopHost, removeDesktopShortcut, residentStartup, resolveStateRoot } from '../src/platform/windows/desktop-host.mjs';
 import { selfRelay } from '../src/self-relay/lifecycle.mjs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
@@ -18,32 +17,28 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { requestRecovery, recoveryStatus, recoveryWarning } from '../src/shared-recovery.mjs';
 import { configureManagedEnvironment, clearManagedEnvironment } from '../src/platform/windows/user-environment.mjs';
 import { resolveCodexRuntime } from '../src/platform/windows/codex-runtime.mjs';
+import { controlRequest } from '../src/service-control.mjs';
+import { processAlive } from '../src/background-process.mjs';
 
 const help = `Code Relax（Windows）
-用法：relax <setup|doctor|skill-install|skill-remove|uninstall|start|shared-start|shortcuts|pair|status|stop> [--json]
+用法：relax <命令> [--json]；下列命令均可用
   setup   部署并启动固定目录服务、受管 app-server 和登录自启动；安全配置 Desktop 后续接入
-  start   启动或复用 Bridge，并恢复已配置的私有中继
-  shared-start 启动或复用 Codex 内核，再启动 Desktop、Bridge 和已配置的私有中继
+  start   启动或复用 Bridge 和 Codex 内核，并恢复已配置的私有中继
   shared-recover --confirm 重新打开 Desktop 并接入 Codex 内核；不强制重启已有内核
   shared-recovery-status 查看最近一次恢复的实际阶段和结果
   autostart-enable / autostart-disable / autostart-status 管理当前用户登录时启动 Bridge
-  shortcuts 创建 Codex 内核桌面快捷方式
   pair    启动或复用工作站服务，并打开一次性配对二维码
   status  查看服务健康状态
   stop    停止服务
-  dev     在 Bridge 端口开启调试页面（实时读取当前源码/包资源）
-  dev-status 查看 Bridge 调试页面状态
-  dev-stop 关闭调试页面，不停止 Bridge
   relay-start 启动或复用私有中继，已有授权直接恢复，首次授权生成二维码
-  relay-shared-start 启动 Codex 内核和 Bridge 后连接私有中继（需先退出当前 Codex）
-  relay-status 查看私有中继连接器及手机连接状态
+  relay-status 查看私有中继连接器及移动端连接状态
   relay-stop 停止私有中继连接器，不停止 Bridge 或 Codex
   relay-revoke 撤销这台电脑的全部移动设备授权（停止连接器不会撤销授权）
   doctor  检查安装、Node、Codex 内核、网络和 Skill，提示防火墙处理方式
   skill-install 安装/更新当前用户的 Codex Skill，不覆盖自定义文件
   skill-remove  移除本包安装且未修改的 Skill
   uninstall 停止并移除固定目录服务和本包 Skill，清理自有 Desktop 环境变量，保留其他配置与附件
-默认监听 0.0.0.0，手机与电脑需在同一受信任局域网。
+默认监听 0.0.0.0，移动端与电脑需在同一受信任局域网。
 --json 输出机器可读结果；统一二维码不含 LAN 地址、Bridge Token 或中继地址。`;
 
 async function main() {
@@ -52,7 +47,7 @@ async function main() {
     console.log(help);
     return;
   }
-  if (!['autostart-enable', 'autostart-disable', 'autostart-status', 'shared-recover', 'shared-recovery-status', 'relay-shared-start', 'relay-revoke', 'relay-start', 'relay-status', 'relay-stop', 'dev', 'dev-status', 'dev-stop', 'setup', 'doctor', 'skill-install', 'skill-remove', 'uninstall', 'shared-start', 'shortcuts', 'start', 'pair', 'status', 'stop'].includes(command)
+  if (!['autostart-enable', 'autostart-disable', 'autostart-status', 'shared-recover', 'shared-recovery-status', 'relay-revoke', 'relay-start', 'relay-status', 'relay-stop', 'setup', 'doctor', 'skill-install', 'skill-remove', 'uninstall', 'start', 'pair', 'status', 'stop'].includes(command)
     || flags.some(flag => flag !== '--json' && !(command === 'shared-recover' && flag === '--confirm'))) {
     throw new Error('无效命令或参数。使用 --help 查看用法。');
   }
@@ -60,30 +55,13 @@ async function main() {
   const json = flags.includes('--json');
   const paths = runtimePaths();
   const { stateRoot, serviceRoot } = paths;
-  if (['relay-shared-start', 'relay-revoke', 'relay-start', 'relay-status', 'relay-stop'].includes(command)) {
-    if (command === 'relay-shared-start') {
-      const existing = await selfRelay('relay-status', stateRoot);
-      if (existing.running && existing.transportMode !== 'lan-shared') throw new Error('旧连接器仍在运行，请先执行 relay-stop；不会自动中断手机连接。');
-      const result = await new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [fileURLToPath(import.meta.url), 'shared-start', '--json'], { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
-        let output = '', errors = '';
-        child.stdout.on('data', chunk => { output += chunk; }); child.stderr.on('data', chunk => { errors += chunk; });
-        child.once('error', reject);
-        child.once('exit', code => { if (code) reject(new Error(errors.trim().replace(/^(?:Code Relax：)+/u, '') || 'Codex 内核启动失败')); else { try { resolve(JSON.parse(output)); } catch { reject(new Error('Codex 内核启动结果无法确认，未启动中继')); } } });
-      });
-      if (!result.bridgeReady) { console.log(json ? JSON.stringify(result) : result.displayText); return; }
-    }
-    const result = await selfRelay(command === 'relay-shared-start' ? 'relay-start' : command, stateRoot, command === 'relay-shared-start' ? 'lan-shared' : '');
+  if (['relay-revoke', 'relay-start', 'relay-status', 'relay-stop'].includes(command)) {
+    const result = await selfRelay(command, stateRoot);
     console.log(json ? JSON.stringify(result) : `${result.displayText}${result.qrPath ? '\n二维码：' + result.qrPath : ''}`);
     return;
   }
-  if (['dev', 'dev-status', 'dev-stop'].includes(command)) {
-    const result = await debugUi(command, stateRoot);
-    console.log(json ? JSON.stringify(result) : result.message || JSON.stringify(result));
-    return;
-  }
   const installedEntry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
-  if (['autostart-enable', 'autostart-disable', 'autostart-status', 'shared-recover', 'shared-recovery-status', 'shared-start', 'shortcuts', 'start', 'pair', 'status', 'stop'].includes(command) && path.resolve(fileURLToPath(import.meta.url)).toLowerCase() !== installedEntry.toLowerCase()) {
+  if (['autostart-enable', 'autostart-disable', 'autostart-status', 'shared-recover', 'shared-recovery-status', 'start', 'pair', 'status', 'stop'].includes(command) && path.resolve(fileURLToPath(import.meta.url)).toLowerCase() !== installedEntry.toLowerCase()) {
     if (!fs.existsSync(installedEntry)) throw new Error('尚未部署服务，请先执行 relax setup。');
     const executable = readRecord(path.join(serviceRoot, 'installation.json'))?.nodeExecutable;
     if (!executable || !fs.existsSync(executable)) throw new Error('安装时选用的 Node 不存在，请重新执行 relax setup。');
@@ -92,7 +70,6 @@ async function main() {
     process.exitCode = code ?? 1;
     return;
   }
-  host.migrateState(stateRoot);
   const service = lifecycle({ stateRoot, host });
   if (command.startsWith('autostart-')) {
     const installation = readRecord(path.join(serviceRoot, 'installation.json'));
@@ -122,13 +99,6 @@ async function main() {
     console.log(json ? JSON.stringify(result) : `${result.displayText}\n二维码：${result.qrPath}`);
     return;
   }
-  if (command === 'shortcuts') {
-    const installation = readRecord(path.join(serviceRoot, 'installation.json'));
-    if (!installation?.nodeExecutable) throw new Error('请先执行 relax setup。');
-    const shortcuts = await desktopShortcuts({ serviceRoot, nodeExecutable: installation.nodeExecutable });
-    console.log(json ? JSON.stringify({ shortcuts }) : `桌面快捷方式已创建：\n${shortcuts.join('\n')}`);
-    return;
-  }
   if (command === 'doctor') {
     const result = await doctor({ paths, host, service });
     console.log(json ? JSON.stringify(result) : result.checks.map(item => `[${item.status}] ${item.message}`).join('\n'));
@@ -148,7 +118,7 @@ async function main() {
     const result = await uninstallService(paths, service, async () => {
       environment = await clearManagedEnvironment(stateRoot);
       const installation = readRecord(path.join(serviceRoot, 'installation.json'));
-      if (installation?.nodeExecutable) await desktopShortcuts({ serviceRoot, nodeExecutable: installation.nodeExecutable }, true);
+      if (installation?.nodeExecutable) await removeDesktopShortcut({ serviceRoot, nodeExecutable: installation.nodeExecutable });
       if (installation?.nodeExecutable) await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, 'disable');
     });
     result.environment = environment;
@@ -164,18 +134,21 @@ async function main() {
     if (major < 22 || (major === 22 && minor < 12)) throw new Error('需要 Node >=22.12。');
     const physicalStateRoot = await resolveStateRoot(stateRoot);
     // Preserve the effective package view; never replace a newer file already in it.
-    for (const name of ['bridge-config.json', 'bridge-session.json', 'bridge-startup-context.json', 'execution-mode.json',
-      'self-relay-config.json', 'self-relay-session.json', 'lan-device-authorizations.json', 'shared-desktop.json',
-      'managed-app-server.json', 'managed-environment.json', 'shared-recovery.json', 'shared-recovery.lock', 'debug-ui-session.json']) {
+    for (const name of ['bridge-config.json', 'bridge-session.json', 'bridge-startup-context.json',
+      'self-relay-config.json', 'self-relay-session.json', 'lan-device-authorizations.json',
+      'managed-app-server.json', 'managed-environment.json', 'shared-recovery.json', 'shared-recovery.lock']) {
       const source = path.join(stateRoot, name), target = path.join(physicalStateRoot, name);
       if (fs.existsSync(source) && !fs.existsSync(target)) fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL);
     }
     const hadInstalledService = fs.existsSync(path.join(serviceRoot, 'installation.json'));
+    const previousInstallation = readRecord(path.join(serviceRoot, 'installation.json'));
+    if (previousInstallation?.nodeExecutable) await removeDesktopShortcut({ serviceRoot, nodeExecutable: previousInstallation.nodeExecutable });
     const desktopBeforeSetup = await desktopHost.inspect();
     const runtime = await resolveCodexRuntime(physicalStateRoot, { refresh: true });
     const desktopNeedsAttach = desktopBeforeSetup.running && !await host.sharedServiceUrl();
     const previous = hadInstalledService ? await service.status() : { processRunning: false };
-    const previousRelay = await selfRelay('relay-status', stateRoot);
+    const legacyRelaySession = readRecord(path.join(stateRoot, 'self-relay-session.json'));
+    const previousRelay = legacyRelaySession ? await controlRequest(legacyRelaySession) : await selfRelay('relay-status', stateRoot);
     const resumeAfterUpdate = previous.processRunning || previousRelay.running;
     const executable = fs.realpathSync(process.execPath);
     const startInstalled = async () => {
@@ -195,7 +168,14 @@ async function main() {
       beforeActivate: async () => {
         if (desktopNeedsAttach) await desktopHost.closeDesktop(desktopBeforeSetup.desktop);
         stoppedForUpdate = resumeAfterUpdate;
-        if (previousRelay.running) await selfRelay('relay-stop', stateRoot);
+        if (previousRelay.running && legacyRelaySession) {
+          await controlRequest(legacyRelaySession, 'POST');
+          const deadline = Date.now() + 10000;
+          while (processAlive(legacyRelaySession.pid)) {
+            if (Date.now() >= deadline) throw new Error('旧中继进程未在 10 秒内退出。');
+            await delay(100);
+          }
+        } else if (previousRelay.running) await selfRelay('relay-stop', stateRoot);
         if (previous.processRunning) await service.stop();
       },
       verifyActivation: async () => { await startInstalled(); },
@@ -240,7 +220,7 @@ async function main() {
       managedAppServerMigrated = true;
       managedAppServerMigration.restarted = true;
       if (desktopAttached) {
-        await launchDesktop('shared', { stateRoot: physicalStateRoot, host: desktopHost });
+        await launchDesktop({ stateRoot: physicalStateRoot, host: desktopHost });
         desktopRestarted = true;
         desktopRestartReason = 'app-server-migration';
         bridge = await service.status();
@@ -250,7 +230,7 @@ async function main() {
     if (desktopNeedsAttach && !desktopRestarted) {
       const currentDesktop = await desktopHost.inspect();
       if (currentDesktop.running) await desktopHost.closeDesktop(currentDesktop.desktop);
-      await launchDesktop('shared', { stateRoot: physicalStateRoot, host: desktopHost });
+      await launchDesktop({ stateRoot: physicalStateRoot, host: desktopHost });
       desktopRestarted = true;
       desktopRestartReason = 'attach-managed-server';
       bridge = await service.status();
@@ -269,7 +249,7 @@ async function main() {
     const migrationText = managedAppServerMigrated ? '已自动重建旧启动链的 app-server；安装前尚未完成的任务可能已中断。\n' : '';
     const restartText = desktopRestarted
       ? 'Codex Desktop 已干净重启并重新接入受管 app-server。'
-      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一受管 app-server；手机控制不依赖 Desktop 是否打开。'
+      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一受管 app-server；移动端控制不依赖 Desktop 是否打开。'
       : '使用独立 Codex CLI；无需安装 Codex Desktop。';
     console.log(json ? JSON.stringify({ ...installed, nextSteps: desktopSetupSteps, displayText: `${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}` }) : `服务已安装：${installed.serviceRoot}\n使用已安装的 Node：${installed.nodeExecutable}\n受管 app-server 已就绪；首次联网可能需要 Windows 防火墙授权。\n${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}`);
     return;
@@ -279,26 +259,20 @@ async function main() {
     console.log(json ? JSON.stringify(result) : result.message);
     return;
   }
-  let desktop;
-  if (command === 'shared-start') {
-    if (!json) console.log('正在检查 Codex 的启动模式…');
-    desktop = await launchDesktop('shared', { stateRoot, host: desktopHost });
-    delete process.env.CODEX_APP_TOOLS_PIPE_PATH;
-  }
-  if (!json && (desktop || command === 'start')) console.log('正在检查电脑连接并准备 Bridge…');
-  const result = await service[desktop ? 'start' : command]();
+  if (!json && command === 'start') console.log('正在检查电脑连接并准备 Bridge…');
+  const result = await service[command]();
   if (command === 'status') {
     console.log(json ? JSON.stringify(result) : result.running
       ? `服务正常：${result.mode}，版本 ${result.version || '未知'}，端口 ${result.port}，PID ${result.pid}` : '服务未就绪。');
     return;
   }
   const { accessUrl, qrPath: _legacyQrPath, ...metadata } = result;
-  const notice = '本机服务检查通过，手机连通性尚未验证。若电脑弹出 Node 网络访问提示，请先处理 Windows 防火墙授权，再用手机连接。';
+  const notice = '本机服务检查通过，移动端连通性尚未验证。若电脑弹出 Node 网络访问提示，请先处理 Windows 防火墙授权，再用移动端连接。';
   let relay;
   if (fs.existsSync(path.join(stateRoot, 'self-relay-config.json'))) relay = await selfRelay('relay-start', stateRoot);
   const nextSteps = phonePairingSteps(metadata.transportMode, relay?.paired === true);
   const displayText = pairingDisplayText(nextSteps, notice);
-  const output = { ...metadata, ...(desktop ? { desktop, bridgeReady: true } : {}), ...(relay ? { relayConnected: relay.relayConnected,
+  const output = { ...metadata, ...(relay ? { relayConnected: relay.relayConnected,
     paired: relay.paired, clientCount: relay.clientCount, ...(relay.qrPath ? { qrPath: relay.qrPath, expiresAt: relay.expiresAt } : {}) } : {}),
     nextSteps, displayText, mode: 'lan', listenAddress: '0.0.0.0', address: new URL(accessUrl).host,
     lanAccess: 'unverified', notice };

package/dist/bin/migrate-relay-db.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import mysql from 'mysql2/promise';
+import { deviceStore } from '../src/self-relay/device-store.mjs';
+import { relayAdminState } from '../src/self-relay/admin-state.mjs';
+
+const command = process.argv[2];
+if (!['--schema', '--import', '--check'].includes(command) || !process.env.RELAY_MYSQL_CONFIG_FILE) {
+  throw new Error('Use --schema, --import or --check with RELAY_MYSQL_CONFIG_FILE');
+}
+const config = JSON.parse(fs.readFileSync(process.env.RELAY_MYSQL_CONFIG_FILE, 'utf8'));
+const db = await mysql.createConnection({ ...config, dateStrings: true, timezone: 'Z', multipleStatements: false });
+const sqlTime = value => value.replace('T', ' ').replace(/Z$/, '');
+const migrations = ['001_relay_core', '002_email_accounts'];
+try {
+  if (command === '--schema') {
+    const [existing] = await db.query("SHOW TABLES LIKE 'schema_migrations'");
+    const [applied] = existing.length ? await db.query('SELECT version, sha256 FROM schema_migrations') : [[]];
+    const known = new Map(applied.map(row => [row.version, row.sha256]));
+    if (known.size !== applied.length || [...known.keys()].some(version => !migrations.includes(version))) throw new Error('Unexpected schema version');
+    for (const version of migrations) {
+      const source = fs.readFileSync(fileURLToPath(new URL(`../database/${version}.sql`, import.meta.url)), 'utf8');
+      const sha256 = createHash('sha256').update(source).digest('hex');
+      if (known.has(version)) {
+        if (known.get(version) !== sha256) throw new Error(`Migration changed: ${version}`);
+        continue;
+      }
+      if (version !== migrations[0] && !known.has(migrations[migrations.indexOf(version) - 1])) throw new Error('Previous migration missing');
+      const statements = source.split('\n').filter(line => !line.trimStart().startsWith('--')).join('\n');
+      for (const statement of statements.split(';').map(item => item.trim()).filter(Boolean)) await db.query(statement);
+      await db.execute('INSERT INTO schema_migrations (version, sha256) VALUES (?,?)', [version, sha256]);
+      known.set(version, sha256);
+      console.log(JSON.stringify({ schema: version, sha256 }));
+    }
+  } else {
+    const [versions] = await db.query('SELECT version FROM schema_migrations');
+    if (!versions.some(row => row.version === '001_relay_core') || versions.some(row => !migrations.includes(row.version))) throw new Error('Unexpected schema version');
+    if (command === '--check') {
+      const names = ['computers', 'mobile_authorizations', 'official_computers', 'announcements', 'relay_settings', 'users', 'user_login_identities'];
+      if (versions.some(row => row.version === '002_email_accounts')) names.push('email_login_challenges', 'user_sessions', 'email_send_limits');
+      const counts = {};
+      for (const name of names) { const [rows] = await db.query(`SELECT COUNT(*) AS count FROM ${name}`); counts[name] = rows[0].count; }
+      if (process.env.RELAY_STATE_FILE && process.env.RELAY_ADMIN_STATE_FILE) {
+        const devices = deviceStore(process.env.RELAY_STATE_FILE).entries();
+        const admin = relayAdminState(process.env.RELAY_ADMIN_STATE_FILE, 8).read();
+        const expected = { computers: devices.length,
+          mobile_authorizations: devices.reduce((sum, item) => sum + item.clients.length, 0),
+          official_computers: devices.filter(item => item.officialComputer).length,
+          announcements: admin.announcements.length, relay_settings: 1 };
+        if (Object.keys(expected).some(name => counts[name] !== expected[name])) throw new Error('Imported row counts differ from JSON');
+        const [saved] = await db.query('SELECT id,host_hash,status,revision FROM computers');
+        const original = new Map(devices.map(item => [item.id, item]));
+        for (const row of saved) {
+          const item = original.get(row.id);
+          if (!item || item.hostHash !== row.host_hash || item.status !== row.status || item.revision !== Number(row.revision)) {
+            throw new Error('Imported computer identity differs from JSON');
+          }
+        }
+        const [authorized] = await db.query('SELECT computer_id,client_id,credential_hash FROM mobile_authorizations');
+        for (const row of authorized) {
+          const item = original.get(row.computer_id)?.clients.find(client => client.id === row.client_id);
+          if (!item || item.hash !== row.credential_hash) throw new Error('Imported mobile authorization differs from JSON');
+        }
+        const [settings] = await db.query('SELECT max_relay_sessions FROM relay_settings WHERE id=1');
+        if (settings[0]?.max_relay_sessions !== admin.maxRelaySessions) throw new Error('Imported relay setting differs from JSON');
+        console.log(JSON.stringify({ verified: true, counts }));
+      } else console.log(JSON.stringify(counts));
+    } else {
+      const stateFile = process.env.RELAY_STATE_FILE, adminFile = process.env.RELAY_ADMIN_STATE_FILE;
+      if (!stateFile || !adminFile) throw new Error('RELAY_STATE_FILE and RELAY_ADMIN_STATE_FILE required for import');
+      const devices = deviceStore(stateFile).entries();
+      const admin = relayAdminState(adminFile, 8).read();
+      const [existing] = await db.query('SELECT (SELECT COUNT(*) FROM computers) AS computers, (SELECT COUNT(*) FROM relay_settings) AS settings');
+      if (existing[0].computers || existing[0].settings) throw new Error('Import target is not empty');
+      await db.beginTransaction();
+      try {
+        for (const item of devices) {
+          await db.execute('INSERT INTO computers (id,host_hash,status,revision,created_at,updated_at) VALUES (?,?,?,?,?,?)',
+            [item.id, item.hostHash, item.status, item.revision, sqlTime(item.createdAt), sqlTime(item.updatedAt)]);
+          for (const client of item.clients) await db.execute(
+            'INSERT INTO mobile_authorizations (computer_id,client_id,credential_hash,created_at,updated_at) VALUES (?,?,?,?,?)',
+            [item.id, client.id, client.hash, sqlTime(client.createdAt), sqlTime(client.updatedAt)]);
+          if (item.officialComputer) {
+            const official = item.officialComputer;
+            await db.execute('INSERT INTO official_computers (computer_id,environment_id,name,hostname,updated_at) VALUES (?,?,?,?,?)',
+              [item.id, official.environmentId, official.name, official.hostname, sqlTime(official.updatedAt)]);
+          }
+        }
+        await db.execute('INSERT INTO relay_settings (id,max_relay_sessions,updated_at) VALUES (1,?,UTC_TIMESTAMP(3))', [admin.maxRelaySessions]);
+        for (const item of admin.announcements) await db.execute(
+          'INSERT INTO announcements (id,title,message,status,created_at,updated_at,published_at) VALUES (?,?,?,?,?,?,?)',
+          [item.id, item.title, item.message, item.status, sqlTime(item.createdAt), sqlTime(item.updatedAt),
+            item.publishedAt ? sqlTime(item.publishedAt) : null]);
+        await db.commit();
+      } catch (error) { await db.rollback(); throw error; }
+      console.log(JSON.stringify({ imported: true, computers: devices.length,
+        mobileAuthorizations: devices.reduce((sum, item) => sum + item.clients.length, 0),
+        officialComputers: devices.filter(item => item.officialComputer).length,
+        announcements: admin.announcements.length }));
+    }
+  }
+} finally { await db.end(); }

package/dist/bin/self-relay-server.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-import { deviceStore, validId } from '../src/self-relay/device-store.mjs';
+import { deviceStore, validId } from '../src/self-relay/device-store.mjs';
+import { openRelayMysql } from '../src/self-relay/mysql-state.mjs';
 import { startSelfRelay } from '../src/self-relay/server.mjs';
 import { updateDebugAllowlist } from '../src/self-relay/debug-allowlist.mjs';
 
@@ -9,15 +10,18 @@ if (!keyFile) throw new Error('RELAY_HOST_KEY_FILE is required');
 const hostKey = fs.readFileSync(keyFile, 'utf8').trim();
 const port = Number(process.env.RELAY_PORT || 45850);
 if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Invalid RELAY_PORT');
-const stateFile = process.env.RELAY_STATE_FILE;
-if (!stateFile) throw new Error('RELAY_STATE_FILE is required');
+const stateFile = process.env.RELAY_STATE_FILE;
+const mysqlConfigFile = process.env.RELAY_MYSQL_CONFIG_FILE;
+const accountConfigFile = process.env.RELAY_ACCOUNT_CONFIG_FILE;
+if (!stateFile && !mysqlConfigFile) throw new Error('RELAY_STATE_FILE or RELAY_MYSQL_CONFIG_FILE is required');
 const debugAllowlistFile = process.env.RELAY_DEBUG_ALLOWLIST_FILE || '/etc/codex-relay/debug-allowlist.json';
 const adminStateFile = process.env.RELAY_ADMIN_STATE_FILE || '/var/lib/codex-relay/admin.json';
 const maxRelaySessions = Number(process.env.RELAY_MAX_RELAY_SESSIONS || 8);
 if (!Number.isSafeInteger(maxRelaySessions) || maxRelaySessions < 1 || maxRelaySessions > 256) throw new Error('Invalid RELAY_MAX_RELAY_SESSIONS');
 const debugCommand = process.argv.find(value => ['--debug-list', '--debug-allow', '--debug-deny'].includes(value));
 if (debugCommand) {
-  const records = deviceStore(stateFile).entries();
+  const database = mysqlConfigFile ? await openRelayMysql(mysqlConfigFile, maxRelaySessions) : null;
+  const records = (database?.devices || deviceStore(stateFile)).entries();
   if (debugCommand === '--debug-list') {
     console.log(JSON.stringify(records.map(record => ({
       deviceId: record.id, status: record.status, clientCount: record.clients.length,
@@ -30,21 +34,24 @@ if (debugCommand) {
     updateDebugAllowlist(debugAllowlistFile, deviceId, debugCommand === '--debug-allow');
     console.log('Debug allowlist updated; restart relay to apply.');
   }
+  if (database) await database.close();
   process.exit(0);
 }
-if (process.argv.includes('--init-state')) { deviceStore(stateFile, { initialize: true }); console.log('Device store initialized'); process.exit(0); }
-const revokeIndex = process.argv.indexOf('--revoke-host');
-if (revokeIndex >= 0) {
+if (process.argv.includes('--init-state')) { if (mysqlConfigFile) throw new Error('Use migrations for MySQL mode'); deviceStore(stateFile, { initialize: true }); console.log('Device store initialized'); process.exit(0); }
+const revokeIndex = process.argv.indexOf('--revoke-host');
+if (revokeIndex >= 0) {
   // Run only with the service stopped: this is an offline administrator operation.
   if (!process.argv.includes('--offline')) throw new Error('Stop the relay service and supply --offline');
   const id = process.argv[revokeIndex + 1];
   if (!validId(id)) throw new Error('Invalid device ID');
-  const store = deviceStore(stateFile), record = store.entries().find(item => item.id === id);
+  const database = mysqlConfigFile ? await openRelayMysql(mysqlConfigFile, maxRelaySessions) : null;
+  const store = database?.devices || deviceStore(stateFile), record = store.entries().find(item => item.id === id);
   if (!record) throw new Error('Device not found');
-  store.save({ ...record, status: 'revoked', clientHash: undefined, clientId: undefined, revision: record.revision + 1, updatedAt: new Date().toISOString() });
+  await store.save({ ...record, status: 'revoked', clients: [], revision: record.revision + 1, updatedAt: new Date().toISOString() });
+  if (database) await database.close();
   console.log('Computer and phone authorization revoked'); process.exit(0);
 }
-const relay = await startSelfRelay({ port, hostKey, stateFile, debugAllowlistFile, adminStateFile, maxRelaySessions,
+const relay = await startSelfRelay({ port, hostKey, stateFile, mysqlConfigFile, accountConfigFile, debugAllowlistFile, adminStateFile, maxRelaySessions,
   publicRelayUrl: process.env.RELAY_PUBLIC_URL || '', appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || '',
   log: entry => console.log(JSON.stringify({ time: new Date().toISOString(), ...entry })) });
 console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32, maxRelaySessions,

package/dist/shared/app-server-events.cjs

@@ -1,14 +1,14 @@
 (function (root, factory) {
   if (typeof module === 'object' && module.exports) module.exports = factory();
   else root.CodexAppServerEvents = factory();
-})(globalThis, function () {
+})(globalThis, function () {
   function mergeItems(existing, incoming = []) {
     for (const source of incoming) {
       const item = compactItem(source);
       const index = existing.findIndex(current => current.id === item.id);
       if (index < 0) existing.push(item);
       else existing[index] = { ...existing[index], ...item };
-    }
+    }
     return existing;
   }
 
@@ -137,6 +137,18 @@
     }
     return match;
   }
+  function catalogThreadProjectId(thread, projects) {
+    if (thread.projectId) return thread.projectId;
+    const local = thread.environments?.find(environment => environment.environmentId === 'local');
+    if (local && Array.isArray(local.runtimeWorkspaceRoots)) {
+      for (const root of local.runtimeWorkspaceRoots) {
+        const projectId = threadProjectId({ cwd: root }, projects);
+        if (projectId) return projectId;
+      }
+      return null;
+    }
+    return threadProjectId({ cwd: thread.cwd }, projects);
+  }
   function projectlessThreadTarget(cwd = '') {
     return { projectId: null, runtimeWorkspaceRoots: [], ...(cwd ? { cwd } : {}) };
   }
@@ -289,6 +301,6 @@
     }
     return readQueue(request, threadId);
   }
-  return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, projectlessThreadTarget, updateSettings,
+  return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
     permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
 });

package/dist/shared/file-mentions.cjs

@@ -0,0 +1,35 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else root.CodexFileMentions = api;
+})(globalThis, function () {
+  const heading = '# Files mentioned by the user:';
+  const request = '## My request:';
+
+  function parse(value) {
+    const source = typeof value === 'string' ? value : '';
+    if (!source.startsWith(heading)) return { text: source, files: [] };
+    const marker = source.indexOf(`\n${request}`, heading.length);
+    if (marker < 0) return { text: source, files: [] };
+    const files = [];
+    for (const line of source.slice(heading.length, marker).split(/\r?\n/)) {
+      const match = /^## (.+): ((?:[A-Za-z]:[\\/]|\/)[^\r\n]+)$/.exec(line);
+      if (!match) continue;
+      let name = match[1];
+      if (name.startsWith('"')) {
+        try { name = JSON.parse(name); } catch { continue; }
+      }
+      if (typeof name !== 'string' || !name) continue;
+      files.push({ type: 'file', name, path: match[2] });
+    }
+    if (!files.length) return { text: source, files: [] };
+    return { text: source.slice(marker + request.length + 1).trim(), files };
+  }
+
+  function wrap(prompt, files) {
+    if (!files?.length) return prompt;
+    return `${heading}\n${files.map(file => `\n## ${JSON.stringify(file.name)}: ${file.path}\n`).join('')}\n${request}\n${prompt || '请查看上述文件。'}`;
+  }
+
+  return Object.freeze({ parse, wrap });
+});