@walkhi/code-relax 0.1.0-beta.8 → 0.1.0-beta.81

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,225 @@
+import fs from 'node:fs';
+import { newestRuntime, 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());
+}
+
+export async function runtimeInstallationFingerprint() {
+  const installed = await installedDesktopRuntime();
+  return installed ? [installed.package, fingerprint(installed.executable)] : null;
+}
+
+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 = [];
+  let installed = null;
+  if (!environment.CODE_RELAX_CODEX_PATH) {
+    try { installed = await installedDesktopRuntime(); }
+    catch (error) { throw new Error(`无法确认最新 Codex Desktop 内核，未降级到其他 CLI：${error.message}`); }
+  }
+  for (const candidate of discoverCodex(environment)) {
+    try {
+      if (candidate.source === 'desktop' && !await matchesInstalledDesktop(candidate.executable, installed)) {
+        continue; // Superseded Desktop extraction directories are not installed candidates.
+      }
+      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) { throw new Error(`无法确认 Codex 候选版本，未降级：${candidate.executable}: ${error.message}`); }
+  }
+  if (installed && !candidates.some(candidate => candidate.source === 'desktop')) {
+    throw new Error(`当前 Codex Desktop 内核尚未准备完整，未降级到旧 CLI：${installed.package}。请打开更新后的桌面端完成内核提取。`);
+  }
+  const candidate = newestRuntime(candidates);
+  if (candidate) {
+    try {
+      if (!runtimeFilesAvailable(candidate.executable)) throw new Error('缺少同目录的 codex-code-mode-host.exe');
+      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) { throw new Error(`最新 Codex 内核 ${candidate.version} 校验失败，未降级：${candidate.executable}: ${error.message}`); }
+  }
+  throw new Error('未找到 Codex CLI，请安装或更新 Codex CLI 后执行 relax setup。');
+}

package/dist/src/platform/windows/desktop-helper.mjs

