@walkhi/code-relax 0.1.0-beta.10 → 0.1.0-beta.101

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

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { startBackground } from '../../background-process.mjs';
+import { systemRequest } from './system.mjs';
+import { assertPlainPath } from '../../skill-install.mjs';
+import { setTimeout as delay } from 'node:timers/promises';
+import { runtimePaths } from '../runtime-paths.mjs';
+import { readRecord } from '../../service-lifecycle.mjs';
+export { residentStartup } from './resident-startup.mjs';
+
+import { managedEndpointUrl, readManagedEndpoint } from '../../managed-endpoint.mjs';
+export function createDesktopHost({ request = systemRequest, wait = delay, now = Date.now, timeout = 10000,
+  stateRoot = () => runtimePaths().stateRoot, fingerprint = file => {
+    const stat = fs.statSync(path.join(file, 'resources/linux-package-metadata.json'));
+    return `${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+  } } = {}) {
+  return {
+    desktopIntegration: true,
+    async inspect() {
+      const url = readManagedEndpoint(stateRoot());
+      const info = await request({ operation: 'desktop-info', url });
+      return { ...info, managedUrl: url, desktopIdentity: info.desktop ? `${info.desktop}:${info.version}:${info.build}:${fingerprint(info.desktop)}` : null };
+    },
+    process: pid => request({ operation: 'process', pid }),
+    ownsListener: (expected, url) => request({ operation: 'owns-listener', expected, url }),
+    start: startBackground,
+    async stop(pid, expected) {
+      if (!expected || expected.pid !== pid) throw new Error('停止内核前缺少进程身份，未结束任何进程。');
+      return request({ operation: 'stop', expected });
+    },
+    async sharedServiceUrl() {
+      const info = await this.inspect();
+      return info.connectedToManagedServer ? info.managedUrl : '';
+    },
+    async startDesktop(bundlePath, environment) {
+      const managedUrl = managedEndpointUrl(environment.CODEX_APP_SERVER_WS_URL);
+      if (!managedUrl || managedUrl !== readManagedEndpoint(stateRoot())) throw new Error('Desktop 内核地址与工作站不一致。');
+      const runtime = readRecord(path.join(stateRoot(), 'codex-runtime.json'));
+      const codexHome = environment.CODEX_HOME || runtime?.codexHome;
+      if (!codexHome || !path.isAbsolute(codexHome)) throw new Error('缺少已选内核的 CODEX_HOME，请先运行 relax setup。');
+      const info = await this.inspect();
+      if (info.running) throw new Error('Desktop 仍在运行，未创建第二个实例。');
+      if (info.desktop !== bundlePath) throw new Error('Codex Desktop 安装位置已变化，请重新检查。');
+      return request({ operation: 'desktop-start', bundlePath,
+        environment: { CODEX_HOME: codexHome, CODEX_APP_SERVER_WS_URL: managedUrl } });
+    },
+    async closeDesktop(bundlePath) {
+      const info = await this.inspect();
+      if (!info.running) return;
+      if (info.desktop !== bundlePath || !info.process) throw new Error('Desktop 进程身份已变化，未请求退出。');
+      await request({ operation: 'desktop-close', bundlePath, expected: info.process });
+      const deadline = now() + timeout;
+      while ((await this.inspect()).running) {
+        if (now() >= deadline) throw new Error('Desktop 尚未正常退出，请在 Linux 上处理未保存内容后重试；未强制结束进程。');
+        await wait(200);
+      }
+    },
+    async desktopReady() {
+      const info = await this.inspect();
+      return info.running && info.finishedLaunching && info.connectedToManagedServer;
+    },
+    async prepareKernelRestart() {
+      const info = await this.inspect();
+      if (!info.running || !info.connectedToManagedServer) return null;
+      await this.closeDesktop(info.desktop);
+      return info.desktop;
+    },
+    async resumeAfterKernelRestart(bundlePath, environment) {
+      if (!bundlePath) return;
+      await this.startDesktop(bundlePath, environment);
+      const deadline = now() + 30000;
+      while (!await this.desktopReady()) {
+        if (now() >= deadline) throw new Error('内核已就绪，但 Linux Desktop 尚未重新接入。');
+        await wait(500);
+      }
+    },
+    ready: async url => { try { return (await fetch(url, { signal: AbortSignal.timeout(1000) })).ok; } catch { return false; } },
+  };
+}
+export const desktopHost = createDesktopHost();
+export async function resolveStateRoot(stateRoot) {
+  if (process.getuid() === 0) throw new Error('请以普通 Linux 桌面用户安装 Code Relax，不使用 sudo。');
+  assertPlainPath(stateRoot);
+  fs.mkdirSync(stateRoot, { recursive: true, mode: 0o700 });
+  return fs.realpathSync(stateRoot);
+}
+export async function removeDesktopShortcut() { return { removed: false, reason: 'not-used-on-linux' }; }

package/dist/src/platform/linux/desktop-installation.mjs

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+// Official Linux 26.1007.71326 deb: /usr/bin/chatgpt -> codex-launcher,
+// ChatGPT and resources/{codex,codex-code-mode-host,rg} share this root.
+export function installedDesktop(environment = process.env) {
+  const roots = ['/usr/lib/chatgpt', '/opt/chatgpt', '/opt/ChatGPT'];
+  for (const directory of String(environment.PATH || '').split(':').filter(value => value.startsWith('/'))) {
+    try { roots.push(path.dirname(fs.realpathSync(path.join(directory, 'chatgpt')))); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  for (const root of new Set(roots)) {
+    const metadataFile = path.join(root, 'resources/linux-package-metadata.json');
+    if (!fs.existsSync(metadataFile)) continue;
+    const metadata = JSON.parse(fs.readFileSync(metadataFile, 'utf8'));
+    if (metadata.codexAppBrand !== 'chatgpt' || metadata.codexBuildFlavor !== 'prod' || !metadata.version) continue;
+    const executable = path.join(root, 'ChatGPT');
+    if (!fs.existsSync(executable)) continue;
+    return { desktop: fs.realpathSync(root), executable: fs.realpathSync(executable), version: metadata.version, build: metadata.version };
+  }
+  return null;
+}
+export function verifyDesktopPackage(root) {
+  const file = path.join(root, 'resources/codex');
+  // Trust the machine's installed package database; do not treat a JSON brand
+  // marker as an operating-system signature or accept an unrelated CLI shim.
+  if (fs.existsSync('/usr/bin/dpkg-query')) {
+    const owner = execFileSync('/usr/bin/dpkg-query', ['-S', file], { encoding: 'utf8' }).trim();
+    if (!owner.split('\n').some(line => line === `chatgpt: ${file}`)) throw new Error('内核不属于已安装的官方 chatgpt 软件包。');
+  } else if (fs.existsSync('/usr/bin/rpm')) {
+    if (execFileSync('/usr/bin/rpm', ['-qf', '--qf', '%{NAME}', file], { encoding: 'utf8' }).trim() !== 'chatgpt') throw new Error('内核软件包身份不匹配。');
+  } else if (fs.existsSync('/usr/bin/pacman')) {
+    if (!/^chatgpt(?:-bin)?$/.test(execFileSync('/usr/bin/pacman', ['-Qoq', file], { encoding: 'utf8' }).trim())) throw new Error('内核软件包身份不匹配。');
+  } else throw new Error('无法核对 Linux 桌面版软件包，请通过官方软件包安装 ChatGPT。');
+}

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

@@ -0,0 +1,11 @@
+import { desktopHost } from './desktop-host.mjs';
+import { withDesktopProjectRegistration as register } from '../desktop-project-store.mjs';
+
+// Verified against the Linux 26.1007.71326 local-projects/project-order store.
+export async function withDesktopProjectRegistration(options, action) {
+  const host = options.host || desktopHost;
+  if (!(await host.inspect()).desktop)
+    return action({ register: async () => ({ status: 'not-applicable', reason: 'desktop-not-installed' }),
+      remove: async (_project, _operation, _save, removeNative) => { await removeNative(); return { status: 'not-applicable', reason: 'desktop-not-installed' }; } });
+  return register({ ...options, host }, action);
+}

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

@@ -0,0 +1,11 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { networkCandidates } from '../posix/network-candidates.mjs';
+
+export async function lanNetworks() {
+  const hardware = fs.readdirSync('/sys/class/net').filter(name => fs.existsSync(`/sys/class/net/${name}/device`)).map(interfaceName => ({
+    interfaceName, networkName: interfaceName,
+    networkType: fs.existsSync(`/sys/class/net/${interfaceName}/wireless`) ? 'wifi' : 'ethernet',
+  }));
+  return networkCandidates(hardware, os.networkInterfaces());
+}

package/dist/src/platform/linux/process.mjs

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import { managedEndpointUrl } from '../../managed-endpoint.mjs';
+
+const gone = error => ['ENOENT', 'ESRCH'].includes(error.code);
+let bootId;
+export function processInfo(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error('无效的进程 ID。');
+  const root = `/proc/${pid}`;
+  try {
+    if (fs.statSync(root).uid !== process.getuid()) return null;
+    const stat = fs.readFileSync(`${root}/stat`, 'utf8');
+    const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+    if (fields[0] === 'Z') return null;
+    const ticks = fields[19];
+    bootId ??= fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+    const created = `${bootId}:${ticks}`;
+    const executable = fs.readlinkSync(`${root}/exe`);
+    const args = fs.readFileSync(`${root}/cmdline`, 'utf8').split('\0').filter(Boolean);
+    const after = fs.readFileSync(`${root}/stat`, 'utf8');
+    if (after.slice(after.lastIndexOf(')') + 2).split(' ')[19] !== ticks) return null;
+    return { pid, created, executable, args, command: args.join(' ') };
+  } catch (error) { if (gone(error)) return null; throw error; }
+}
+export const sameProcess = (a, b) => !!a && !!b && a.pid === b.pid && a.created === b.created
+  && a.executable === b.executable && JSON.stringify(a.args) === JSON.stringify(b.args);
+export function stopProcess(pid, expected) {
+  if (expected?.pid !== pid || !sameProcess(expected, processInfo(pid))) throw new Error('进程身份已变化，未结束进程。');
+  process.kill(pid, 'SIGTERM');
+  return { stopped: true };
+}
+function hasManagedSocket(pid, url, listener) {
+  const endpoint = managedEndpointUrl(url);
+  if (!endpoint) return false;
+  const port = Number(endpoint.slice(endpoint.lastIndexOf(':') + 1)).toString(16).toUpperCase().padStart(4, '0');
+  try {
+    const sockets = new Set(fs.readdirSync(`/proc/${pid}/fd`).flatMap(fd => {
+      try { return /^socket:\[(\d+)\]$/.exec(fs.readlinkSync(`/proc/${pid}/fd/${fd}`))?.slice(1) || []; }
+      catch (error) { if (gone(error)) return []; throw error; }
+    }));
+    return ['tcp', 'tcp6'].some(table => fs.readFileSync(`/proc/${pid}/net/${table}`, 'utf8').trim().split('\n').slice(1).some(line => {
+      const fields = line.trim().split(/\s+/);
+      return fields[3] === (listener ? '0A' : '01') && sockets.has(fields[9])
+        && [`0100007F:${port}`, `0000000000000000FFFF00000100007F:${port}`].includes(fields[listener ? 1 : 2]);
+    }));
+  } catch (error) { if (gone(error)) return false; throw error; }
+}
+
+export const connectedToManagedServer = (pid, url) => hasManagedSocket(pid, url, false);
+export function ownsManagedListener(expected, url) {
+  return !!expected && sameProcess(expected, processInfo(expected.pid))
+    && hasManagedSocket(expected.pid, url, true)
+    && sameProcess(expected, processInfo(expected.pid));
+}

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

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export async function projectLocations() {
+  const home = os.homedir();
+  const config = path.isAbsolute(process.env.XDG_CONFIG_HOME || '') ? process.env.XDG_CONFIG_HOME : path.join(home, '.config');
+  let text = '';
+  try { text = fs.readFileSync(path.join(config, 'user-dirs.dirs'), 'utf8'); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const directory = (name, fallback) => {
+    const match = new RegExp(`^XDG_${name}_DIR="([^"\\n]+)"$`, 'm').exec(text);
+    const value = match?.[1].replace(/^\$HOME(?=\/|$)/, home);
+    return value && path.isAbsolute(value) && !value.includes('$') ? value : path.join(home, fallback);
+  };
+  return { home, downloads: directory('DOWNLOAD', 'Downloads'), defaultParent: path.join(directory('DOCUMENTS', 'Documents'), 'ChatGPT'), roots: ['/'] };
+}

