@walkhi/code-relax 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/src/platform/macos/retained-runtime.mjs

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { readRecord, writeRecord } from '../../service-lifecycle.mjs';
+
+const owner = 'code-relax-macos-runtime';
+const manifestName = '.code-relax-runtime.json';
+function filesAt(root, relative = '') {
+  const result = [];
+  if (fs.lstatSync(root).isSymbolicLink()) throw new Error('Codex 运行时目录不能是符号链接。');
+  for (const entry of fs.readdirSync(path.join(root, relative), { withFileTypes: true })) {
+    const name = path.join(relative, entry.name);
+    if (entry.isDirectory()) result.push(...filesAt(root, name));
+    else if (entry.isFile()) result.push(name);
+    else throw new Error(`Codex 运行时包含不支持的链接或文件：${name}`);
+  }
+  return result.sort();
+}
+export function packageRoot(executable) {
+  const bundleSuffix = path.join('CodexCLI.app', 'Contents', 'MacOS', 'codex');
+  const bundled = executable.endsWith(path.sep + bundleSuffix);
+  const root = bundled ? path.resolve(executable, '../../../..') : path.dirname(path.dirname(executable));
+  const metadata = readRecord(path.join(root, 'codex-package.json'));
+  if ((!bundled && path.basename(path.dirname(executable)) !== 'bin') || path.basename(executable) !== 'codex'
+      || metadata?.layoutVersion !== 1 || metadata.entrypoint !== 'bin/codex' || metadata.variant !== 'codex'
+      || !['aarch64-apple-darwin', 'x86_64-apple-darwin'].includes(metadata.target)
+      || metadata.resourcesDir !== 'codex-resources' || metadata.pathDir !== 'codex-path')
+    throw new Error('需要完整的官方 Mac Codex 运行时包，不能仅复制 codex 单个文件。');
+  for (const file of ['bin/codex', 'bin/codex-code-mode-host', 'codex-path/rg']) {
+    if (!fs.statSync(path.join(root, file)).isFile()) throw new Error(`Codex 运行时缺少 ${file}`);
+  }
+  if (!fs.statSync(path.join(root, 'codex-resources')).isDirectory()) throw new Error('Codex 运行时缺少资源目录。');
+  return root;
+}
+export function runtimeFingerprint(executable) {
+  const root = packageRoot(executable);
+  return JSON.stringify(filesAt(root).filter(name => name !== manifestName).map(name => {
+    const stat = fs.statSync(path.join(root, name));
+    return [name, stat.size, stat.mtimeMs, stat.ctimeMs, stat.ino, stat.mode & 0o777];
+  }));
+}
+async function digestFiles(root) {
+  const records = [];
+  for (const name of filesAt(root).filter(name => name !== manifestName)) {
+    const file = path.join(root, name), hash = createHash('sha256');
+    const before = fs.statSync(file);
+    for await (const chunk of fs.createReadStream(file)) hash.update(chunk);
+    const after = fs.statSync(file);
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || before.ino !== after.ino)
+      throw new Error('Codex 更新正在替换文件，请待安装完成后重试。');
+    records.push({ name, size: after.size, mode: after.mode & 0o777, sha256: hash.digest('hex') });
+  }
+  return records;
+}
+const treeHash = files => createHash('sha256').update(JSON.stringify(files)).digest('hex');
+function removeFiles(root, names) {
+  for (const name of names) {
+    fs.unlinkSync(path.join(root, name));
+  }
+  // Empty package resource directories must also be removed, without recursive deletion.
+  const collect = directory => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory()) throw new Error('运行时清理期间出现未知文件，保留目录。');
+      const child = path.join(directory, entry.name); collect(child); fs.rmdirSync(child);
+    }
+  };
+  collect(root);
+  fs.rmdirSync(root);
+}
+
+export async function retainRuntime(executable, stateRoot, version) {
+  const source = packageRoot(executable);
+  const sourceFingerprint = runtimeFingerprint(executable);
+  const files = await digestFiles(source);
+  if (sourceFingerprint !== runtimeFingerprint(executable)) throw new Error('Codex 包在核对期间发生变化，未切换内核。');
+  const digest = treeHash(files);
+  const parent = path.join(stateRoot, 'macos-runtimes'), target = path.join(parent, digest);
+  const retained = path.join(target, path.relative(source, executable));
+  if (fs.existsSync(target)) {
+    const manifest = readRecord(path.join(target, manifestName));
+    if (manifest?.owner !== owner || manifest.digest !== digest || treeHash(await digestFiles(target)) !== digest)
+      throw new Error('已保留的 Mac 内核内容不完整，未覆盖运行中的文件。');
+    return { executable: retained, sourceExecutable: executable, sourceFingerprint };
+  }
+  fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+  const staging = path.join(parent, `.${randomUUID()}.tmp`);
+  fs.mkdirSync(staging, { mode: 0o700 });
+  const created = [];
+  try {
+    for (const file of files) {
+      const destination = path.join(staging, file.name);
+      fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+      // APFS can clone blocks, but each snapshot has independent file identity.
+      // A hard link would let an in-place npm update modify the running kernel.
+      fs.copyFileSync(path.join(source, file.name), destination, fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE);
+      created.push(file.name);
+      fs.chmodSync(destination, file.mode);
+    }
+    fs.mkdirSync(path.join(staging, 'codex-resources'), { recursive: true, mode: 0o700 });
+    if (treeHash(await digestFiles(staging)) !== digest || sourceFingerprint !== runtimeFingerprint(executable))
+      throw new Error('复制期间 Codex 包发生变化，未使用混合版本。');
+    writeRecord(path.join(staging, manifestName), { owner, digest, version, files });
+    created.push(manifestName);
+    fs.renameSync(staging, target);
+    return { executable: retained, sourceExecutable: executable, sourceFingerprint };
+  } catch (error) {
+    if (fs.existsSync(staging)) removeFiles(staging, created);
+    throw error;
+  }
+}
+
+export async function pruneRetainedDesktopRuntimes(stateRoot, keepExecutable) {
+  const parent = path.join(stateRoot, 'macos-runtimes');
+  if (!fs.existsSync(parent)) return;
+  const keep = packageRoot(path.resolve(keepExecutable));
+  // An installed (non-retained) process is not authority to clean this store.
+  if (path.dirname(keep) !== path.resolve(parent) || !/^[a-f0-9]{64}$/.test(path.basename(keep))) return;
+  for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+    const directory = path.join(parent, entry.name);
+    if (!entry.isDirectory() || !/^[a-f0-9]{64}$/.test(entry.name) || directory === keep) continue;
+    const manifest = readRecord(path.join(directory, manifestName));
+    if (manifest?.owner !== owner || manifest.digest !== entry.name || !Array.isArray(manifest.files)) continue;
+    const actual = await digestFiles(directory);
+    if (treeHash(actual) !== entry.name || JSON.stringify(actual) !== JSON.stringify(manifest.files)) continue;
+    removeFiles(directory, [...actual.map(file => file.name), manifestName]);
+  }
+}