@@ -0,0 +1,179 @@
+import net from 'node:net';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const exec = promisify(execFile);
+const binary = fileURLToPath(new URL('../../../native/desktop-helper/CodeRelaxDesktop.exe', import.meta.url));
+const powershell = path.join(process.env.SystemRoot || 'C:/Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+const quote = value => `'${String(value).replaceAll("'", "''")}'`;
+const encoded = script => Buffer.from(script, 'utf16le').toString('base64');
+const maxFrameBytes = 6 * 1024 * 1024;
+
+export async function desktopHelperStatus() {
+  if (process.platform !== 'win32' || !fs.existsSync(binary)) return { installed: false, running: false, state: 'unavailable' };
+  const { stdout } = await exec(binary, ['--status'], { windowsHide: true, encoding: 'utf8', timeout: 5000 });
+  const result = JSON.parse(stdout.trim());
+  if (result.error) throw new Error(result.error);
+  return result;
+}
+
+async function elevateHelper(argument) {
+  const script = `$ErrorActionPreference = 'Stop'; try { $child = Start-Process -FilePath ${quote(binary)} -ArgumentList ${quote(argument)} -Verb RunAs -PassThru -Wait; exit $child.ExitCode } catch { [Console]::Error.WriteLine($_.Exception.Message); exit 1 }`;
+  try { await exec(powershell, ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded(script)], { windowsHide: true, timeout: 180000 }); }
+  catch (error) { throw new Error(`桌面操作辅助服务配置未完成，需要在工作站确认 UAC：${error.stderr?.trim() || error.message}`); }
+}
+
+export async function removeDesktopHelper() {
+  const current = await desktopHelperStatus();
+  if (!current.installed) return { installed: false, removed: false };
+  await elevateHelper('--remove');
+  const result = await desktopHelperStatus();
+  if (result.installed) throw new Error('桌面操作辅助服务尚未移除。');
+  return { ...result, removed: true };
+}
+
+export async function installDesktopHelper() {
+  if (!fs.existsSync(binary)) throw new Error('缺少原生 桌面操作辅助组件，请先构建或安装完整 npm 包。');
+  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded('[Console]::OutputEncoding = New-Object Text.UTF8Encoding; [Security.Principal.WindowsIdentity]::GetCurrent().User.Value')], { windowsHide: true, encoding: 'utf8' });
+  const sid = stdout.trim();
+  if (!/^S-1-5-21-(?:\d+-){3}\d+$/.test(sid)) throw new Error('无法获取当前 Windows 用户 SID。');
+  const current = await desktopHelperStatus();
+  const hash = target => createHash('sha256').update(fs.readFileSync(target)).digest('hex');
+  if (current.running && current.userSid === sid && hash(binary) === hash(current.path)) return { ...current, changed: false };
+  // Only this installer is elevated. Node and the workstation remain user-level.
+  await elevateHelper(`--install ${sid}`);
+  const installed = await desktopHelperStatus();
+  if (!installed.running || installed.userSid !== sid) throw new Error('桌面操作辅助服务尚未就绪。');
+  return { ...installed, changed: true };
+}
+
+class PipeSession {
+  constructor() {
+    this.socket = net.createConnection('\\\\.\\pipe\\CodeRelax.Desktop.v1');
+    this.socket.setEncoding('utf8');
+    this.buffer = '';
+    this.waiter = null;
+    this.closed = false;
+    this.socket.on('data', data => {
+      this.buffer += data;
+      if (Buffer.byteLength(this.buffer) > maxFrameBytes) { this.fail(new Error('桌面画面超过大小限制')); return; }
+      const end = this.buffer.indexOf('\n');
+      if (end < 0) return;
+      try {
+        const result = JSON.parse(this.buffer.slice(0, end));
+        this.buffer = this.buffer.slice(end + 1);
+        if (!this.waiter) throw new Error('收到未请求的 桌面数据');
+        const waiter = this.waiter; this.waiter = null; clearTimeout(waiter.timer);
+        const complete = () => result.error
+          ? waiter.reject(Object.assign(new Error(result.error), { code: 'desktop_native_error' })) : waiter.resolve(result);
+        if (result.state === 'pending' || result.continuing === true) complete();
+        else this.socket.write('ACK\n', error => {
+          if (error) console.warn(JSON.stringify({ event: 'desktop-response-ack', code: error.code || 'write_failed' }));
+          // The parsed result remains authoritative even if cleanup disconnects.
+          complete();
+        });
+      } catch (error) { this.fail(error); }
+    });
+    this.socket.on('error', error => this.fail(error));
+    this.socket.on('close', () => { this.closed = true; this.fail(new Error('桌面操作辅助连接已关闭，请重新获取画面')); });
+  }
+  fail(error) {
+    if (this.waiter) { const waiter = this.waiter; this.waiter = null; clearTimeout(waiter.timer); waiter.reject(error); }
+    this.socket.destroy();
+  }
+  request(command) {
+    if (this.closed || this.socket.destroyed || this.waiter) return Promise.reject(new Error('桌面操作辅助连接不可用'));
+    return new Promise((resolve, reject) => {
+      this.waiter = { resolve, reject, timer: setTimeout(() => this.fail(new Error('桌面操作辅助请求超时；点击不会自动重发，请刷新画面核对')), 10000) };
+      this.socket.write(`${command}\n`);
+    });
+  }
+  close() { this.fail(new Error('桌面画面已释放')); }
+}
+
+// Frame and input share one worker pipe. Serialize them without replaying input.
+export class DesktopHelper {
+  constructor() { this.active = null; this.reading = false; this.queue = Promise.resolve(); this.version = 0; }
+  serial(operation) {
+    const version = this.version;
+    const result = this.queue.then(() => {
+      if (version !== this.version) throw Object.assign(new Error('桌面操作已取消，请刷新'), { code: 'desktop_session_invalid' });
+      return operation();
+    });
+    this.queue = result.catch(() => {});
+    return result;
+  }
+  clear(current = this.active) {
+    if (!current) return;
+    clearTimeout(current.timer); current.session.close();
+    if (this.active === current) this.active = null;
+  }
+  async frame({ preview = false } = {}) {
+    if (this.reading) throw new Error('正在获取桌面画面，请稍候');
+    this.reading = true;
+    try { return await this.serial(async () => {
+      if (!this.active || this.active.preview !== preview) {
+        this.clear();
+        const version = this.version;
+        const status = await desktopHelperStatus();
+        if (version !== this.version) throw new Error('桌面操作已取消');
+        if (!status.running) return { state: 'unavailable', message: '工作站桌面服务尚未就绪' };
+        this.active = { session: new PipeSession(), preview };
+      }
+      const current = this.active;
+      try {
+        clearTimeout(current.timer);
+        const frame = await current.session.request(current.frame ? 'FRAME' : preview ? 'PREVIEW' : 'FRAME');
+        if (this.active !== current) throw new Error('桌面画面已释放');
+        if (frame.state !== 'pending') { this.clear(current); return frame; }
+        if (!/^[a-f0-9]{32}$/.test(frame.frameId) || !/^[a-f0-9]{32}$/.test(frame.sessionId) || !Number.isSafeInteger(frame.width) || !Number.isSafeInteger(frame.height) ||
+            !['image/png', 'image/jpeg'].includes(frame.mimeType) || !frame.image?.startsWith('data:' + frame.mimeType + ';base64,') ||
+            frame.width < 1 || frame.height < 1 || frame.preview !== preview) throw new Error('桌面画面格式无效');
+        const image = Buffer.from(frame.image.slice(('data:' + frame.mimeType + ';base64,').length), 'base64');
+        delete frame.image;
+        current.sessionId = frame.sessionId;
+        frame.imagePath = '/api/desktop/frames/' + frame.frameId;
+        frame.size = image.length;
+        current.frame = frame; current.image = image; current.expires = Date.now() + 30000;
+        current.timer = setTimeout(() => this.release(undefined, current.sessionId), 30000);
+        return frame;
+      } catch (error) { this.clear(current); throw error; }
+    }); } finally { this.reading = false; }
+  }
+  input(sessionId, command) {
+    return this.serial(async () => {
+      const current = this.active;
+      if (!current?.frame || sessionId !== current.sessionId || Date.now() >= current.expires)
+        throw Object.assign(new Error('请刷新桌面后操作'), { code: 'desktop_session_invalid' });
+      try {
+        const result = await current.session.request(command);
+        if (result.continuing !== true) this.clear(current);
+        return result;
+      } catch (error) { this.clear(current); throw error; }
+    });
+  }
+  move({ sessionId, dx, dy }) {
+    if (!Number.isSafeInteger(dx) || !Number.isSafeInteger(dy) || Math.abs(dx) > 512 || Math.abs(dy) > 512 || (!dx && !dy))
+      throw new Error('无效的相对鼠标位移');
+    return this.input(sessionId, 'MOVE ' + sessionId + ' ' + dx + ' ' + dy);
+  }
+  click({ sessionId, button }) {
+    if (!['left', 'right'].includes(button)) throw new Error('无效的鼠标按键');
+    return this.input(sessionId, 'BUTTON ' + sessionId + ' ' + button);
+  }
+  image(frameId) {
+    const current = this.active;
+    if (!current?.frame || current.frame.frameId !== frameId || Date.now() >= current.expires)
+      throw new Error('桌面画面已释放或过期，请重新获取');
+    return current.image;
+  }
+  release(frameId, sessionId) {
+    if (frameId && this.active?.frame?.frameId !== frameId) return;
+    if (sessionId && this.active?.sessionId !== sessionId) return;
+    this.version++; this.clear();
+  }
+}