package/dist/src/platform/linux/resident-startup.mjs

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertPlainPath } from '../../skill-install.mjs';
+import { runtimePaths } from '../runtime-paths.mjs';
+import { readRecord } from '../../service-lifecycle.mjs';
+
+// XDG autostart inherits the actual graphical session (Wayland/X11 and the
+// unlocked Secret Service). No system daemon, sudo, or shell profile mutation.
+const quote = value => {
+  if (/[\u0000-\u001f\u007f]/.test(value)) throw new Error('登录启动路径含无效控制字符。');
+  return `"${value.replace(/%/g, '%%').replace(/[\\"`$]/g, char => `\\${char}`).replace(/\\/g, '\\\\')}"`;
+};
+export function autostartEntry({ serviceRoot, nodeExecutable, environment = process.env }) {
+  const entry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
+  const variables = {};
+  for (const name of ['CODEX_HOME', 'XDG_DATA_HOME', 'XDG_STATE_HOME', 'XDG_CONFIG_HOME'])
+    if (environment[name]) variables[name] = environment[name];
+  const stablePath = String(environment.PATH || '').split(':').filter(value => value.startsWith('/') && !value.endsWith('/node_modules/.bin')).join(':');
+  if (stablePath) variables.PATH = stablePath;
+  const command = [quote(nodeExecutable), quote(entry), 'start', '--json'].join(' ');
+  const assignments = Object.entries(variables).map(([key, value]) => quote(`${key}=${value}`));
+  return `[Desktop Entry]\nType=Application\nName=Code Relax\nComment=Code Relax workstation\nExec=/usr/bin/env ${[...assignments, command].join(' ')}\nTerminal=false\nX-CodeRelax-Owner=${encodeURIComponent(path.resolve(serviceRoot))}\n`;
+}
+export async function residentStartup(installation, action = 'status') {
+  if (!['status', 'enable', 'disable'].includes(action)) throw new Error('无效的登录启动操作。');
+  if (process.getuid() === 0) throw new Error('请以普通 Linux 桌面用户安装，不使用 sudo。');
+  const config = path.isAbsolute(process.env.XDG_CONFIG_HOME || '') ? process.env.XDG_CONFIG_HOME : path.join(os.homedir(), '.config');
+  const file = path.join(config, 'autostart/cn.walkhi.code-relax.desktop');
+  assertPlainPath(file);
+  const runtime = readRecord(path.join(runtimePaths().stateRoot, 'codex-runtime.json'));
+  const environment = { ...process.env, ...(runtime?.codexHome ? { CODEX_HOME: runtime.codexHome } : {}) };
+  const expected = autostartEntry({ ...installation, environment });
+  let current = '';
+  try { current = fs.readFileSync(file, 'utf8'); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const marker = `X-CodeRelax-Owner=${encodeURIComponent(path.resolve(installation.serviceRoot))}`;
+  if (current && !current.split(/\r?\n/).includes(marker)) throw new Error('同名登录启动项不属于此安装，未修改。');
+  const command = `${quote(installation.nodeExecutable)} ${quote(path.join(installation.serviceRoot, 'dist/bin/codex-remote.mjs'))} start --json`;
+  const execLine = current.split(/\r?\n/).find(line => line.startsWith('Exec=')) || '';
+  if (action === 'status') return { enabled: execLine.startsWith('Exec=/usr/bin/env ') && execLine.endsWith(command)
+      && !/^(?:Hidden=true|X-GNOME-Autostart-enabled=false)$/m.test(current), path: file, mechanism: 'XDG Autostart' };
+  if (action === 'disable') {
+    if (current) fs.unlinkSync(file);
+    return { enabled: false, removed: !!current, path: file };
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.tmp`;
+  try { fs.writeFileSync(temporary, expected, { flag: 'wx', mode: 0o600 }); fs.renameSync(temporary, file); }
+  finally { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); }
+  return { enabled: true, path: file, mechanism: 'XDG Autostart', appliesAtNextLogin: true };
+}

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

@@ -0,0 +1,76 @@
+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-linux-runtime';
+const manifestName = '.code-relax-runtime.json';
+// Linux Desktop currently ships a flat, statically linked runtime, unlike Mac.
+const names = ['codex', 'codex-code-mode-host', 'rg'];
+export function runtimeFingerprint(executable) {
+  return JSON.stringify(names.map(name => {
+    const stat = fs.statSync(path.join(path.dirname(executable), name));
+    return [name, stat.size, stat.mtimeMs, stat.ctimeMs, stat.ino, stat.mode & 0o777];
+  }));
+}
+async function digestFiles(root) {
+  const files = [];
+  for (const name of names) {
+    const file = path.join(root, name), hash = createHash('sha256');
+    const before = fs.lstatSync(file);
+    if (!before.isFile()) throw new Error(`Linux 内核组件不是普通文件：${name}`);
+    for await (const chunk of fs.createReadStream(file)) hash.update(chunk);
+    const after = fs.statSync(file);
+    if (before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+      throw new Error('Linux 内核更新正在替换文件，请稍后重试。');
+    files.push({ name, size: after.size, mode: after.mode & 0o777, sha256: hash.digest('hex') });
+  }
+  return files;
+}
+const treeHash = files => createHash('sha256').update(JSON.stringify(files)).digest('hex');
+export async function retainRuntime(executable, stateRoot, version) {
+  const source = path.dirname(executable), sourceFingerprint = runtimeFingerprint(executable);
+  const files = await digestFiles(source), digest = treeHash(files);
+  if (sourceFingerprint !== runtimeFingerprint(executable)) throw new Error('Linux 内核在核对期间发生变化。');
+  const parent = path.join(stateRoot, 'linux-runtimes'), target = path.join(parent, digest);
+  const result = { executable: path.join(target, 'codex'), sourceExecutable: executable, sourceFingerprint };
+  if (fs.existsSync(target)) {
+    if (readRecord(path.join(target, manifestName))?.owner !== owner || treeHash(await digestFiles(target)) !== digest)
+      throw new Error('保留的 Linux 内核不完整，未覆盖运行中的文件。');
+    return result;
+  }
+  fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+  const staging = path.join(parent, `.${randomUUID()}.tmp`), created = [];
+  fs.mkdirSync(staging, { mode: 0o700 });
+  try {
+    for (const file of files) {
+      const destination = path.join(staging, file.name);
+      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);
+    }
+    if (treeHash(await digestFiles(staging)) !== digest || sourceFingerprint !== runtimeFingerprint(executable))
+      throw new Error('Linux 内核复制期间发生变化，未使用混合版本。');
+    writeRecord(path.join(staging, manifestName), { owner, digest, version, files });
+    created.push(manifestName);
+    fs.renameSync(staging, target);
+    return result;
+  } catch (error) {
+    if (fs.existsSync(staging)) { for (const name of created) fs.unlinkSync(path.join(staging, name)); fs.rmdirSync(staging); }
+    throw error;
+  }
+}
+export async function pruneRetainedDesktopRuntimes(stateRoot, keepExecutable) {
+  const parent = path.resolve(stateRoot, 'linux-runtimes'), keep = path.dirname(path.resolve(keepExecutable));
+  if (path.dirname(keep) !== parent || !/^[a-f0-9]{64}$/.test(path.basename(keep)) || !fs.existsSync(parent)) 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 record = readRecord(path.join(directory, manifestName));
+    if (record?.owner !== owner || record.digest !== entry.name) continue;
+    if (fs.readdirSync(directory).sort().join('|') !== [...names, manifestName].sort().join('|')) continue;
+    const actual = await digestFiles(directory);
+    if (treeHash(actual) !== entry.name || JSON.stringify(record.files) !== JSON.stringify(actual)) continue;
+    for (const name of [...names, manifestName]) fs.unlinkSync(path.join(directory, name));
+    fs.rmdirSync(directory);
+  }
+}

package/dist/src/platform/linux/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/linux/system.mjs

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { installedDesktop, verifyDesktopPackage } from './desktop-installation.mjs';
+import { processInfo, sameProcess, stopProcess, connectedToManagedServer, ownsManagedListener } from './process.mjs';
+import { startBackground } from '../../background-process.mjs';
+
+// Package upgrades unlink the old executable while its process stays alive.
+// Match that process for Desktop discovery, but retain its exact /proc identity
+// for sameProcess/stopProcess so a changed process is never signalled blindly.
+const desktopExecutableMatches = (actual, installed) => actual === installed || actual === `${installed} (deleted)`;
+
+export async function systemRequest(request) {
+  if (request.operation === 'owns-listener') return ownsManagedListener(request.expected, request.url);
+  if (request.operation === 'process') return processInfo(request.pid);
+  if (request.operation === 'stop') return stopProcess(request.expected?.pid, request.expected);
+  const installed = installedDesktop();
+  if (request.operation === 'desktop-info') {
+    const running = [];
+    if (installed) for (const name of fs.readdirSync('/proc').filter(name => /^\d+$/.test(name))) {
+      try {
+        if (fs.statSync(`/proc/${name}`).uid !== process.getuid()
+            || !desktopExecutableMatches(fs.readlinkSync(`/proc/${name}/exe`), installed.executable)) continue;
+      } catch (error) { if (['ENOENT', 'ESRCH', 'EACCES'].includes(error.code)) continue; throw error; }
+      const info = processInfo(Number(name));
+      if (info && desktopExecutableMatches(info.executable, installed.executable) && !info.args.some(arg => arg.startsWith('--type='))) running.push(info);
+    }
+    if (running.length > 1) throw new Error('发现多个 ChatGPT 桌面实例，请先关闭多余实例。');
+    const info = running[0] || null;
+    const connected = info ? connectedToManagedServer(info.pid, request.url) : false;
+    if (info && !sameProcess(info, processInfo(info.pid))) throw new Error('核对期间桌面进程发生变化。');
+    return { ...(installed || { desktop: null, version: '', build: '' }), running: !!info,
+      finishedLaunching: connected, connectedToManagedServer: connected, process: info };
+  }
+  if (!installed || installed.desktop !== request.bundlePath) throw new Error('桌面版安装位置已变化。');
+  if (request.operation === 'desktop-start') {
+    verifyDesktopPackage(installed.desktop);
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) throw new Error('请在 Linux 图形桌面的当前用户会话中运行 relax setup。');
+    const environment = { ...process.env, ...request.environment };
+    delete environment.CODEX_APP_SERVER_FORCE_CLI;
+    delete environment.CODEX_APP_TOOLS_PIPE_PATH;
+    const pid = await startBackground(path.join(installed.desktop, 'codex-launcher'), [], environment);
+    return { pid, started: true };
+  }
+  if (request.operation === 'desktop-close') {
+    // Electron's POSIX signal handler calls Browser::Quit for SIGTERM. Wait
+    // for exit before touching the store; never escalate to SIGKILL.
+    return stopProcess(request.expected?.pid, request.expected);
+  }
+  throw new Error(`不支持的 Linux 系统操作：${request.operation}`);
+}

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

@@ -0,0 +1,31 @@
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { managedUserEnvironment, managedEnvironmentName } from '../managed-user-environment.mjs';
+import { installedDesktop } from './desktop-installation.mjs';
+
+const exec = promisify(execFile);
+const systemctl = async args => (await exec('/usr/bin/systemctl', ['--user', ...args], { timeout: 5000 })).stdout;
+const config = path.isAbsolute(process.env.XDG_CONFIG_HOME || '') ? process.env.XDG_CONFIG_HOME : path.join(os.homedir(), '.config');
+export const environmentConfig = url => `# Managed by Code Relax\n${managedEnvironmentName}=${url}\n`;
+const adapter = managedUserEnvironment({
+  file: path.join(config, 'environment.d/60-code-relax.conf'),
+  render: environmentConfig, scope: 'systemd-user',
+  read: async () => {
+    if (process.getuid() === 0) throw new Error('请以普通 Linux 用户配置内核环境，不使用 sudo。');
+    const lines = (await systemctl(['show-environment'])).split('\n');
+    const value = name => {
+      const raw = lines.find(line => line.startsWith(`${name}=`))?.slice(name.length + 1) || '';
+      return raw.startsWith('"') ? JSON.parse(raw) : raw;
+    };
+    return { value: value(managedEnvironmentName), forceCli: value('CODEX_APP_SERVER_FORCE_CLI') };
+  },
+  set: url => systemctl(['set-environment', `${managedEnvironmentName}=${url}`]),
+  unset: () => systemctl(['unset-environment', managedEnvironmentName]),
+});
+export async function configureManagedEnvironment(stateRoot, url) {
+  if (!installedDesktop()) return { configured: false, reason: 'desktop-not-installed' };
+  return adapter.configureManagedEnvironment(stateRoot, url);
+}
+export const { clearManagedEnvironment } = adapter;

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

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import { newestRuntime, verifyProtocol } from '../codex-protocol.mjs';
+import { readRecord, writeRecord } from '../../service-lifecycle.mjs';
+import { retainRuntime, runtimeFingerprint, packageRoot } from './retained-runtime.mjs';
+export { runtimeFingerprint, pruneRetainedDesktopRuntimes } from './retained-runtime.mjs';
+
+const exec = promisify(execFile);
+export const codeModeHostPath = executable => path.join(packageRoot(executable), 'bin/codex-code-mode-host');
+const fileExists = file => { try { return fs.statSync(file).isFile(); } catch (error) { if (error.code === 'ENOENT') return false; throw error; } };
+export function nativeExecutable(file) {
+  if (!fileExists(file)) return false;
+  const descriptor = fs.openSync(file, 'r');
+  try {
+    const magic = Buffer.alloc(4);
+    if (fs.readSync(descriptor, magic, 0, 4, 0) !== 4) return false;
+    return [0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xcafebabe, 0xbebafeca, 0xcafebabf, 0xbfbafeca].includes(magic.readUInt32BE());
+  } finally { fs.closeSync(descriptor); }
+}
+export function runtimeFilesAvailable(executable) {
+  try { return nativeExecutable(executable) && nativeExecutable(codeModeHostPath(executable)); }
+  catch (error) { if (error.code === 'EACCES') throw error; return false; }
+}
+function nativeEntry(file) {
+  if (!fileExists(file)) return null;
+  file = fs.realpathSync(file);
+  if (nativeExecutable(file)) return file;
+  if (path.basename(path.dirname(file)) === 'bin') {
+    const bundle = path.resolve(file, '../../CodexCLI.app/Contents/MacOS/codex');
+    if (nativeExecutable(bundle)) return bundle;
+  }
+  return null;
+}
+
+// Match the official CLI's native package mapping. Never launch the npm JS shim as a kernel.
+export function discoverCodex(environment = process.env, { home = os.homedir(), arch = process.arch } = {}) {
+  if (!['arm64', 'x64'].includes(arch)) throw new Error(`不支持的 Mac CPU：${arch}`);
+  const found = new Map();
+  const add = (file, source) => {
+    file = nativeEntry(file);
+    if (!file) return;
+    fs.accessSync(file, fs.constants.X_OK);
+    const executable = fs.realpathSync(file);
+    if (!found.has(executable)) found.set(executable, { executable, source });
+  };
+  if (environment.CODE_RELAX_CODEX_PATH) {
+    const file = environment.CODE_RELAX_CODEX_PATH;
+    if (!path.isAbsolute(file) || path.basename(file) !== 'codex') throw new Error('CODE_RELAX_CODEX_PATH 必须是原生 codex 程序的绝对路径。');
+    add(file, 'explicit');
+    if (!found.size) throw new Error('指定的 Codex 原生程序不存在或不是 Mach-O 可执行文件。');
+    return [...found.values()];
+  }
+  for (const directory of ['/Applications', path.join(home, 'Applications')]) {
+    for (const name of ['ChatGPT.app', 'Codex.app']) {
+      const bundle = path.join(directory, name);
+      if (!fileExists(path.join(bundle, 'Contents/Info.plist'))) continue;
+      const id = execFileSync('/usr/bin/plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', path.join(bundle, 'Contents/Info.plist')], { encoding: 'utf8', timeout: 5000 }).trim();
+      if (id !== 'com.openai.codex') continue;
+      add(path.join(bundle, 'Contents/Resources/codex-cli/CodexCLI.app/Contents/MacOS/codex'), 'desktop');
+    }
+  }
+  const codexHome = environment.CODEX_HOME?.trim() || path.join(home, '.codex');
+  const directories = [...String(environment.PATH || '').split(path.delimiter), environment.CODEX_INSTALL_DIR,
+    path.join(home, '.local/bin'), path.join(codexHome, 'packages/standalone/current/bin')].filter(item => item && path.isAbsolute(item));
+  const target = `${arch === 'arm64' ? 'aarch64' : 'x86_64'}-apple-darwin`;
+  for (const directory of new Set(directories)) {
+    const entry = path.join(directory, 'codex');
+    if (!fileExists(entry)) continue;
+    if (nativeEntry(entry)) { add(entry, 'cli'); continue; }
+    let root = path.dirname(fs.realpathSync(entry));
+    while (true) {
+      const packageFile = path.join(root, 'package.json');
+      if (fileExists(packageFile) && readRecord(packageFile)?.name === '@openai/codex') {
+        let vendor = path.join(root, 'vendor');
+        try { vendor = path.join(path.dirname(createRequire(packageFile).resolve(`@openai/codex-darwin-${arch}/package.json`)), 'vendor'); }
+        catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; }
+        add(path.join(vendor, target, 'bin/codex'), 'npm');
+        break;
+      }
+      const parent = path.dirname(root);
+      if (parent === root) break;
+      root = parent;
+    }
+  }
+  return [...found.values()];
+}
+
+export async function resolveCodexRuntime(stateRoot, { refresh = false, environment = process.env } = {}) {
+  fs.mkdirSync(stateRoot, { recursive: true, mode: 0o700 });
+  const recordFile = path.join(stateRoot, 'codex-runtime.json');
+  const saved = readRecord(recordFile);
+  const codexHome = path.resolve(environment.CODEX_HOME?.trim() || saved?.codexHome || path.join(os.homedir(), '.codex'));
+  const explicit = environment.CODE_RELAX_CODEX_PATH || (saved?.source === 'explicit' ? saved.sourceExecutable : '');
+  if (!refresh && saved?.executable && (!explicit || explicit === saved.sourceExecutable) && codexHome === saved.codexHome
+      && runtimeFilesAvailable(saved.executable) && saved.fingerprint === runtimeFingerprint(saved.executable)) return saved;
+  const candidates = [];
+  for (const candidate of discoverCodex({ ...environment, CODEX_HOME: codexHome, CODE_RELAX_CODEX_PATH: explicit })) {
+    try {
+      const { stdout } = await exec(candidate.executable, ['--version'], { timeout: 10000, env: { ...environment, CODEX_HOME: codexHome } });
+      const version = /^codex-cli (\d+\.\d+\.\d+(?:-[\w.]+)?)/m.exec(stdout)?.[1];
+      if (!version) throw new Error('无法识别 Codex 版本');
+      candidates.push({ ...candidate, version });
+    } catch (error) { throw new Error(`无法确认 Codex 候选版本，未降级：${candidate.executable}: ${error.message}`); }
+  }
+  const candidate = newestRuntime(candidates);
+  if (candidate) {
+    try {
+      if (!runtimeFilesAvailable(candidate.executable)) throw new Error('缺少配套原生 codex-code-mode-host');
+      const retained = await retainRuntime(candidate.executable, stateRoot, candidate.version);
+      await verifyProtocol(retained.executable, stateRoot);
+      const result = { ...candidate, ...retained, codexHome, fingerprint: runtimeFingerprint(retained.executable) };
+      writeRecord(recordFile, result);
+      return result;
+    } catch (error) { throw new Error(`最新 Codex 内核 ${candidate.version} 校验失败，未降级：${candidate.executable}: ${error.message}`); }
+  }
+  throw new Error('未找到 Mac Codex 内核，请安装官方 Codex 应用或完整 CLI 并登录账号。');
+}