package/dist/src/platform/macos/service-host.mjs

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { runtimePaths } from '../runtime-paths.mjs';
+import { readRecord } from '../../service-lifecycle.mjs';
+import { lanNetworks } from './network-info.mjs';
+import { desktopHost } from './desktop-host.mjs';
+
+export { lanNetworks };
+export const lanAddress = async () => (await lanNetworks())[0]?.address || '';
+export const sharedServiceUrl = () => desktopHost.sharedServiceUrl();
+export async function bridgeEnvironment() {
+  const environment = { ...process.env };
+  const installed = readRecord(path.join(runtimePaths().serviceRoot, 'installation.json'));
+  if (!installed?.nodeExecutable || !fs.existsSync(installed.nodeExecutable)) throw new Error('安装时选用的 Node 不存在，请重新执行 relax setup。');
+  environment.CODEX_MCP_NODE_PATH = installed.nodeExecutable;
+  delete environment.CODEX_APP_TOOLS_PIPE_PATH;
+  return { executable: installed.nodeExecutable, environment };
+}

package/dist/src/platform/macos/system.mjs

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+export const hostBinary = fileURLToPath(new URL('../../../native/macos-host/CodeRelaxHost', import.meta.url));
+export function systemRequest(request) {
+  if (process.platform !== 'darwin') return Promise.reject(new Error('需要 macOS 工作站。'));
+  if (!fs.existsSync(hostBinary)) return Promise.reject(new Error('缺少 Mac 系统适配组件，请先在 Mac 上执行 npm run build。'));
+  return new Promise((resolve, reject) => {
+    const child = spawn(hostBinary, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+    let output = '', diagnostic = '', failure;
+    const timer = setTimeout(() => { failure = new Error('macOS 系统操作超时；请检查钥匙串是否已解锁。'); child.kill(); }, 60000);
+    child.stdout.setEncoding('utf8'); child.stderr.setEncoding('utf8');
+    child.stdout.on('data', value => {
+      output += value;
+      if (Buffer.byteLength(output) > 2 * 1024 * 1024) { failure = new Error('macOS 系统响应过大。'); child.kill(); }
+    });
+    child.stderr.on('data', value => { diagnostic = (diagnostic + value).slice(0, 1024); });
+    child.stdin.on('error', () => {});
+    child.once('error', () => { clearTimeout(timer); reject(new Error('无法启动 macOS 系统适配组件。')); });
+    child.once('close', code => {
+      clearTimeout(timer);
+      if (failure || code !== 0) return reject(failure || new Error(`macOS 系统操作失败：${diagnostic.trim() || code}`));
+      try { resolve(JSON.parse(output)); }
+      catch { reject(new Error('macOS 系统组件返回无效结果。')); }
+    });
+    child.stdin.end(JSON.stringify(request));
+  });
+}

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

@@ -0,0 +1,9 @@
+import { managedEndpointUrl } from '../../managed-endpoint.mjs';
+// Launch Services receives these settings for one new application instance.
+// Do not mutate shell profiles or the login session's global environment.
+export async function configureManagedEnvironment(stateRoot, url) {
+  if (!managedEndpointUrl(url)) throw new Error('未确认 Codex 内核地址。');
+  return { configured: true, changed: false, owned: false, persistent: false,
+    scope: 'application-launch', value: url };
+}
+export async function clearManagedEnvironment() { return { removed: false, preserved: false, reason: 'application-launch-only' }; }

package/dist/src/platform/native-package.mjs

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+export const nativeTargets = Object.freeze({
+  'win32-x64': { packageName: '@walkhi/code-relax-native-win32-x64', file: 'desktop-helper/CodeRelaxDesktop.exe' },
+  'darwin-arm64': { packageName: '@walkhi/code-relax-native-darwin-arm64', file: 'macos-host/CodeRelaxHost' },
+  'darwin-x64': { packageName: '@walkhi/code-relax-native-darwin-x64', file: 'macos-host/CodeRelaxHost' },
+  'linux-x64': { packageName: null, file: null },
+  'linux-arm64': { packageName: null, file: null },
+});
+
+const readJson = file => JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+
+// Native dependencies are selected by npm's os/cpu filters. Materialize only
+// this platform's helper before setup touches the installed workstation.
+export function prepareNativePackage(packageRoot, { platform = process.platform, arch = process.arch } = {}) {
+  const target = nativeTargets[`${platform}-${arch}`];
+  if (!target) throw new Error(`尚不支持此工作站平台：${platform}-${arch}。`);
+  const marker = path.join(packageRoot, 'dist/build-platform.json');
+  const build = readJson(marker);
+  if (!target.file) {
+    const pkg = readJson(path.join(packageRoot, 'package.json'));
+    if (!(build.platform === platform && build.arch === arch)
+        && !(build.layout === 'npm-platform-packages' && build.version === pkg.version))
+      throw new Error('安装包构建与当前系统、架构或版本不匹配，请重新安装。');
+    // Linux adapters use Node/procfs and the session's Secret Service. There is
+    // no private native helper to download; sharp/RTC select their own binaries.
+    fs.writeFileSync(marker, JSON.stringify({ platform, arch, version: pkg.version }));
+    return { platform, arch, materialized: false };
+  }
+  const destination = path.join(packageRoot, 'dist/native', target.file);
+  if (build.platform === platform && build.arch === arch) {
+    if (!fs.statSync(destination).isFile()) throw new Error('安装包缺少当前平台原生组件，请重新安装。');
+    return { platform, arch, materialized: false };
+  }
+  const pkg = readJson(path.join(packageRoot, 'package.json'));
+  if (build.layout !== 'npm-platform-packages' || build.version !== pkg.version)
+    throw new Error('安装包构建与当前系统、架构或版本不匹配，请重新安装。');
+  let manifest;
+  try { manifest = createRequire(path.join(packageRoot, 'package.json')).resolve(`${target.packageName}/package.json`); }
+  catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') throw error;
+    throw new Error(`缺少 ${target.packageName}@${pkg.version}；请勿省略 optional 依赖，使用 npm install -g @walkhi/code-relax@${pkg.version} --include=optional --allow-scripts=@walkhi/code-relax --foreground-scripts 重新安装。`);
+  }
+  const native = readJson(manifest);
+  if (native.name !== target.packageName || native.version !== pkg.version
+      || native.os?.length !== 1 || native.os[0] !== platform || native.cpu?.length !== 1 || native.cpu[0] !== arch)
+    throw new Error('原生组件包的系统、架构或版本不匹配，未更新工作站。');
+  const source = path.join(path.dirname(manifest), 'native', target.file);
+  if (!fs.statSync(source).isFile()) throw new Error('平台包缺少原生组件，未更新工作站。');
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+  if (platform === 'darwin') fs.chmodSync(destination, 0o755);
+  // Only commit the selected platform after the component has been copied.
+  fs.writeFileSync(marker, JSON.stringify({ platform, arch, version: pkg.version }));
+  return { platform, arch, packageName: native.name, materialized: true };
+}

