@walkhi/code-relax 0.1.0-beta.16 → 0.1.0-beta.18

package/README.md

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

package/dist/bin/codex-remote.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { phonePairingSteps, desktopSetupSteps, pairingDisplayText } from '../src/onboarding.mjs';
-import { lifecycle, readRecord } from '../src/service-lifecycle.mjs';
+import { lifecycle, readRecord, writeRecord } from '../src/service-lifecycle.mjs';
 import { runtimePaths } from '../src/platform/windows/runtime-paths.mjs';
 import * as host from '../src/platform/windows/service-host.mjs';
 import { installService, uninstallService, packageRoot } from '../src/service-install.mjs';
@@ -23,17 +23,27 @@ import { processAlive } from '../src/background-process.mjs';
 const help = `Code Relax（Windows）
 用法：relax <命令> [--json]；下列命令均可用
 常用指令：
-  start   启动或复用 Bridge 和 Codex 内核，并恢复已配置的私有中继
-  pair    启动或复用工作站服务，并打开一次性配对二维码
+  start   启动或复用桌面服务和 Codex 内核，并恢复已配置的 Code Relax 中继
+  pair    启动或复用桌面服务，并打开一次性配对二维码
 维护指令：
-  setup   部署并启动固定目录服务、受管 app-server 和登录自启动；安全配置 Desktop 后续接入
+  setup   部署并启动桌面服务、Codex 内核和登录自启动；安全配置 Desktop 后续接入
   doctor  检查服务、登录自启、最近恢复结果、网络和 Skill
   desktop-recover --confirm 重新打开 Desktop 并接入 Codex 内核；不强制重启已有内核
   uninstall 停止并移除固定目录服务和本包 Skill，清理自有 Desktop 环境变量，保留其他配置与附件
 默认监听 0.0.0.0，移动端与电脑需在同一受信任局域网。
---json 输出机器可读结果；统一二维码不含 LAN 地址、Bridge Token 或中继地址。`;
+--json 输出机器可读结果；统一二维码不含 LAN 地址、桌面服务凭据或中继地址。`;
+
+function currentNodeExecutable() {
+  const link = process.env.NVM_SYMLINK && path.join(process.env.NVM_SYMLINK, 'node.exe');
+  if (link && fs.existsSync(link)) {
+    try {
+      if (fs.realpathSync(link).toLowerCase() === fs.realpathSync(process.execPath).toLowerCase()) return link;
+    } catch {}
+  }
+  return process.execPath;
+}
 
-async function main() {
+async function main() {
   const [command, ...flags] = process.argv.slice(2);
   if (!command || command === '--help' || command === '-h') {
     console.log(help);
@@ -46,11 +56,20 @@ async function main() {
   if (process.platform !== 'win32') throw new Error('当前被控端仅支持 Windows。');
   const json = flags.includes('--json');
   const paths = runtimePaths();
-  const { stateRoot, serviceRoot } = paths;
-  const installedEntry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
-  if (['desktop-recover', 'start', 'pair'].includes(command) && path.resolve(fileURLToPath(import.meta.url)).toLowerCase() !== installedEntry.toLowerCase()) {
+  const { stateRoot, serviceRoot } = paths;
+  const installedEntry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
+  const installationPath = path.join(serviceRoot, 'installation.json');
+  const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
+  const currentNodeSupported = nodeMajor > 22 || (nodeMajor === 22 && nodeMinor >= 12);
+  const installed = path.resolve(fileURLToPath(import.meta.url)).toLowerCase() === installedEntry.toLowerCase();
+  const installation = readRecord(installationPath);
+  if (installation?.nodeExecutable && !fs.existsSync(installation.nodeExecutable) && currentNodeSupported
+    && ['start', 'pair', 'doctor'].includes(command)) {
+    writeRecord(installationPath, { ...installation, nodeExecutable: currentNodeExecutable() });
+  }
+  if (['desktop-recover', 'start', 'pair'].includes(command) && !installed) {
     if (!fs.existsSync(installedEntry)) throw new Error('尚未部署服务，请先执行 relax setup。');
-    const executable = readRecord(path.join(serviceRoot, 'installation.json'))?.nodeExecutable;
+    const executable = readRecord(installationPath)?.nodeExecutable;
     if (!executable || !fs.existsSync(executable)) throw new Error('安装时选用的 Node 不存在，请重新执行 relax setup。');
     const child = spawn(executable, [installedEntry, command, ...flags], { stdio: 'inherit', windowsHide: true });
     const code = await new Promise((resolve, reject) => { child.once('error', reject); child.once('exit', resolve); });
@@ -59,21 +78,12 @@ async function main() {
   }
   const service = lifecycle({ stateRoot, host });
   const ensureAutostart = async () => {
-    const installation = readRecord(path.join(serviceRoot, 'installation.json'));
-    if (!installation?.nodeExecutable) throw new Error('请先执行 setup。');
-    const current = await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, 'status');
+    const currentInstallation = readRecord(installationPath);
+    if (!currentInstallation?.nodeExecutable) throw new Error('请先执行 setup。');
+    const startup = { serviceRoot, nodeExecutable: currentInstallation.nodeExecutable };
+    const current = await residentStartup(startup, 'status');
     if (current.enabled) return { ...current, repaired: false };
-    const running = await service.status();
-    if (!running.running) await service.start();
-    const deadline = Date.now() + 35000;
-    while (true) {
-      const ready = await service.status();
-      if (ready.running && ready.managedAppServer?.ready) break;
-      if (Date.now() >= deadline) throw new Error('Codex 内核未就绪，未启用 Desktop 自动接入。');
-      await delay(250);
-    }
-    const result = await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, 'enable');
-    if ((await desktopHost.inspect()).desktop) await configureManagedEnvironment(stateRoot);
+    const result = await residentStartup(startup, 'enable');
     return { ...result, repaired: true };
   };
   if (command === 'desktop-recover') {
@@ -83,13 +93,13 @@ async function main() {
     return;
   }
   if (command === 'pair') {
+    await ensureAutostart();
     let bridge = await service.status();
     if (!bridge.running) {
       await service.start();
       bridge = await service.status();
     }
     if (!bridge.running) throw new Error('Code Relax 工作站服务未能启动。');
-    await ensureAutostart();
     const result = await selfRelay('relay-pair', stateRoot);
     if (!json && result.qrPath) {
       const viewer = spawn('explorer.exe', [result.qrPath], { detached: true, stdio: 'ignore', windowsHide: true });
@@ -142,7 +152,7 @@ async function main() {
     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 executable = currentNodeExecutable();
     const startInstalled = async () => {
       const entry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
       const child = spawn(executable, [entry, 'start', '--json'], { windowsHide: true, stdio: ['ignore', 'ignore', 'pipe'] });
@@ -152,7 +162,7 @@ async function main() {
       if (code) {
         try { await selfRelay('relay-stop', stateRoot); } catch {}
         try { await service.stop(); } catch {}
-        throw new Error(errors.trim().replace(/^(?:Code Relax：)+/u, '') || 'Bridge 启动失败');
+        throw new Error(errors.trim().replace(/^(?:Code Relax：)+/u, '') || '桌面服务启动失败');
       }
     };
     let stoppedForUpdate = false;
@@ -173,6 +183,7 @@ async function main() {
       verifyActivation: async () => { await startInstalled(); },
       restoreActivation: async () => { if (stoppedForUpdate) await startInstalled(); },
     });
+    const autostart = await residentStartup(installed, 'enable');
     const deadline = Date.now() + 35_000;
     let bridge = await service.status();
     while (bridge.running && !['ready', 'failed'].includes(bridge.managedAppServer?.state) && Date.now() < deadline) {
@@ -180,7 +191,7 @@ async function main() {
       bridge = await service.status();
     }
     if (!bridge.running || bridge.managedAppServer?.state !== 'ready') {
-      throw new Error(bridge.managedAppServer?.error || 'Bridge 已安装，但受管 app-server 未就绪；未写入 Desktop 环境变量。');
+      throw new Error(bridge.managedAppServer?.error || '桌面服务已安装，但 Codex 内核未就绪；未写入 Desktop 环境变量。');
     }
     const environment = desktopBeforeSetup.desktop
       ? await configureManagedEnvironment(physicalStateRoot) : { configured: false, reason: 'desktop-not-installed' };
@@ -203,11 +214,11 @@ async function main() {
         await delay(250);
         bridge = await service.status();
         if (bridge.managedAppServer?.restart?.status === 'failed') {
-          throw new Error(bridge.managedAppServer.restart.error || '受管 app-server 启动链迁移失败。');
+          throw new Error(bridge.managedAppServer.restart.error || 'Codex 内核启动链迁移失败。');
         }
       } while (Date.now() < migrationDeadline && (!bridge.running || bridge.managedAppServer?.state !== 'ready' || bridge.managedAppServer.launcherRestartRequired));
       if (!bridge.running || bridge.managedAppServer?.state !== 'ready' || bridge.managedAppServer.launcherRestartRequired) {
-        throw new Error('受管 app-server 未在 40 秒内完成启动链迁移。');
+        throw new Error('Codex 内核未在 40 秒内完成启动链迁移。');
       }
       managedAppServerMigrated = true;
       managedAppServerMigration.restarted = true;
@@ -218,7 +229,6 @@ async function main() {
         bridge = await service.status();
       }
     }
-    const autostart = await residentStartup(installed, 'enable');
     const skill = installSkill(path.join(serviceRoot, 'dist/skills/code-relax/SKILL.md'));
     if (desktopNeedsAttach && !desktopRestarted) {
       const currentDesktop = await desktopHost.inspect();
@@ -242,15 +252,15 @@ async function main() {
     installed.desktopRestartReason = desktopRestartReason;
     const migrationText = managedAppServerMigrated ? '已自动重建旧启动链的 app-server；安装前尚未完成的任务可能已中断。\n' : '';
     const restartText = desktopRestarted
-      ? 'Codex Desktop 已干净重启并重新接入受管 app-server。'
-      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一受管 app-server；移动端控制不依赖 Desktop 是否打开。'
+      ? 'Codex Desktop 已干净重启并重新接入 Codex 内核。'
+      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一 Codex 内核；移动端控制不依赖 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}`);
+    console.log(json ? JSON.stringify({ ...installed, nextSteps: desktopSetupSteps, displayText: `${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}` }) : `桌面服务已安装：${installed.serviceRoot}\n使用已安装的 Node：${installed.nodeExecutable}\nCodex 内核已就绪；首次联网可能需要 Windows 防火墙授权。\n${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}`);
     return;
   }