package/dist/src/platform/windows/desktop-host.mjs

@@ -1,38 +1,65 @@
-import { startWindowsProcess } from './background-process.mjs';
+import { startWindowsProcess } from './background-process.mjs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import { managedEndpointUrl, readManagedEndpoint } from '../../managed-endpoint.mjs';
+import { runtimePaths } from './runtime-paths.mjs';
 import { sharedServiceUrl } from './service-host.mjs';
 const exec = promisify(execFile);
 const directory = path.dirname(fileURLToPath(import.meta.url));
 export const powershell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
 export async function runScript(name, args = []) {
-  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', path.join(directory, name), ...args], { windowsHide: true, encoding: 'utf8', timeout: 30000 });
+  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', path.join(directory, name), ...args], { windowsHide: true, encoding: 'utf8', timeout: 30000 });
   return stdout.trim();
 }
-export const desktopHost = {
+export const desktopHost = {
   inspect: async () => JSON.parse(await runScript('desktop-info.ps1')),
   process: async pid => JSON.parse(await runScript('desktop-info.ps1', ['-ProcessId', String(pid)])),
   sharedServiceUrl,
-  start: startWindowsProcess,
-  closeDesktop: executable => runScript('stop-desktop.ps1', ['-Executable', executable]),
-  stop: pid => process.kill(pid),
+  ownsListener: async (expected, url) => JSON.parse(await runScript('desktop-info.ps1', ['-ProcessId', String(expected.pid), '-Expected', JSON.stringify(expected), '-AppServerUrl', url, '-CheckListener'])),
+  start: startWindowsProcess,
+  startDesktop: (executable, environment) => {
+    const url = managedEndpointUrl(environment.CODEX_APP_SERVER_WS_URL);
+    if (!url || url !== readManagedEndpoint(runtimePaths().stateRoot)) throw new Error('Desktop 内核地址与工作站不一致。');
+    return runScript('activate-desktop.ps1', [
+      '-Executable', executable, '-AppServerUrl', url,
+    ]);
+  },
+  async desktopReady() {
+    return (await this.inspect()).hasWindow === true && Boolean(await this.sharedServiceUrl());
+  },
+  closeDesktop: executable => runScript('stop-desktop.ps1', ['-Executable', executable]),
+  stop: (pid, expected) => runScript('desktop-info.ps1', ['-ProcessId', String(pid), '-Expected', JSON.stringify(expected), '-StopManagedProcess']),
+  async prepareKernelRestart() {
+    const info = await this.inspect();
+    if (!info.running || !await this.sharedServiceUrl()) return null;
+    await this.closeDesktop(info.desktop);
+    return info.desktop;
+  },
+  async resumeAfterKernelRestart(executable, environment) {
+    if (!executable) return;
+    await this.startDesktop(executable, environment);
+    const deadline = Date.now() + 30000;
+    while (!await this.desktopReady()) {
+      if (Date.now() >= deadline) throw new Error('Codex 内核已就绪，但 Desktop 未完成重新接入。');
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  },
   ready: async url => { try { return (await fetch(url, { signal: AbortSignal.timeout(1000) })).ok; } catch { return false; } },
-};
-export const resolveStateRoot = stateRoot => runScript('resolve-state-root.ps1', ['-StateRoot', stateRoot]);
+};
+export const resolveStateRoot = stateRoot => runScript('resolve-state-root.ps1', ['-StateRoot', stateRoot]);
 
-export async function desktopShortcuts({ serviceRoot, nodeExecutable }, remove = false, destination) {
+export async function removeDesktopShortcut({ serviceRoot, nodeExecutable }, destination) {
   const entry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
   const args = ['-NodePath', nodeExecutable, '-Entry', entry];
-  if (remove) args.push('-Remove');
   if (destination) args.push('-Destination', destination);
   return JSON.parse(await runScript('desktop-shortcuts.ps1', args));
-}
-
-export async function residentStartup({ serviceRoot, nodeExecutable }, action = 'status') {
-  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
-    path.join(serviceRoot, 'dist/src/platform/windows/resident-startup.ps1'), '-NodePath', nodeExecutable,
-    '-Entry', path.join(serviceRoot, 'dist/bin/codex-remote.mjs'), '-Action', action], { windowsHide: true, encoding: 'utf8' });
-  return JSON.parse(stdout.trim());
-}
+}
+
+export async function residentStartup({ serviceRoot, nodeExecutable }, action = 'status') {
+  const { stdout } = await exec(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+    path.join(serviceRoot, 'dist/src/platform/windows/resident-startup.ps1'), '-NodePath', nodeExecutable,
+    '-Entry', path.join(serviceRoot, 'dist/bin/codex-remote.mjs'), '-Action', action], { windowsHide: true, encoding: 'utf8' });
+  return JSON.parse(stdout.trim());
+}

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