package/dist/src/platform/network-info.mjs

@@ -0,0 +1,3 @@
+import { platformModule } from './select.mjs';
+const adapter = await import(platformModule('network-info'));
+export const { lanNetworks } = adapter;

package/dist/src/platform/path-identity.mjs

@@ -0,0 +1,5 @@
+import path from 'node:path';
+export function executableKey(file, platform = process.platform) {
+  const resolved = path.resolve(file);
+  return platform === 'win32' ? resolved.toLowerCase() : resolved;
+}

package/dist/src/platform/posix/network-candidates.mjs

@@ -0,0 +1,23 @@
+import net from 'node:net';
+
+const privateIpv4 = address => {
+  if (net.isIP(address) !== 4) return false;
+  const [a, b] = address.split('.').map(Number);
+  return a === 10 || (a === 192 && b === 168) || (a === 172 && b >= 16 && b <= 31) || (a === 100 && b >= 64 && b <= 127);
+};
+export function networkCandidates(hardware, addresses) {
+  const results = [];
+  const seen = new Set();
+  for (const item of hardware) {
+    if (!['wifi', 'ethernet'].includes(item.networkType) || typeof item.interfaceName !== 'string') continue;
+    const label = value => String(value).replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 80);
+    const interfaceName = label(item.interfaceName), networkName = label(item.networkName || interfaceName);
+    if (!interfaceName || !networkName) continue;
+    for (const info of addresses[item.interfaceName] || []) {
+      if (info.internal || !privateIpv4(info.address) || seen.has(info.address)) continue;
+      seen.add(info.address);
+      results.push({ address: info.address, interfaceName, networkName, networkType: item.networkType });
+    }
+  }
+  return results.slice(0, 8);
+}

