@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.6

package/README.md

@@ -80,4 +80,4 @@ npm uninstall -g @walkhi/code-relax
 
 ## 发布边界
 
-registry 当前公开包为 `@walkhi/code-relax@0.1.0-beta.3`，主 CLI 为 `relax`，并保留 `code-relax` 兼容入口。该版将 WMI 后的第二层 PowerShell broker 改为 Node worker，并加入 `%LOCALAPPDATA%\CodexRemote\install.log` 持久安装日志；本机启动交接、npm 打包和公开 registry 已验证，仍需在原故障电脑复核。详细规则见 [npm 分发](../docs/npm-distribution.md)。
+registry 当前公开包为 `@walkhi/code-relax@0.1.0-beta.6`，主 CLI 为 `relax`，并保留 `code-relax` 兼容入口。该版为受管 app-server 记录启动代次，升级发现旧启动链时自动重建进程，使 beta5 的隐藏控制台修复真正生效；`doctor` 会区分安装版本与运行代次。通信协议仍为 7。详细规则见 [npm 分发](../docs/npm-distribution.md)。

package/dist/bin/codex-remote.mjs

@@ -23,7 +23,7 @@ const help = `Code Relax（Windows）
   setup   部署并启动固定目录服务、受管 app-server 和登录自启动；安全配置 Desktop 后续接入
   start   启动或复用 Bridge，并恢复已配置的私有中继
   shared-start 启动或复用完整控制，再启动 Bridge 和已配置的私有中继
-  shared-recover --confirm 启用或重新启动完整控制，保留 Bridge 和中继，可能中断当前任务
+  shared-recover --confirm 重新打开 Desktop 并接入完整控制；不强制重启已有 app-server
   shared-recovery-status 查看最近一次恢复的实际阶段和结果
   autostart-enable / autostart-disable / autostart-status 管理当前用户登录时启动 Bridge
   desktop-start 恢复基础控制，再启动 Bridge（切换前须自行退出 Desktop）
@@ -154,8 +154,8 @@ async function main() {
     result.environment = environment;
     result.skill = skill.managed ? removeSkill() : { removed: false, message: '未移除自定义或未安装的 Skill。' };
     result.message = environment?.preserved
-      ? '固定目录服务已卸载；检测到用户自定义的 CODEX_APP_SERVER_WS_URL，已保留。配置、附件也已保留。npm 命令入口可再用 npm uninstall -g @walkhi/code-relax 移除。'
-      : '固定目录服务已卸载；Code Relax 设置的 app-server 环境变量已清理，其他配置和附件已保留。npm 命令入口可再用 npm uninstall -g @walkhi/code-relax 移除。';
+      ? '固定目录服务已卸载；检测到用户自定义的 CODEX_APP_SERVER_WS_URL，已保留。配置、附件和可能仍在执行任务的 app-server 也已保留；重启 Windows可结束该进程。npm 命令入口可再用 npm uninstall -g @walkhi/code-relax 移除。'
+      : '固定目录服务已卸载；Code Relax 设置的 app-server 环境变量已清理，其他配置、附件和可能仍在执行任务的 app-server 已保留；重启 Windows可结束该进程。npm 命令入口可再用 npm uninstall -g @walkhi/code-relax 移除。';
     console.log(json ? JSON.stringify(result) : `${result.message}\n${result.skill.message}`);
     return;
   }
@@ -205,18 +205,36 @@ async function main() {
     if (!bridge.running || bridge.managedAppServer?.state !== 'ready') {
       throw new Error(bridge.managedAppServer?.error || 'Bridge 已安装，但受管 app-server 未就绪；未写入 Desktop 环境变量。');
     }
+    let managedAppServerMigrated = false;
+    if (bridge.managedAppServer.launcherRestartRequired) {
+      await service.restartManagedAppServer();
+      const migrationDeadline = Date.now() + 40_000;
+      do {
+        await delay(250);
+        bridge = await service.status();
+        if (bridge.managedAppServer?.restart?.status === 'failed') {
+          throw new Error(bridge.managedAppServer.restart.error || '受管 app-server 启动链迁移失败。');
+        }
+      } 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 秒内完成启动链迁移。');
+      }
+      managedAppServerMigrated = true;
+    }
     const autostart = await residentStartup(installed, 'enable');
     const environment = await configureManagedEnvironment(physicalStateRoot);
     installed.autostart = autostart;
     installed.restarted = resumeAfterUpdate;
     installed.environment = environment;
     installed.managedAppServer = bridge.managedAppServer;
+    installed.managedAppServerMigrated = managedAppServerMigrated;
     installed.desktop = bridge.desktop;
     installed.desktopRestartRecommended = bridge.desktop?.state === 'ordinary';
+    const migrationText = managedAppServerMigrated ? '已自动重建旧启动链的 app-server；安装前尚未完成的任务可能已中断。\n' : '';
     const restartText = installed.desktopRestartRecommended
       ? 'Codex 当前仍在使用原连接。可以在手机端选择“立即重启（推荐）”，或稍后自行完全退出再启动。'
       : '下次正常启动 Codex 时会连接受管 app-server。';
-    console.log(json ? JSON.stringify({ ...installed, nextSteps: desktopSetupSteps, displayText: `${desktopSetupSteps.join('\n')}\n${restartText}` }) : `服务已安装：${installed.serviceRoot}\n使用已安装的 Node：${installed.nodeExecutable}\n受管 app-server 已就绪；首次联网可能需要 Windows 防火墙授权。\n${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}\n受管 app-server 已就绪；首次联网可能需要 Windows 防火墙授权。\n${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}`);
     return;
   }
   if (command === 'stop') {

package/dist/src/managed-app-server.mjs

@@ -8,6 +8,7 @@ import { SharedAppServer } from './shared-app-server.mjs';
 
 export const managedAppServerUrl = 'ws://127.0.0.1:45839';
 export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
+export const managedAppServerLauncherRevision = 2;
 const retryDelays = [1_000, 2_000, 5_000, 10_000, 20_000];
 
 export function managedPortAvailable() {
@@ -80,21 +81,26 @@ export class ManagedAppServer extends EventEmitter {
           [path.join(this.stateRoot, 'managed-app-server.stdout.log'), path.join(this.stateRoot, 'managed-app-server.stderr.log')]);
         const started = await this.host.process(pid);
         if (!sameManagedProcess(started, started)) throw new Error('Codex 内核启动后进程身份无法确认。');
-        record = actual = started;
+        actual = started;
+        record = { ...started, launcherRevision: managedAppServerLauncherRevision };
         writeRecord(this.recordPath, record);
       } else if (!readRecord(this.recordPath)) {
-        writeRecord(this.recordPath, actual);
+        record = { ...actual, launcherRevision: Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0 };
+        writeRecord(this.recordPath, record);
       }
       await this.waitUntilReady(actual);
       await this.client.connect();
       if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
       const preferredExecutable = path.resolve(info.cli);
       const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
+      const launcherRevision = Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0;
       this.retryAttempt = 0;
       this.retryAfter = 0;
       this.publish({ state: 'ready', ready: true, error: null, pid: actual.pid,
         created: actual.created, executable: actual.executable, preferredExecutable,
-        updatePending, url: managedAppServerUrl });
+        updatePending, launcherRevision,
+        launcherRestartRequired: launcherRevision !== managedAppServerLauncherRevision,
+        url: managedAppServerUrl });
       return true;
     } catch (error) {
       this.failed(error instanceof Error ? error.message : String(error));

package/dist/src/platform/windows/launch-worker.mjs

@@ -17,7 +17,6 @@ try {
   const descriptors = (spec.logs || []).map(file => fs.openSync(file, 'a'));
   try {
     const child = spawn(spec.executable, spec.args || [], {
-      detached: true,
       windowsHide: true,
       env: spec.environment,
       stdio: ['ignore', descriptors[0] ?? 'ignore', descriptors[1] ?? 'ignore'],
@@ -26,7 +25,8 @@ try {
       child.once('spawn', resolve);
       child.once('error', reject);
     });
-    child.unref();
+    // Keep this WMI-owned broker alive with the target so Codex tools inherit
+    // its hidden console instead of creating a visible console per command.
     result.pid = child.pid;
     diagnostic(`target started (PID ${child.pid})`);
   } finally {

package/dist/src/self-relay/lifecycle.mjs

@@ -1,9 +1,9 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { setTimeout as delay } from 'node:timers/promises';
-import { startBackground, processAlive } from '../background-process.mjs';
-import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { startBackground, processAlive } from '../background-process.mjs';
+import { promisify } from 'node:util';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { hostname } from 'node:os';
@@ -16,8 +16,8 @@ import { connectBridgeRelay } from './connector.mjs';
 import { validProbeIceServers } from './p2p-probe.mjs';
 import { relayAddress, validSecret } from './wire.mjs';
 import { saveLanAuthorizations } from './lan-authorizations.mjs';
-import { lanNetworks } from '../platform/windows/network-info.mjs';
-
+import { lanNetworks } from '../platform/windows/network-info.mjs';
+
 const exec = promisify(execFile);
 const script = fileURLToPath(import.meta.url);
 const recordPath = root => path.join(root, 'self-relay-session.json');
@@ -32,34 +32,33 @@ async function loadConfig(stateRoot) {
   if (config.p2pWindowsRouteHelper !== undefined && typeof config.p2pWindowsRouteHelper !== 'boolean') throw new Error('p2pWindowsRouteHelper 必须是布尔值');
   if (config.p2pWindowsRouteHelper && !/^[A-Za-z0-9_-]{32,128}$/.test(config.p2pWindowsRouteHelperToken || '')) throw new Error('p2pWindowsRouteHelperToken 无效');
   const url = process.env.RELAY_URL || config.url;
-  if (!url) throw new Error('请先配置 self-relay-config.json 的 url 和 hostKeyFile（或 sshHost、sshKeyPath），详见自建中继文档。');
+  if (!url) throw new Error('请先配置 self-relay-config.json 的 url 和 hostKeyFile（或 sshHost、sshKeyPath），详见自建中继文档。');
   relayAddress(url);
   const resolved = relayAddress(url);
   const pairingUrl = config.pairingUrl || `${resolved.startsWith('wss:') ? 'https:' : 'http:'}//${new URL(resolved).host}/pair`;
   const pairing = new URL(pairingUrl);
   if (!['https:', 'http:'].includes(pairing.protocol) || pairing.pathname !== '/pair' || pairing.search || pairing.hash || pairing.username || pairing.password ||
       (pairing.protocol === 'http:' && pairing.hostname !== '127.0.0.1')) throw new Error('self-relay-config.json 的 pairingUrl 必须是 HTTPS /pair 地址。');