@@ -1,6 +1,30 @@
-param([int]$ProcessId = 0)
+param([int]$ProcessId = 0, [string]$Expected, [string]$AppServerUrl, [switch]$CheckListener, [switch]$StopManagedProcess)
 $ErrorActionPreference = 'Stop'
 [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+function Read-Identity([int]$Id) {
+    $item = Get-CimInstance Win32_Process -Filter "ProcessId=$Id"
+    if ($item) { return @{ pid=$item.ProcessId; executable=$item.ExecutablePath; command=$item.CommandLine; created=$item.CreationDate.ToUniversalTime().ToString('o') } }
+    return $null
+}
+function Same-Identity($a, $b) {
+    return $null -ne $a -and $null -ne $b -and $a.pid -eq $b.pid -and $a.executable -ceq $b.executable -and $a.command -ceq $b.command -and $a.created -ceq $b.created
+}
+if ($CheckListener -or $StopManagedProcess) {
+    if ($ProcessId -le 0 -or -not $Expected) { throw 'Missing managed process identity.' }
+    $identity = $Expected | ConvertFrom-Json
+    if ($identity.pid -ne $ProcessId) { throw 'Process identity mismatch.' }
+    $actual = Read-Identity $ProcessId
+    if (-not (Same-Identity $identity $actual)) {
+        if ($StopManagedProcess) { throw 'Process identity changed; nothing stopped.' }
+        'false'; exit
+    }
+    if ($StopManagedProcess) { Stop-Process -Id $ProcessId -ErrorAction Stop; '{"stopped":true}'; exit }
+    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.' }
+    $port = [int]$Matches[1]
+    $listeners = @(Get-NetTCPConnection -LocalPort $port -State Listen -ErrorAction SilentlyContinue | Where-Object { $_.LocalAddress -eq '127.0.0.1' -and $_.OwningProcess -eq $ProcessId })
+    [bool]($listeners.Count -gt 0 -and (Same-Identity $identity (Read-Identity $ProcessId))) | ConvertTo-Json -Compress
+    exit
+}
 if ($ProcessId -gt 0) {
     $item = Get-CimInstance Win32_Process -Filter "ProcessId=$ProcessId"
     if ($item) { @{ pid=$item.ProcessId; executable=$item.ExecutablePath; command=$item.CommandLine; created=$item.CreationDate.ToUniversalTime().ToString('o') } | ConvertTo-Json -Compress }
@@ -8,9 +32,7 @@ if ($ProcessId -gt 0) {
     exit
 }
 $package = Get-AppxPackage OpenAI.Codex | Select-Object -First 1
-if (-not $package) { throw '未找到 Codex Desktop，请先安装并登录。' }
+if (-not $package) { @{ desktop=$null; running=$false } | ConvertTo-Json -Compress; exit }
 $desktop = Join-Path $package.InstallLocation 'app/ChatGPT.exe'
 $running = @(Get-Process ChatGPT -ErrorAction SilentlyContinue | Where-Object { $_.Path -eq $desktop })
-$binaryRoot = Join-Path $env:LOCALAPPDATA 'OpenAI/Codex/bin'
-$cli = Get-ChildItem -LiteralPath $binaryRoot -Filter codex.exe -Recurse -ErrorAction SilentlyContinue | Sort-Object LastWriteTime -Descending | Select-Object -First 1
-@{ desktop=$desktop; cli=$cli.FullName; running=($running.Count -gt 0) } | ConvertTo-Json -Compress
+@{ desktop=$desktop; version=$package.Version.ToString(); running=($running.Count -gt 0); hasWindow=(@($running | Where-Object { $_.MainWindowHandle -ne 0 }).Count -gt 0) } | ConvertTo-Json -Compress

package/dist/src/platform/windows/desktop-project-registration.mjs

@@ -0,0 +1,4 @@
+import { desktopHost } from './desktop-host.mjs';
+import { withDesktopProjectRegistration as register } from '../desktop-project-store.mjs';
+export { registerProjectInState, desktopProjectRestartWarning } from '../desktop-project-store.mjs';
+export const withDesktopProjectRegistration = (options, action) => register({ host: desktopHost, ...options }, action);

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