package/dist/src/platform/posix/runtime-paths.mjs

@@ -0,0 +1,25 @@
+import os from 'node:os';
+import path from 'node:path';
+
+// These are user-owned locations; resolving paths does not create or migrate data.
+export function runtimePaths(environment = process.env, home = os.homedir(), platform = process.platform) {
+  if (!['darwin', 'linux'].includes(platform)) throw new Error(`Unsupported POSIX host: ${platform}`);
+  const join = path.posix.join;
+  const xdgRoot = (name, fallback) => path.posix.isAbsolute(environment[name] || '')
+    ? environment[name] : join(home, fallback);
+  const dataRoot = platform === 'darwin'
+    ? join(home, 'Library', 'Application Support', 'CodexRemote')
+    : join(xdgRoot('XDG_DATA_HOME', '.local/share'), 'CodexRemote');
+  const stateRoot = platform === 'darwin'
+    ? join(dataRoot, 'state')
+    : join(xdgRoot('XDG_STATE_HOME', '.local/state'), 'CodexRemote');
+  const codexDataRoot = environment.CODEX_HOME?.trim() || join(home, '.codex');
+  return {
+    codexDataRoot,
+    sessionsRoot: join(codexDataRoot, 'sessions'),
+    stateRoot,
+    serviceRoot: join(dataRoot, 'service'),
+    uploadsRoot: join(dataRoot, 'attachments'),
+    credentialsRoot: join(dataRoot, 'credentials'),
+  };
+}

package/dist/src/platform/power-inhibitor.mjs