-  return { ...config, url: resolved, pairingUrl: pairing.href };
-}
+  return { ...config, url: resolved, pairingUrl: pairing.href };
+}
 async function registrationKey(config) {
   if (config.url === officialConfig.url) return undefined;
   const hostKeyFile = process.env.RELAY_HOST_KEY_FILE || config.hostKeyFile;
-  let hostKey;
-  if (hostKeyFile) hostKey = fs.readFileSync(hostKeyFile, 'utf8').trim();
-  else {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(config.sshHost || '') ||
-      !/^\/[a-zA-Z0-9/_.-]+$/.test(config.sshKeyPath || '')) throw new Error('中继注册凭据配置不完整或无效。');
-    try {
-      const result = await exec('ssh', ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', config.sshHost,
-        `sudo -n cat ${config.sshKeyPath}`], { encoding: 'utf8', timeout: 15000, windowsHide: true });
-      hostKey = result.stdout.trim();
-    } catch { throw new Error('无法通过已配置 SSH 读取中继注册凭据。'); }
-  }
-  if (!validSecret(hostKey)) throw new Error('中继注册凭据格式无效。');
-  return hostKey;
-}
-
-export async function selfRelay(command, stateRoot, requiredMode = '') {
+  let hostKey;
+  if (hostKeyFile) hostKey = fs.readFileSync(hostKeyFile, 'utf8').trim();
+  else {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(config.sshHost || '') ||
+      !/^\/[a-zA-Z0-9/_.-]+$/.test(config.sshKeyPath || '')) throw new Error('中继注册凭据配置不完整或无效。');
+    try {
+      const result = await exec('ssh', ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', config.sshHost,
+        `sudo -n cat ${config.sshKeyPath}`], { encoding: 'utf8', timeout: 15000, windowsHide: true });
+      hostKey = result.stdout.trim();
+    } catch { throw new Error('无法通过已配置 SSH 读取中继注册凭据。'); }
+  }
+  if (!validSecret(hostKey)) throw new Error('中继注册凭据格式无效。');
+  return hostKey;
+}
+export async function selfRelay(command, stateRoot, requiredMode = '') {
   const previous = readRecord(recordPath(stateRoot));
   let current;
   if (previous) {
@@ -139,12 +138,12 @@ async function worker(stateRoot, instanceId, refresh = false, requiredMode = '')
     fs.rmSync(legacyPath);
   }
   let identity = identities.servers[config.url];
-  if (!identity) {
-    identity = { id: randomUUID(), secret: randomBytes(32).toString('base64url'), registered: false };
-    identities.servers[config.url] = identity; await credentialStore('save', identities);
-  }
-  const hostKey = identity.registered ? undefined : await registrationKey(config);
-  let bridgeError = '';
+  if (!identity) {
+    identity = { id: randomUUID(), secret: randomBytes(32).toString('base64url'), registered: false };
+    identities.servers[config.url] = identity; await credentialStore('save', identities);
+  }
+  const hostKey = identity.registered ? undefined : await registrationKey(config);
+  let bridgeError = '';
   async function refreshHealth() {
     try { health = await serviceHealth(session()) || { transportMode: health.transportMode, status: 'offline', desktopConnected: false }; bridgeError = ''; }
     catch (error) { bridgeError = error.message; health = { transportMode: health.transportMode, status: 'offline', desktopConnected: false }; }
@@ -204,7 +203,7 @@ async function worker(stateRoot, instanceId, refresh = false, requiredMode = '')
       await refreshHealth();
       const lanCandidates = await currentLanCandidates();
       connector?.events.removeAllListeners(); connector?.close();
-      const current = connector = connectBridgeRelay({ relayUrl: config.url, hostKey: identity.registered ? undefined : hostKey, identity,
+      const current = connector = connectBridgeRelay({ relayUrl: config.url, hostKey: identity.registered ? undefined : hostKey, identity,
         bridgeUrl: `ws://127.0.0.1:${bridge?.port || 45831}/api/socket`, bridgeToken: bridge?.accessUrl ? new URL(bridge.accessUrl).searchParams.get('token') : 'unavailable',
         bridgeConnection: () => { const latest = session(); return { url: `ws://127.0.0.1:${latest.port}/api/socket`, token: new URL(latest.accessUrl).searchParams.get('token') }; },
         hostName: hostname(), lanCandidates, p2pProbe: config.p2pProbe === true, iceServers: config.p2pIceServers || [],

package/dist/src/server.mjs

@@ -768,8 +768,14 @@ server.on('error', error => {
 server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
   try {
     if (process.env.CODEX_REMOTE_INSTANCE && process.env.CODEX_REMOTE_CONTROL_SECRET && process.env.CODEX_REMOTE_READY_PATH) {
-      control = await openControl({ instanceId: process.env.CODEX_REMOTE_INSTANCE,
-        secret: process.env.CODEX_REMOTE_CONTROL_SECRET, shutdown: shutDown, actions: { 'refresh-execution': refreshExecution } });
+      control = await openControl({ instanceId: process.env.CODEX_REMOTE_INSTANCE,
+        secret: process.env.CODEX_REMOTE_CONTROL_SECRET, shutdown: shutDown, actions: {
+          'refresh-execution': refreshExecution,
+          'restart-managed-app-server': () => {
+            const state = managedAppServer.snapshot();
+            return state.launcherRestartRequired ? managedAppServer.restart(crypto.randomUUID()) : state;
+          },
+        } });
       writeRecord(process.env.CODEX_REMOTE_READY_PATH, { instanceId: process.env.CODEX_REMOTE_INSTANCE,
         pid: process.pid, controlPort: control.port });
     }

package/dist/src/service-doctor.mjs

@@ -40,6 +40,8 @@ export async function doctor({ paths, host, service, skillTarget }) {
         : state.managedAppServer?.error || '受管 app-server 尚未就绪。');
     if (state.managedAppServer?.updatePending) add('managed-app-server-update', 'warning',
       'Codex Desktop 已提供新版 CLI；当前 app-server 会继续完成任务，并在下次进程自然重启或重新登录 Windows 后采用新版。');
+    if (state.managedAppServer?.launcherRestartRequired) add('managed-app-server-launcher', 'warning',
+      '安装文件已经更新，但当前 app-server 仍由旧启动链创建；隐藏控制台等运行时修复尚未生效，请执行 relax setup 或重启 Windows。');
   });
   await check('desktop-environment', async () => {
     const environment = await readManagedEnvironment();

package/dist/src/service-lifecycle.mjs

@@ -61,7 +61,7 @@ export function lifecycle({ stateRoot, host }) {
       desktopRestartRecommended: result?.desktopRestartRecommended === true,
       resident: result?.resident === true };
   }
-  async function pair() {
+  async function pair() {
     const session = readRecord(sessionPath);
     const connection = await alive(session) ? await health(session) : null;
     if (connection?.status !== 'ok' || !session.lan) {
@@ -76,7 +76,12 @@ export function lifecycle({ stateRoot, host }) {
       execution: connection.execution, managedAppServer: connection.managedAppServer, desktop: connection.desktop,
       desktopRestartRecommended: connection.desktopRestartRecommended === true, accessUrl: session.accessUrl,
       qrPath: path.join(stateRoot, 'connection-qr.png') };
-  }
+  }
+  async function restartManagedAppServer() {
+    const session = readRecord(sessionPath);
+    if (!await alive(session)) throw new Error('Bridge 尚未运行，无法迁移受管 app-server。');
+    return controlRequest(session, 'POST', 'restart-managed-app-server');
+  }
   async function start() {
     let session = readRecord(sessionPath);
     if (await alive(session)) {
@@ -126,5 +131,5 @@ export function lifecycle({ stateRoot, host }) {
       throw error;
     } finally { fs.rmSync(readyPath, { force: true }); }
   }
-  return { start, pair, status, stop };
-}
+  return { start, pair, status, stop, restartManagedAppServer };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.4",
+  "version": "0.1.0-beta.6",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {