@walkhi/code-relax 0.1.0-beta.11 → 0.1.0-beta.13

package/dist/bin/codex-remote.mjs

@@ -15,11 +15,14 @@ import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 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 { configureManagedEnvironment, clearManagedEnvironment, readManagedEnvironment } from '../src/platform/windows/user-environment.mjs';
 import { resolveCodexRuntime } from '../src/platform/windows/codex-runtime.mjs';
+import { managedAppServerUrl } from '../src/managed-app-server.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|pair|status|stop> [--json]
+用法：relax <命令> [--json]；下列命令均可用
   setup   部署并启动固定目录服务、受管 app-server 和登录自启动；安全配置 Desktop 后续接入
   start   启动或复用 Bridge 和 Codex 内核，并恢复已配置的私有中继
   shared-recover --confirm 重新打开 Desktop 并接入 Codex 内核；不强制重启已有内核
@@ -72,8 +75,33 @@ async function main() {
   if (command.startsWith('autostart-')) {
     const installation = readRecord(path.join(serviceRoot, 'installation.json'));
     if (!installation?.nodeExecutable) throw new Error('请先执行 setup。');
-    const result = await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, command.slice('autostart-'.length));
-    console.log(json ? JSON.stringify(result) : `登录启动：${result.enabled ? '已启用' : '已关闭'}`); return;
+    const action = command.slice('autostart-'.length);
+    let environment;
+    if (action === 'disable') {
+      environment = await clearManagedEnvironment(stateRoot);
+      const current = await readManagedEnvironment();
+      if (current.userValue === managedAppServerUrl || (!current.userValue && current.machineValue === managedAppServerUrl)) {
+        throw new Error('Desktop 仍会连接 Code Relax 内核；请先处理非本包管理的 CODEX_APP_SERVER_WS_URL，未关闭登录启动。');
+      }
+    }
+    if (action === 'enable') {
+      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 }, action);
+    if (action === 'enable' && (await desktopHost.inspect()).desktop) environment = await configureManagedEnvironment(stateRoot);
+    const output = { ...result, ...(environment ? { environment } : {}) };
+    const environmentText = environment?.preserved ? '；用户自定义的 Desktop 地址已保留，请自行核对' :
+      environment?.removed ? '；已清除 Code Relax 设置的 Desktop 地址' :
+        environment?.configured ? '；已配置 Desktop 接入地址' : '';
+    console.log(json ? JSON.stringify(output) : `登录启动：${result.enabled ? '已启用' : '已关闭'}${environmentText}`); return;
   }
   if (command === 'shared-recover' || command === 'shared-recovery-status') {
     if (command === 'shared-recover' && !flags.includes('--confirm')) throw new Error(recoveryWarning + ' 使用 --confirm 确认。');
@@ -145,7 +173,8 @@ async function main() {
     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 () => {
@@ -165,7 +194,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(); },

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/server-requests.cjs

@@ -1,67 +1,95 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexServerRequests = factory();
-})(globalThis, function () {
-  const command = 'item/commandExecution/requestApproval';
-  const file = 'item/fileChange/requestApproval';
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexServerRequests = factory();
+})(globalThis, function () {
+  const command = 'item/commandExecution/requestApproval';
+  const file = 'item/fileChange/requestApproval';
   const input = 'item/tool/requestUserInput';
+  const elicitation = 'mcpServer/elicitation/request';
   const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  function browserAccess(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.tool_name !== 'access_browser_origin'
+      || meta.codex_approval_kind !== 'mcp_tool_call' || meta.codex_request_type !== 'approval_request'
+      || meta.codex_sensitive_action !== true || p.requestedSchema?.type !== 'object'
+      || Object.keys(p.requestedSchema.properties || {}).length) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['http:', 'https:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+      return { origin: meta.origin, persistent: meta.persist === 'always' };
+    } catch { return null; }
+  }
   function decisions(request) {
-    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
     if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    const browser = browserAccess(request);
+    if (browser) return browser.persistent ? ['allowOnce', 'allowSite', 'allowAllSites', 'decline'] : ['allowOnce', 'decline'];
     return [];
-  }
-  function validate(request, result) {
-    if ([command, file].includes(request.method)) {
-      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
-      return;
-    }
+  }
+  function validate(request, result) {
+    if ([command, file].includes(request.method)) {
+      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
+      return;
+    }
     if (request.method === input) {
-      const questions = request.params.questions || [];
-      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
-        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
+      const questions = request.params.questions || [];
+      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
+        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
       return;
     }
-    throw new Error('此类请求需在工作站处理');
-  }
-  class Store {
-    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
-    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
-    receive(message) {
-      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
-      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
-      this.requests.set(message.id, request); this.changed(request.params.threadId);
-    }
-    notification(method, params) {
-      if (method === 'serverRequest/resolved') {
-        const request = this.requests.get(params.requestId);
-        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
-      } else if (method === 'turn/completed' || method === 'thread/closed') {
-        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
-        this.changed(params.threadId);
-      }
-    }
-    forget(threadId) {
-      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
-      this.changed(threadId);
-    }
-    reset(epoch) {
-      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
-      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
-    }
-    async respond(threadId, { id, epoch, result }, send) {
-      const request = this.requests.get(id);
-      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
-      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
-      validate(request, result);
-      request.status = 'submitted'; this.changed(threadId);
-      try { await send({ id: request.id, result }); }
-      catch (error) {
-        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
-        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
-      }
-      return { submitted: true };
+    const browser = browserAccess(request);
+    if (browser) {
+      const allowed = [
+        { action: 'accept', content: {}, _meta: null },
+        { action: 'decline', content: null, _meta: null },
+      ];
+      if (browser.persistent) allowed.push(
+        { action: 'accept', content: {}, _meta: { persist: 'always' } },
+        { action: 'accept', content: {}, _meta: { persist: 'always', browser_use_persistent_approval_scope: 'all-sites' } },
+      );
+      if (!allowed.some(choice => equal(choice, result))) throw new Error('网站访问决定不属于当前请求');
+      return;
     }
-  }
-  return { Store, decisions, validate, command, file, input };
-});
+    throw new Error('此类请求需在工作站处理');
+  }
+  class Store {
+    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
+    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    receive(message) {
+      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
+      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
+      this.requests.set(message.id, request); this.changed(request.params.threadId);
+    }
+    notification(method, params) {
+      if (method === 'serverRequest/resolved') {
+        const request = this.requests.get(params.requestId);
+        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
+      } else if (method === 'turn/completed' || method === 'thread/closed') {
+        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
+        this.changed(params.threadId);
+      }
+    }
+    forget(threadId) {
+      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
+      this.changed(threadId);
+    }
+    reset(epoch) {
+      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
+      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
+    }
+    async respond(threadId, { id, epoch, result }, send) {
+      const request = this.requests.get(id);
+      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
+      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
+      validate(request, result);
+      request.status = 'submitted'; this.changed(threadId);
+      try { await send({ id: request.id, result }); }
+      catch (error) {
+        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
+        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
+      }
+      return { submitted: true };
+    }
+  }
+  return { Store, decisions, validate, command, file, input, elicitation, browserAccess };
+});

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