-  if (!json && command === 'start') console.log('正在检查电脑连接并准备 Bridge…');
-  const result = await service[command]();
+  if (!json && command === 'start') console.log('正在检查电脑连接并准备桌面服务…');
   await ensureAutostart();
+  const result = await service[command]();
   const { accessUrl, qrPath: _legacyQrPath, ...metadata } = result;
   const notice = '本机服务检查通过，移动端连通性尚未验证。若电脑弹出 Node 网络访问提示，请先处理 Windows 防火墙授权，再用移动端连接。';
   let relay;
@@ -263,7 +273,7 @@ async function main() {
     lanAccess: 'unverified', notice };
   if (json) console.log(JSON.stringify(output));
   else {
-    console.log('电脑连接检查通过 · Bridge 已就绪');
+    console.log('电脑连接检查通过 · 桌面服务已就绪');
     console.log(`局域网模式：监听 0.0.0.0:${result.port}，连接地址 ${output.address}，PID ${result.pid}`);
     if (relay?.qrPath) console.log(`配对二维码：${relay.qrPath}`);
     console.log(displayText);

package/dist/bin/manage-relay-admin.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import mysql from 'mysql2/promise';
+
+const path = process.env.RELAY_MYSQL_CONFIG_FILE;
+const action = process.argv[2];
+const email = (process.argv[3] || '').trim().toLowerCase();
+if (!path || !['--grant', '--revoke', '--list'].includes(action) ||
+    (action !== '--list' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))) {
+  throw new Error('Use --grant EMAIL, --revoke EMAIL or --list with RELAY_MYSQL_CONFIG_FILE');
+}
+const db = await mysql.createConnection({ ...JSON.parse(fs.readFileSync(path, 'utf8')),
+  dateStrings: true, timezone: 'Z', multipleStatements: false });
+try {
+  if (action === '--grant') await db.execute(`INSERT INTO relay_admin_emails (email,granted_at)
+    VALUES (?,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE email=VALUES(email)`, [email]);
+  else if (action === '--revoke') await db.execute('DELETE FROM relay_admin_emails WHERE email=?', [email]);
+  const [rows] = await db.query('SELECT email FROM relay_admin_emails ORDER BY email');
+  console.log(JSON.stringify({ admins: rows.map(row => row.email) }));
+} finally { await db.end(); }

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