@@ -0,0 +1,22 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+// stdin is a lifetime lease: even an abrupt service exit releases the assertion.
+export function launchPowerInhibitor() {
+  const lease = "process.stdin.resume();process.stdin.on('end',()=>process.exit(0));console.log('ready')";
+  let executable, args;
+  if (process.platform === 'darwin') {
+    executable = '/usr/bin/caffeinate';
+    args = ['-i', process.execPath, '-e', lease];
+  } else if (process.platform === 'win32') {
+    executable = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+    args = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+      fileURLToPath(new URL('./windows/keep-awake.ps1', import.meta.url))];
+  } else if (process.platform === 'linux') {
+    executable = '/usr/bin/systemd-inhibit';
+    args = ['--what=idle', '--mode=block', '--who=Code Relax', '--why=Workstation remote access',
+      process.execPath, '-e', lease];
+  } else throw new Error(`保持唤醒不支持当前系统：${process.platform}`);
+  return spawn(executable, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+}

package/dist/src/platform/project-locations.mjs

@@ -0,0 +1,3 @@
+import { platformModule } from './select.mjs';
+const adapter = await import(platformModule('project-locations'));
+export const { projectLocations } = adapter;

package/dist/src/platform/runtime-paths.mjs

@@ -0,0 +1,8 @@
+import { runtimePaths as windowsPaths } from './windows/runtime-paths.mjs';
+import { runtimePaths as posixPaths } from './posix/runtime-paths.mjs';
+
+export function runtimePaths(environment = process.env, home, platform = process.platform) {
+  if (platform === 'win32') return windowsPaths(environment, home);
+  if (platform === 'darwin' || platform === 'linux') return posixPaths(environment, home, platform);
+  throw new Error(`Unsupported workstation platform: ${platform}`);
+}

package/dist/src/platform/select.mjs

@@ -0,0 +1,5 @@
+export function platformModule(name, platform = process.platform) {
+  const directory = { win32: 'windows', darwin: 'macos', linux: 'linux' }[platform];
+  if (!directory) throw new Error(`工作站暂不支持此系统：${platform}`);
+  return new URL(`./${directory}/${name}.mjs`, import.meta.url);
+}

package/dist/src/platform/service-host.mjs

@@ -0,0 +1,3 @@
+import { platformModule } from './select.mjs';
+const adapter = await import(platformModule('service-host'));
+export const { sharedServiceUrl, lanAddress, lanNetworks, bridgeEnvironment } = adapter;

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

@@ -0,0 +1,3 @@
+import { platformModule } from './select.mjs';
+const adapter = await import(platformModule('user-environment'));
+export const { configureManagedEnvironment, clearManagedEnvironment } = adapter;

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