@@ -5,7 +5,7 @@ import { EventEmitter } from 'node:events';
 import { setTimeout as delay } from 'node:timers/promises';
 import { readRecord, writeRecord } from './service-lifecycle.mjs';
 import { SharedAppServer } from './shared-app-server.mjs';
-import { resolveCodexRuntime } from './platform/windows/codex-runtime.mjs';
+import { pruneRetainedDesktopRuntimes, resolveCodexRuntime, runtimeFilesAvailable } from './platform/windows/codex-runtime.mjs';
 
 export const managedAppServerUrl = 'ws://127.0.0.1:45839';
 export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
@@ -74,9 +74,14 @@ export class ManagedAppServer extends EventEmitter {
       const candidate = readRecord(this.recordPath);
       const process = candidate?.pid ? await this.host.process(candidate.pid) : null;
       if (sameManagedProcess(candidate, process)) { record = candidate; actual = process; }
-      const runtime = actual
-        ? readRecord(path.join(this.stateRoot, 'codex-runtime.json')) || { executable: actual.executable }
-        : await resolveCodexRuntime(this.stateRoot, { environment: this.environment });
+      const startedHere = !actual;
+      const savedRuntime = actual ? readRecord(path.join(this.stateRoot, 'codex-runtime.json')) : null;
+      const runtime = actual && savedRuntime?.executable && runtimeFilesAvailable(savedRuntime.executable)
+        ? savedRuntime
+        : await resolveCodexRuntime(this.stateRoot, { refresh: !actual, environment: this.environment });
+      if (actual && !runtimeFilesAvailable(actual.executable)) {
+        throw new Error(`运行中的 Codex 内核目录已被移除或缺少 codex-code-mode-host.exe：${actual.executable}；已找到可用内核 ${runtime.executable}，请确认重启内核。`);
+      }
       if (!actual) {
         if (!await this.available()) throw new Error('45839 被未识别进程占用，未启动或结束任何进程。');
         const childEnvironment = { ...this.environment };
@@ -99,6 +104,10 @@ export class ManagedAppServer extends EventEmitter {
       await this.waitUntilReady(actual);
       await this.client.connect();
       if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
+      if (startedHere) {
+        try { pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
+        catch (error) { console.error('旧版 Codex 内核文件清理失败：', error); }
+      }
       const preferredExecutable = path.resolve(runtime.executable);
       const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
       const launcherRevision = Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0;

package/dist/src/platform/windows/codex-runtime.mjs

@@ -3,6 +3,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { readRecord, writeRecord } from '../../service-lifecycle.mjs';
 
@@ -11,7 +13,130 @@ const requiredMethods = ['thread/start', 'thread/resume', 'thread/list', 'thread
   'thread/items/list', 'turn/start', 'turn/steer', 'turn/interrupt', 'model/list', 'project/list',
   'thread/settings/update', 'configRequirements/read', 'thread/queue/list', 'thread/queue/add',
   'thread/queue/delete', 'thread/queue/start', 'thread/read', 'thread/unsubscribe', 'config/read', 'account/rateLimits/read'];
-const fingerprint = file => { const s = fs.statSync(file); return `${s.size}:${s.mtimeMs}`; };
+export const codeModeHostPath = executable => path.join(path.dirname(executable), 'codex-code-mode-host.exe');
+export const runtimeFilesAvailable = executable => fs.existsSync(executable) && fs.existsSync(codeModeHostPath(executable));
+const fingerprint = executable => [executable, codeModeHostPath(executable)]
+  .map(file => { const s = fs.statSync(file); return `${s.size}:${s.mtimeMs}`; }).join('|');
+const powershell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+const desktopRuntimeScript = path.join(path.dirname(fileURLToPath(import.meta.url)), 'desktop-runtime.ps1');
+
+async function fileHash(file) {
+  const hash = createHash('sha256');
+  for await (const chunk of fs.createReadStream(file)) hash.update(chunk);
+  return hash.digest('hex');
+}
+
+async function installedDesktopRuntime() {
+  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+    '-File', desktopRuntimeScript], { windowsHide: true, encoding: 'utf8', timeout: 30000 });
+  return JSON.parse(stdout.trim());
+}
+
+async function matchesInstalledDesktop(executable, installed) {
+  if (!installed || !runtimeFilesAvailable(executable) || !runtimeFilesAvailable(installed.executable)) return false;
+  const files = [[executable, installed.executable], [codeModeHostPath(executable), installed.codeModeHost]];
+  for (const [candidate, bundled] of files) {
+    if (fs.statSync(candidate).size !== fs.statSync(bundled).size || await fileHash(candidate) !== await fileHash(bundled)) return false;
+  }
+  return true;
+}
+
+function runtimeFiles(directory, relative = '') {
+  const files = [];
+  for (const entry of fs.readdirSync(path.join(directory, relative), { withFileTypes: true })) {
+    const name = path.join(relative, entry.name);
+    if (entry.isDirectory()) files.push(...runtimeFiles(directory, name));
+    else if (entry.isFile()) files.push(name);
+    else throw new Error(`Codex 内核目录包含不支持的文件类型：${name}`);
+  }
+  return files.sort();
+}
+
+function runtimeDirectories(files) {
+  const directories = new Set();
+  for (const file of files) {
+    let directory = path.dirname(file);
+    while (directory !== '.') { directories.add(directory); directory = path.dirname(directory); }
+  }
+  return [...directories].sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
+}
+
+async function retainDesktopRuntime(executable, installed, stateRoot) {
+  if (!/^[\w.-]+$/.test(installed.package)) throw new Error('Codex Desktop 安装包名称无效。');
+  const source = path.dirname(executable);
+  const files = runtimeFiles(source);
+  if (files.includes('runtime.json')) throw new Error('Codex 内核目录与保留清单文件名冲突。');
+  const directories = runtimeDirectories(files);
+  const root = path.join(stateRoot, 'desktop-runtimes');
+  const target = path.join(root, installed.package);
+  const retained = path.join(target, 'codex.exe');
+  if (fs.existsSync(target)) {
+    const manifest = readRecord(path.join(target, 'runtime.json'));
+    if (manifest?.package !== installed.package || JSON.stringify(manifest.files) !== JSON.stringify(files)
+      || JSON.stringify(runtimeFiles(target)) !== JSON.stringify([...files, 'runtime.json'].sort())
+      || !await matchesInstalledDesktop(retained, installed)) {
+      throw new Error(`已保留的 Codex 内核文件不完整：${target}`);
+    }
+    return retained;
+  }
+  fs.mkdirSync(root, { recursive: true });
+  const staging = path.join(root, `.${installed.package}.${randomUUID()}.tmp`);
+  fs.mkdirSync(staging);
+  const created = [];
+  try {
+    for (const directory of directories) fs.mkdirSync(path.join(staging, directory));
+    for (const name of files) {
+      const from = path.join(source, name), to = path.join(staging, name);
+      created.push(to);
+      try { fs.linkSync(from, to); }
+      catch (error) {
+        if (error.code !== 'EXDEV') throw error;
+        fs.copyFileSync(from, to);
+      }
+    }
+    if (!await matchesInstalledDesktop(path.join(staging, 'codex.exe'), installed)) {
+      throw new Error('保留的 Codex 内核与当前安装包不一致。');
+    }
+    const manifestPath = path.join(staging, 'runtime.json');
+    writeRecord(manifestPath, { package: installed.package, files });
+    created.push(manifestPath);
+    fs.renameSync(staging, target);
+    return retained;
+  } catch (error) {
+    for (const file of created) fs.rmSync(file, { force: true });
+    for (const directory of directories.reverse()) {
+      const nested = path.join(staging, directory);
+      if (fs.existsSync(nested)) fs.rmdirSync(nested);
+    }
+    fs.rmdirSync(staging);
+    throw error;
+  }
+}
+
+export function pruneRetainedDesktopRuntimes(stateRoot, keepExecutable) {
+  const root = path.join(stateRoot, 'desktop-runtimes');
+  if (!fs.existsSync(root)) return;
+  const keep = path.resolve(path.dirname(keepExecutable)).toLowerCase();
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^OpenAI\.Codex_[\w.-]+$/.test(entry.name)) continue;
+    const directory = path.join(root, entry.name);
+    if (path.resolve(directory).toLowerCase() === keep || fs.lstatSync(directory).isSymbolicLink()) continue;
+    const manifest = readRecord(path.join(directory, 'runtime.json'));
+    const files = manifest?.files;
+    if (manifest?.package !== entry.name || !Array.isArray(files) || !files.includes('codex.exe')
+      || !files.includes('codex-code-mode-host.exe') || new Set(files).size !== files.length
+      || !files.every(name => typeof name === 'string' && name !== 'runtime.json'
+        && path.resolve(directory, name).toLowerCase().startsWith(`${path.resolve(directory).toLowerCase()}${path.sep}`))) continue;
+    const expected = [...files, 'runtime.json'].sort();
+    if (JSON.stringify(runtimeFiles(directory)) !== JSON.stringify(expected)) continue;
+    if (!fs.lstatSync(path.join(directory, 'runtime.json')).isFile()
+      || !files.every(name => fs.lstatSync(path.join(directory, name)).isFile())) continue;
+    for (const name of files) fs.unlinkSync(path.join(directory, name));
+    fs.unlinkSync(path.join(directory, 'runtime.json'));
+    for (const name of runtimeDirectories(files).reverse()) fs.rmdirSync(path.join(directory, name));
+    fs.rmdirSync(directory);
+  }
+}
 
 // Resolve native binaries, never execute a shell shim from a background task.
 export function discoverCodex(environment = process.env) {
@@ -92,11 +217,18 @@ export async function resolveCodexRuntime(stateRoot, { refresh = false, environm
   environment = { ...environment,
     CODEX_HOME: environment.CODEX_HOME || saved?.codexHome || path.join(os.homedir(), '.codex'),
     CODE_RELAX_CODEX_PATH: environment.CODE_RELAX_CODEX_PATH || (saved?.source === 'explicit' ? saved.executable : '') };
-  if (!refresh && saved?.executable && fs.existsSync(saved.executable)
+  if (!refresh && saved?.executable && runtimeFilesAvailable(saved.executable)
     && saved.fingerprint === fingerprint(saved.executable)) return saved;
   const candidates = [], rejected = [];
+  let installed = null;
+  try { installed = await installedDesktopRuntime(); }
+  catch (error) { rejected.push(`无法读取当前 Codex Desktop 安装包：${error.message}`); }
   for (const candidate of discoverCodex(environment)) {
     try {
+      if (!runtimeFilesAvailable(candidate.executable)) throw new Error('缺少同目录的 codex-code-mode-host.exe');
+      if (candidate.source === 'desktop' && !await matchesInstalledDesktop(candidate.executable, installed)) {
+        throw new Error('不是当前 Codex Desktop 安装包配套的 CLI');
+      }
       const { stdout } = await exec(candidate.executable, ['--version'], { windowsHide: true, timeout: 10000 });
       const version = /^codex-cli (\d+\.\d+\.\d+(?:-[\w.]+)?)/m.exec(stdout)?.[1];
       if (!version) throw new Error('无法识别版本');
@@ -106,8 +238,10 @@ export async function resolveCodexRuntime(stateRoot, { refresh = false, environm
   candidates.sort((a, b) => Number(b.source === 'desktop') - Number(a.source === 'desktop') || compareVersions(b.version, a.version));
   for (const candidate of candidates) {
     try {
-      await verifyProtocol(candidate.executable, stateRoot);
-      const result = { ...candidate, fingerprint: fingerprint(candidate.executable),
+      const executable = candidate.source === 'desktop'
+        ? await retainDesktopRuntime(candidate.executable, installed, stateRoot) : candidate.executable;
+      await verifyProtocol(executable, stateRoot);
+      const result = { ...candidate, executable, fingerprint: fingerprint(executable),
         codexHome: path.resolve(environment.CODEX_HOME || path.join(os.homedir(), '.codex')) };
       writeRecord(recordFile, result);
       return result;

package/dist/src/platform/windows/desktop-runtime.ps1

@@ -0,0 +1,10 @@
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+$package = Get-AppxPackage OpenAI.Codex | Select-Object -First 1
+if (-not $package) { 'null'; exit }
+$resources = Join-Path $package.InstallLocation 'app\resources'
+@{
+    package = $package.PackageFullName
+    executable = Join-Path $resources 'codex.exe'
+    codeModeHost = Join-Path $resources 'codex-code-mode-host.exe'
+} | ConvertTo-Json -Compress

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

@@ -0,0 +1,8 @@
+// Windows Script Host has no console. Keep the login task alive until the
+// 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 node = WScript.Arguments.Item(0);
+var entry = WScript.Arguments.Item(1);
+var command = '"' + node + '" "' + entry + '" start --json';
+WScript.Quit(shell.Run(command, 0, true));