@@ -13,7 +13,7 @@ if (!['--schema', '--import', '--check'].includes(command) || !process.env.RELAY
 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'];
+const migrations = ['001_relay_core', '002_email_accounts', '003_relay_usage', '004_relay_usage_actions'];
 try {
   if (command === '--schema') {
     const [existing] = await db.query("SHOW TABLES LIKE 'schema_migrations'");
@@ -40,6 +40,8 @@ try {
     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');
+      if (versions.some(row => row.version === '003_relay_usage')) names.push('relay_admin_emails', 'relay_usage_settings', 'relay_usage_totals', 'relay_usage_computer_totals', 'relay_usage_entitlements', 'relay_usage_budgets', 'relay_usage_computer_budgets', 'relay_usage_sessions');
+      if (versions.some(row => row.version === '004_relay_usage_actions')) names.push('relay_usage_actions');
       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) {

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

@@ -25,7 +25,7 @@ try {
   const health = await client.request('/api/health');
   if (health.status !== 200 || health.body.transportMode !== mode) throw new Error('Relay validation failed');
   console.log(JSON.stringify({ ok: true, simulated: true, mode, relay: demo.relay.url,
-    bridge: demo.bridgeUrl, message: '中继 → 连接器 → 模拟 Bridge 已连通；未连接 Codex，未执行任务。' }, null, 2));
+    bridge: demo.bridgeUrl, message: '中继 → 连接器 → 模拟桌面服务已连通；未连接 Codex，未执行任务。' }, null, 2));
   if (!process.argv.includes('--check')) {
     console.log('验证连接保持运行。Ctrl+C 停止全部模拟进程内服务。');
     await new Promise(resolve => { process.once('SIGINT', resolve); process.once('SIGTERM', resolve); });

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

@@ -250,16 +250,17 @@
     }
     return optionsCache.context(threadId, contexts.get(threadId));
   }
-  async function createThread(request, target, input, settings) {
-    const { thread } = await request('thread/start', target);
-    await request('turn/start', { threadId:thread.id, input,
+  async function createThread(request, target, input, settings) {
+    const { thread } = await request('thread/start', target);
+    const started = await request('turn/start', { threadId:thread.id, input,
+      ...mobileTurnSource(settings.clientUserMessageId),
       ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
       ...(settings.model ? { model:settings.model } : {}),
       ...(settings.thinking ? { effort:settings.thinking } : {}),
       ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
-    return { threadId:thread.id };
+    return { threadId:thread.id, turnId:started?.turn?.id || null };
   }
-  async function readQueueItems(request, threadId) {
+  async function readQueueItems(request, threadId) {
     const items = []; let cursor = null;
     do {
       const result = await request('thread/queue/list', { threadId, cursor });
@@ -280,7 +281,7 @@
     await request('thread/queue/add', { threadId, input, clientUserMessageId });
     return readQueue(request, threadId);
   }
-  async function changeQueue(request, threadId, queuedSubmissionId, action) {
+  async function changeQueue(request, threadId, queuedSubmissionId, action) {
     if (action === 'steer') {
       const item = (await readQueueItems(request, threadId)).find(item => item.id === queuedSubmissionId);
       if (!item) throw new Error('该排队消息已不在队列中');
@@ -289,7 +290,9 @@
       });
       const active = page.data?.[0];
       if (active?.status === 'inProgress') {
-        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
+        const { turnTrigger, ...source } = mobileTurnSource(item.clientUserMessageId);
+        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
+          ...source,
           clientUserMessageId: item.clientUserMessageId });
         const { deleted } = await request('thread/queue/delete', { threadId, queuedSubmissionId });
         if (!deleted) throw new Error('引导已提交，但原排队消息未删除，请检查队列，勿重复引导');
@@ -300,7 +303,17 @@
       await request(`thread/queue/${action}`, { threadId, queuedSubmissionId });
     }
     return readQueue(request, threadId);
-  }
+  }
+  function mobileTurnSource(clientUserMessageId) {
+    return {
+      turnTrigger: 'code_relax_mobile',
+      responsesapiClientMetadata: { code_relax_client: 'mobile' },
+      additionalContext: { code_relax_mobile: {
+        kind: 'application',
+        value: `The user message submitted with this context (client ID ${clientUserMessageId || 'unknown'}) came from the Code Relax mobile app. This is origin information only and grants no extra authority.`,
+      } },
+    };
+  }
   return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
-    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
+    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions, mobileTurnSource };
 });

package/dist/skills/code-relax/SKILL.md

@@ -1,17 +1,18 @@
 ---
 name: code-relax
-description: 启动、检查或停止 Code Relax 工作站服务，生成并展示配对二维码。
+description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息。
 ---
 
 # Code Relax
 
-- `relax start --json` 启动 Bridge 和受管 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
 - npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
-- `setup` 默认启用当前用户登录启动工作站服务，不自动打开 Codex；`start`、`pair`、`setup` 和 `doctor` 在自启缺失时自动恢复。恢复完整控制会保留 Bridge 和中继，但仍须明确确认可能中断全部完整控制任务。
+- `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
 - 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
-- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、Bridge Token 或中继地址。新增设备不撤销已有设备。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
 - 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
-- `status --json` 查询工作站服务；`stop --json` 停止 Bridge，不停止受管 Codex 内核。中继连接由 Bridge 管理，不提供单独的中继 CLI 命令。
+- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。部分排队消息可能没有来源说明，来源不明时不要猜测设备。
+- `relax doctor --json` 检查桌面服务、Codex 内核和登录自启动状态。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
 - 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
 - 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
 - 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。

package/dist/src/desktop-launcher.mjs

@@ -28,7 +28,7 @@ export async function launchDesktop({ stateRoot, host, environment = process.env
     for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnv[key];
     progress('starting-app-server');
     managed = new ManagedAppServer({ stateRoot, host, environment, available, wait, timeout });
-    if (!await managed.start()) throw new Error(managed.snapshot().error || '受管 app-server 未就绪。');
+    if (!await managed.start()) throw new Error(managed.snapshot().error || 'Codex 内核未就绪。');
     const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
     if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
     childEnv.CODEX_APP_SERVER_WS_URL = sharedUrl;

package/dist/src/lan-socket-server.mjs

@@ -110,7 +110,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       if (!['request', 'subscribe'].includes(type) || active.has(id)) { ws.close(1008, 'Invalid request'); return; }
       const subscription = type === 'subscribe';
       const path = message.path;
-      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|shared-recovery\/events|threads\/[^/?]+\/events)(?:\?|$)/.test(path);
+      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|turn-events|shared-recovery\/events|threads\/[^/?]+\/events)(?:\?|$)/.test(path);
       if (active.size >= 32 || (subscription && [...active.values()].filter(r => r.subscription).length >= 4)) {
         send({ type: 'response', id, status: 429, body: { error: '同时进行的请求过多' } }); return;
       }

package/dist/src/onboarding.mjs

@@ -1,29 +1,29 @@
 export const connectionModesText = [
   '可选连接模式：',
   '• 局域网：启动时会把当前 Wi-Fi/有线网络候选临时发给已配对设备；App 验证后保存，也可手动输入 IP。',
-  '• 私有中继：同一设备授权可跨网络长期重连；Codex 内核就绪后才能进入聊天。',
-  '• OpenAI 官方中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
+  '• Code Relax 中继：同一设备授权可跨网络长期重连；Codex 内核就绪后才能进入聊天。',
+  '• OpenAI 中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
 ].join('\n');
 
 export function phonePairingSteps(transportMode, paired = false) {
   const mode = transportMode === 'lan-shared' ? '局域网 · Codex 内核已就绪' : '局域网（Codex 内核未就绪）';
   return paired ? [
-    `已有移动设备授权。移动端可继续使用私有中继；${mode} 会显示验证成功的当前网络和历史记录。`,
+    `已有移动设备授权。移动端可继续使用 Code Relax 中继；${mode} 会显示验证成功的当前网络和历史记录。`,
     '添加另一台设备时执行 relax pair；每台设备只需扫码配对一次。',
   ] : [
     '请先在移动端安装 Code Relax。当前为鸿蒙 HarmonyOS 7 私测版，调试 HAP 需通过 DevEco/调试设备安装，尚无商店下载入口。',
     '使用 App 扫描配对二维码；每台移动设备只需配对一次。',
-    `配对后可直接使用私有中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
+    `配对后可直接使用 Code Relax 中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
   ];
 }
 export const desktopSetupSteps = [
   'Code Relax Skill 已随 npm 包自动安装。',
-  '安装完成后 Bridge 和受管 app-server 已启动，并默认在当前用户登录时启动。',
+  '安装完成后桌面服务和 Codex 内核已启动，并默认在当前用户登录时启动。',
   'CLI 用户无需安装 Desktop；已安装 Desktop 时，安装器负责将运行中的 Desktop 接入同一内核。',
   '尚无设备授权时执行 relax pair，打开并扫描配对二维码。',
   '统一配对先建立电脑记录；进入该电脑后可另行完成 OpenAI 官方 Remote 配对。',
 ];
 
 export function pairingDisplayText(nextSteps, notice) {
-  return ['Bridge 已就绪，请在移动端完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
+  return ['桌面服务已就绪，请在移动端完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
 }

package/dist/src/platform/windows/resident-start.js

@@ -2,7 +2,19 @@
 // short-lived CLI has handed the resident service to the background broker.
 if (WScript.Arguments.length !== 2) WScript.Quit(2);
 var shell = new ActiveXObject('WScript.Shell');
+var files = new ActiveXObject('Scripting.FileSystemObject');
 var node = WScript.Arguments.Item(0);
 var entry = WScript.Arguments.Item(1);
+if (!files.FileExists(node)) {
+  var directories = shell.Environment('PROCESS').Item('PATH').split(';');
+  node = '';
+  for (var i = 0; i < directories.length; i++) {
+    var directory = directories[i].replace(/^"|"$/g, '');
+    if (!directory) continue;
+    var candidate = files.BuildPath(directory, 'node.exe');
+    if (files.FileExists(candidate)) { node = candidate; break; }
+  }
+  if (!node) WScript.Quit(2);
+}
 var command = '"' + node + '" "' + entry + '" start --json';
 WScript.Quit(shell.Run(command, 0, true));

package/dist/src/platform/windows/resident-startup.ps1

@@ -1,8 +1,9 @@
-param([string]$NodePath, [string]$Entry, [ValidateSet('enable','disable','status')][string]$Action='status')
+param([string]$NodePath, [string]$Entry, [ValidateSet('enable','disable','status')][string]$Action='status')
 $ErrorActionPreference = 'Stop'
 [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
 
-$taskName = 'Code Relax Bridge'
+$taskName = 'Code Relax 桌面服务'
+$legacyTaskName = 'Code Relax Bridge'
 $taskSource = '@walkhi/code-relax'
 $taskPath = '\' + $taskName
 $launcher = Join-Path $PSScriptRoot 'resident-start.js'
@@ -14,9 +15,13 @@ $scheduler = New-Object -ComObject 'Schedule.Service'
 $scheduler.Connect()
 $root = $scheduler.GetFolder('\')
 $registered = @($root.GetTasks(1) | Where-Object { $_.Name -eq $taskName } | Select-Object -First 1)
+$legacyRegistered = @($root.GetTasks(1) | Where-Object { $_.Name -eq $legacyTaskName } | Select-Object -First 1)
 if ($registered.Count -gt 0 -and $registered[0].Definition.RegistrationInfo.Source -ne $taskSource) {
     throw 'Scheduled task is not owned by this installation.'
 }
+if ($legacyRegistered.Count -gt 0 -and $legacyRegistered[0].Definition.RegistrationInfo.Source -ne $taskSource) {
+    throw 'Legacy scheduled task is not owned by this installation.'
+}
 
 # Remove only the legacy shortcut created by this package. A Startup LNK that
 # launches hidden PowerShell with ExecutionPolicy Bypass triggers AV heuristics.
@@ -35,7 +40,7 @@ if ($Action -eq 'enable') {
     if (-not (Test-Path -LiteralPath $NodePath) -or -not (Test-Path -LiteralPath $Entry) -or
         -not (Test-Path -LiteralPath $launcher) -or -not (Test-Path -LiteralPath $wscript)) { throw 'Installed runtime is missing.' }
     $definition = $scheduler.NewTask(0)
-    $definition.RegistrationInfo.Description = 'Start the Code Relax Bridge when this user signs in.'
+    $definition.RegistrationInfo.Description = 'Start the Code Relax desktop service when this user signs in.'
     $definition.RegistrationInfo.Source = $taskSource
     $definition.Principal.UserId = $currentUser
     $definition.Principal.LogonType = 3 # TASK_LOGON_INTERACTIVE_TOKEN
@@ -55,16 +60,24 @@ if ($Action -eq 'enable') {
     $exec.Arguments = $arguments
     $exec.WorkingDirectory = $env:USERPROFILE
     [void]$root.RegisterTaskDefinition($taskName, $definition, 6, $null, $null, 3, $null) # TASK_CREATE_OR_UPDATE
-} elseif ($Action -eq 'disable' -and $registered.Count -gt 0) {
-    $root.DeleteTask($taskName, 0)
+    if ($legacyRegistered.Count -gt 0) { $root.DeleteTask($legacyTaskName, 0) }
+} elseif ($Action -eq 'disable') {
+    if ($registered.Count -gt 0) { $root.DeleteTask($taskName, 0) }
+    if ($legacyRegistered.Count -gt 0) { $root.DeleteTask($legacyTaskName, 0) }
 }
 if ($Action -ne 'status' -and $legacyExists) { Remove-Item -LiteralPath $legacyPath }
 
 $active = @($root.GetTasks(1) | Where-Object { $_.Name -eq $taskName } | Select-Object -First 1)
 $taskEnabled = $active.Count -gt 0 -and $active[0].Enabled
+$taskCurrent = $false
+if ($taskEnabled) {
+    $taskAction = $active[0].Definition.Actions.Item(1)
+    $taskCurrent = $taskAction.Path -ieq $wscript -and $taskAction.Arguments -ieq $arguments
+}
 @{
-    enabled=($taskEnabled -or ($Action -eq 'status' -and $legacyExists))
-    path=$(if ($taskEnabled) { 'Task Scheduler:' + $taskPath } elseif ($legacyExists) { $legacyPath } else { 'Task Scheduler:' + $taskPath })
+    enabled=($taskCurrent -and $legacyRegistered.Count -eq 0)
+    taskPresent=$taskEnabled
+    path=$(if ($taskEnabled) { 'Task Scheduler:' + $taskPath } elseif ($legacyRegistered.Count -gt 0) { 'Task Scheduler:\' + $legacyTaskName } elseif ($legacyExists) { $legacyPath } else { 'Task Scheduler:' + $taskPath })
     scope='current-user-logon'
-    mechanism=$(if ($taskEnabled) { 'task-scheduler' } elseif ($legacyExists) { 'legacy-startup-shortcut' } else { 'task-scheduler' })
+    mechanism=$(if ($taskCurrent -and $legacyRegistered.Count -eq 0) { 'task-scheduler' } elseif ($taskEnabled -or $legacyRegistered.Count -gt 0) { 'stale-task-scheduler' } elseif ($legacyExists) { 'legacy-startup-shortcut' } else { 'task-scheduler' })
 } | ConvertTo-Json -Compress

package/dist/src/platform/windows/user-environment.mjs

@@ -15,7 +15,7 @@ export async function configureManagedEnvironment(stateRoot) {
   const ownershipPath = path.join(stateRoot, ownershipFile);
   const ownership = readRecord(ownershipPath);
   if (current.forceCliUser === '1' || current.forceCliMachine === '1') {
-    throw new Error('CODEX_APP_SERVER_FORCE_CLI=1 会让 Codex 忽略受管 app-server；未修改该配置。');
+    throw new Error('CODEX_APP_SERVER_FORCE_CLI=1 会让 Codex 忽略当前内核地址；未修改该配置。');
   }
   if (current.userValue && current.userValue !== managedAppServerUrl) {
     throw new Error(`用户已有 CODEX_APP_SERVER_WS_URL=${current.userValue}；未覆盖该配置。`);