@@ -0,0 +1,49 @@
+param(
+    [Parameter(Mandatory=$true)][string]$Executable,
+    [Parameter(Mandatory=$true)][string]$AppServerUrl
+)
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+if ($AppServerUrl -cnotmatch '^ws://127\.0\.0\.1:([1-9][0-9]{0,4})\z' -or [int]$Matches[1] -gt 65535) { throw 'Invalid managed app-server URL.' }
+$package = Get-AppxPackage OpenAI.Codex | Select-Object -First 1
+if (-not $package -or $Executable -ne (Join-Path $package.InstallLocation 'app/ChatGPT.exe')) {
+    throw 'Desktop executable identity changed; activation stopped.'
+}
+# Packaged activation uses the user's environment, not the worker's env block.
+# Installation already owns and broadcasts this setting. Do not silently launch
+# a separate app-server if it has been removed or changed since installation.
+if ([Environment]::GetEnvironmentVariable('CODEX_APP_SERVER_WS_URL', 'User') -ne $AppServerUrl) {
+    throw 'Desktop app-server environment differs from the workstation; run relax setup to repair it.'
+}
+if ([Environment]::GetEnvironmentVariable('CODEX_APP_SERVER_FORCE_CLI', 'User') -eq '1' -or
+    [Environment]::GetEnvironmentVariable('CODEX_APP_SERVER_FORCE_CLI', 'Machine') -eq '1') {
+    throw 'CODEX_APP_SERVER_FORCE_CLI=1 prevents Desktop from connecting to the workstation.'
+}
+# Activate the registered application so Windows supplies its MSIX identity.
+# Never spawn ChatGPT.exe through the hidden-console broker: a bootstrap failure
+# can leave a windowless Electron singleton blocking subsequent taskbar launches.
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+namespace CodeRelax {
+    [ComImport, Guid("2e941141-7f97-4756-ba1d-9decde894a3d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IApplicationActivationManager {
+        void ActivateApplication([MarshalAs(UnmanagedType.LPWStr)] string appId,
+            [MarshalAs(UnmanagedType.LPWStr)] string arguments, uint options, out uint processId);
+        void ActivateForFile([MarshalAs(UnmanagedType.LPWStr)] string appId, IntPtr items,
+            [MarshalAs(UnmanagedType.LPWStr)] string verb, out uint processId);
+        void ActivateForProtocol([MarshalAs(UnmanagedType.LPWStr)] string appId, IntPtr items, out uint processId);
+    }
+    public static class DesktopActivation {
+        public static uint Activate(string appId) {
+            object instance = Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid("45BA127D-10A8-46EA-8AB7-56EA9078943C")));
+            try {
+                uint processId;
+                ((IApplicationActivationManager)instance).ActivateApplication(appId, "", 2, out processId);
+                return processId;
+            } finally { Marshal.ReleaseComObject(instance); }
+        }
+    }
+}
+'@
+[CodeRelax.DesktopActivation]::Activate($package.PackageFamilyName + '!App')

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

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import { compareVersions, verifyProtocol } from '../codex-protocol.mjs';
+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';
+
+const exec = promisify(execFile);
+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('|');
+export const runtimeFingerprint = fingerprint;
+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) {
+  const found = new Map();
+  const add = (file, source) => {
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return;
+    const executable = fs.realpathSync(file);
+    if (!found.has(executable.toLowerCase()) || source === 'desktop') found.set(executable.toLowerCase(), { executable, source });
+  };
+  if (environment.CODE_RELAX_CODEX_PATH) {
+    const file = environment.CODE_RELAX_CODEX_PATH;
+    if (!path.isAbsolute(file) || path.basename(file).toLowerCase() !== 'codex.exe') throw new Error('CODE_RELAX_CODEX_PATH 必须是 codex.exe 的绝对路径。');
+    add(file, 'explicit');
+    if (!found.size) throw new Error('CODE_RELAX_CODEX_PATH 指定的程序不存在。');
+    return [...found.values()];
+  }
+  const local = environment.LOCALAPPDATA || path.join(os.homedir(), 'AppData/Local');
+  const home = environment.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const directories = [...String(environment.PATH || environment.Path || '').split(';').filter(Boolean),
+    environment.CODEX_INSTALL_DIR, path.join(local, 'Programs/OpenAI/Codex/bin'),
+    path.join(home, 'packages/standalone/current/bin')].filter(Boolean);
+  for (const directory of directories) {
+    add(path.join(directory, 'codex.exe'), 'cli');
+    const packageFile = path.join(directory, 'node_modules/@openai/codex/package.json');
+    if (!fs.existsSync(packageFile)) continue;
+    const root = path.dirname(fs.realpathSync(packageFile));
+    let vendor = path.join(root, 'vendor');
+    try { vendor = path.join(path.dirname(createRequire(packageFile).resolve('@openai/codex-win32-x64/package.json')), 'vendor'); }
+    catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; }
+    add(path.join(vendor, 'x86_64-pc-windows-msvc/bin/codex.exe'), 'npm');
+  }
+  const desktopRoot = path.join(local, 'OpenAI/Codex/bin');
+  add(path.join(desktopRoot, 'codex.exe'), 'desktop');
+  if (fs.existsSync(desktopRoot)) for (const entry of fs.readdirSync(desktopRoot, { withFileTypes: true })) {
+    if (entry.isDirectory()) add(path.join(desktopRoot, entry.name, 'codex.exe'), 'desktop');
+  }
+  return [...found.values()];
+}
+
+export async function resolveCodexRuntime(stateRoot, { refresh = false, environment = process.env } = {}) {
+  fs.mkdirSync(stateRoot, { recursive: true });
+  const recordFile = path.join(stateRoot, 'codex-runtime.json');
+  const saved = readRecord(recordFile);
+  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 && 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('无法识别版本');
+      candidates.push({ ...candidate, version });
+    } catch (error) { rejected.push(`${candidate.executable}: ${error.message}`); }
+  }
+  candidates.sort((a, b) => Number(b.source === 'desktop') - Number(a.source === 'desktop') || compareVersions(b.version, a.version));
+  for (const candidate of candidates) {
+    try {
+      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;
+    } catch (error) { rejected.push(`${candidate.executable}: ${error.message}`); }
+  }
+  throw new Error(`未找到兼容的 Codex CLI，请安装或更新 Codex CLI 后执行 relax setup。${rejected.length ? '\n' + rejected.join('\n') : ''}`);
+}