@walkhi/code-relax 0.1.0-beta.1

package/dist/src/lan-socket-server.mjs

@@ -0,0 +1,103 @@
+import { EventEmitter } from 'node:events';
+import crypto from 'node:crypto';
+import { WebSocketServer, WebSocket } from 'ws';
+
+// One authenticated connection carries requests and explicitly owned subscriptions.
+// The dispatcher is shared business routing, not an HTTP loopback proxy.
+export function attachLanSocket(server, { token, dispatch, authorizeDevice = () => false }) {
+  // Allow four individually valid images to reach the aggregate-size validator,
+  // so an oversized composition returns an error instead of dropping the connection.
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 48 * 1024 * 1024, perMessageDeflate: false });
+  server.on('upgrade', (request, socket, head) => {
+    const origin = request.headers.origin;
+    let allowed = request.url === '/api/socket';
+    // Packaged ArkWeb pages have an opaque ("null") origin; device authentication remains required.
+    if (origin && origin !== 'null') {
+      try { allowed &&= new URL(origin).host === request.headers.host && ['http:', 'https:'].includes(new URL(origin).protocol); }
+      catch { allowed = false; }
+    }
+    if (!allowed) { socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n'); return; }
+    wss.handleUpgrade(request, socket, head, ws => wss.emit('connection', ws));
+  });
+  wss.on('connection', ws => {
+    let authenticated = false, alive = true;
+    const active = new Map();
+    const send = value => {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      if (ws.bufferedAmount > 64 * 1024 * 1024) { ws.close(1013, 'Client too slow'); return; }
+      ws.send(JSON.stringify(value));
+    };
+    const authTimer = setTimeout(() => ws.close(1008, 'Authentication required'), 5000);
+    const heartbeat = setInterval(() => {
+      if (!alive) { ws.terminate(); return; }
+      alive = false; ws.ping();
+    }, 30000);
+    ws.on('pong', () => { alive = true; });
+    ws.on('error', () => {}); // close rejects requests and releases every subscription.
+    ws.on('close', () => {
+      clearTimeout(authTimer); clearInterval(heartbeat);
+      for (const reply of active.values()) reply.end();
+      active.clear();
+    });
+    ws.on('message', async (bytes, binary) => {
+      let message;
+      try { if (binary) throw new Error(); message = JSON.parse(bytes.toString()); }
+      catch { ws.close(1008, 'Invalid JSON'); return; }
+      if (!message || typeof message !== 'object') { ws.close(1008, 'Invalid message'); return; }
+      if (!authenticated) {
+        let accepted = false;
+        if (message.type === 'device-auth') {
+          accepted = authorizeDevice(message.clientId, message.credential) === true;
+        } else if (message.type === 'auth') {
+          const supplied = Buffer.from(typeof message.token === 'string' ? message.token : '');
+          const expected = Buffer.from(token || '');
+          accepted = supplied.length === expected.length && crypto.timingSafeEqual(supplied, expected);
+        }
+        if (!accepted) {
+          ws.close(1008, 'Authentication failed'); return;
+        }
+        authenticated = true; clearTimeout(authTimer); send({ type: 'ready', version: 1 }); return;
+      }
+      const { id, type } = message;
+      if (!Number.isSafeInteger(id) || id < 1) { ws.close(1008, 'Invalid request id'); return; }
+      if (type === 'unsubscribe') { const reply = active.get(id); if (reply?.subscription) reply.end(); return; }
+      if (!['request', 'subscribe'].includes(type) || active.has(id)) { ws.close(1008, 'Invalid request'); return; }
+      const subscription = type === 'subscribe';
+      const path = message.path;
+      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|shared-recovery\/events|threads\/[^/?]+\/events)(?:\?|$)/.test(path);
+      if (active.size >= 32 || (subscription && [...active.values()].filter(r => r.subscription).length >= 4)) {
+        send({ type: 'response', id, status: 429, body: { error: '同时进行的请求过多' } }); return;
+      }
+      if (typeof path !== 'string' || !path.startsWith('/api/') || path.includes('#') ||
+          path.startsWith('/api/attachments/') || path === '/api/socket' || path === '/api/uploads' ||
+          subscription !== isStream || !['GET', 'POST', 'DELETE'].includes(message.method || 'GET') ||
+          (subscription && message.method && message.method !== 'GET') ||
+          (message.body !== undefined && (!message.body || typeof message.body !== 'object' || Array.isArray(message.body)))) {
+        send({ type: 'response', id, status: 400, body: { error: '无效的连接请求' } }); return;
+      }
+      const reply = new EventEmitter();
+      Object.assign(reply, {
+        subscription, headersSent: false, writableEnded: false, destroyed: false,
+        json(status, body) {
+          if (this.writableEnded) return;
+          send({ type: 'response', id, status, body }); this.end();
+        },
+        startEvents() {
+          if (this.writableEnded) return;
+          this.headersSent = true; send({ type: 'subscribed', id });
+        },
+        event(event, data) { if (!this.writableEnded) send({ type: 'event', id, event, data }); },
+        end() {
+          if (this.writableEnded) return;
+          this.writableEnded = this.destroyed = true; active.delete(id);
+          if (subscription) send({ type: 'end', id });
+          this.emit('close');
+        },
+      });
+      active.set(id, reply);
+      try { await dispatch({ method: message.method || 'GET', url: path, body: message.body || {}, headers: {}, socketRequest: true }, reply); }
+      catch (error) { reply.json(500, { error: error.message }); }
+    });
+  });
+  return { close() { for (const ws of wss.clients) ws.terminate(); wss.close(); } };
+}

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

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { setTimeout as delay } from 'node:timers/promises';
+import { readRecord, writeRecord } from './service-lifecycle.mjs';
+import { SharedAppServer } from './shared-app-server.mjs';
+
+export const managedAppServerUrl = 'ws://127.0.0.1:45839';
+export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
+const retryDelays = [1_000, 2_000, 5_000, 10_000, 20_000];
+
+export function managedPortAvailable() {
+  return new Promise(resolve => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.listen(45839, '127.0.0.1', () => server.close(() => resolve(true)));
+  });
+}
+
+export class ManagedAppServer extends EventEmitter {
+  constructor({ stateRoot, host, environment = process.env, available = managedPortAvailable,
+    wait = delay, timeout = 30_000, now = Date.now, client = new SharedAppServer(managedAppServerUrl) }) {
+    super();
+    this.stateRoot = stateRoot;
+    this.host = host;
+    this.environment = environment;
+    this.available = available;
+    this.wait = wait;
+    this.timeout = timeout;
+    this.now = now;
+    this.recordPath = path.join(stateRoot, 'managed-app-server.json');
+    this.legacyRecordPath = path.join(stateRoot, 'shared-desktop.json');
+    this.client = client;
+    this.state = { state: 'absent', ready: false, error: null };
+    this.restartStatus = null;
+    this.stopped = true;
+    this.restarting = false;
+    this.retryAttempt = 0;
+    this.retryAfter = 0;
+    this.client.on('disconnected', () => {
+      if (!this.stopped && !this.restarting) this.failed('Codex 内核连接断开。');
+    });
+  }
+
+  snapshot() { return { ...this.state, ...(this.restartStatus ? { restart: { ...this.restartStatus } } : {}) }; }
+
+  async start() {
+    this.stopped = false;
+    return this.ensure();
+  }
+
+  async ensure() {
+    if (this.stopped) return false;
+    if (this.restarting) return false;
+    if (this.work) return this.work;
+    if (this.now() < this.retryAfter) return false;
+    this.work = this.ensureNow().finally(() => { this.work = null; });
+    return this.work;
+  }
+
+  async ensureNow() {
+    // Keep an already verified instance available while the periodic identity
+    // check runs; publishing "starting" every three seconds makes health flicker.
+    if (!this.state.ready) this.publish({ state: 'starting', ready: false, error: null });
+    try {
+      fs.mkdirSync(this.stateRoot, { recursive: true });
+      const info = await this.host.inspect();
+      if (!info.cli) throw new Error('未找到 Desktop 管理的 codex.exe，请先安装并登录 Codex Desktop。');
+      let record = null, actual = null;
+      for (const candidate of [readRecord(this.recordPath), readRecord(this.legacyRecordPath)].filter(Boolean)) {
+        const process = candidate.pid ? await this.host.process(candidate.pid) : null;
+        if (sameManagedProcess(candidate, process)) { record = candidate; actual = process; break; }
+      }
+      if (!actual) {
+        if (!await this.available()) throw new Error('45839 被未识别进程占用，未启动或结束任何进程。');
+        const childEnvironment = { ...this.environment };
+        for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnvironment[key];
+        const pid = await this.host.start(info.cli, ['app-server', '--listen', managedAppServerUrl], childEnvironment,
+          [path.join(this.stateRoot, 'managed-app-server.stdout.log'), path.join(this.stateRoot, 'managed-app-server.stderr.log')]);
+        const started = await this.host.process(pid);
+        if (!sameManagedProcess(started, started)) throw new Error('Codex 内核启动后进程身份无法确认。');
+        record = actual = started;
+        writeRecord(this.recordPath, record);
+      } else if (!readRecord(this.recordPath)) {
+        writeRecord(this.recordPath, actual);
+      }
+      await this.waitUntilReady(actual);
+      await this.client.connect();
+      if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
+      const preferredExecutable = path.resolve(info.cli);
+      const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
+      this.retryAttempt = 0;
+      this.retryAfter = 0;
+      this.publish({ state: 'ready', ready: true, error: null, pid: actual.pid,
+        created: actual.created, executable: actual.executable, preferredExecutable,
+        updatePending, url: managedAppServerUrl });
+      return true;
+    } catch (error) {
+      this.failed(error instanceof Error ? error.message : String(error));
+      return false;
+    }
+  }
+
+  async waitUntilReady(expected) {
+    const deadline = this.now() + this.timeout;
+    while (true) {
+      const actual = await this.host.process(expected.pid);
+      if (!sameManagedProcess(expected, actual)) throw new Error('Codex 内核在就绪前退出。');
+      if (await this.host.ready(managedAppServerReadyUrl)) return;
+      if (this.now() >= deadline) throw new Error('Codex 内核未在 30 秒内就绪，请查看工作站诊断日志。');
+      await this.wait(250);
+    }
+  }
+
+  restart(operationId) {
+    if (this.stopped) throw new Error('工作站服务正在停止，不能重启 Codex 内核。');
+    if (this.restartWork) {
+      if (this.restartStatus?.operationId === operationId) return this.snapshot();
+      const error = new Error('Codex 内核已经在重启，请等待当前操作完成。');
+      error.code = 'managed_app_server_restarting';
+      throw error;
+    }
+    this.restartStatus = { operationId, status: 'running', stage: 'checking', error: null,
+      startedAt: new Date(this.now()).toISOString() };
+    this.emit('state', this.snapshot());
+    this.restartWork = this.restartNow().finally(() => { this.restartWork = null; });
+    return this.snapshot();
+  }
+
+  async restartNow() {
+    this.restarting = true;
+    const previous = this.state;
+    this.publish({ ...previous, state: 'restarting', ready: false, error: null });
+    try {
+      const record = readRecord(this.recordPath) || readRecord(this.legacyRecordPath);
+      const actual = record?.pid ? await this.host.process(record.pid) : null;
+      if (actual && !sameManagedProcess(record, actual)) {
+        throw new Error('Codex 内核进程身份已经变化，未结束任何进程。');
+      }
+      this.restartStage('stopping');
+      this.client.close();
+      if (actual) {
+        await this.host.stop(actual.pid);
+        await this.waitUntilStopped(actual);
+      } else if (!await this.available()) {
+        throw new Error('45839 被未识别进程占用，未结束任何进程。');
+      }
+      fs.rmSync(this.recordPath, { force: true });
+      this.retryAttempt = 0;
+      this.retryAfter = 0;
+      this.restartStage('starting');
+      const ready = await this.ensureNow();
+      if (!ready) throw new Error(this.state.error || 'Codex 内核未能重新启动。');
+      this.restartStatus = { ...this.restartStatus, status: 'completed', stage: 'ready',
+        completedAt: new Date(this.now()).toISOString() };
+      this.emit('state', this.snapshot());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (this.state.state === 'restarting') this.failed(message);
+      this.restartStatus = { ...this.restartStatus, status: 'failed', stage: 'failed', error: message,
+        completedAt: new Date(this.now()).toISOString() };
+      this.emit('state', this.snapshot());
+    } finally {
+      this.restarting = false;
+    }
+  }
+
+  restartStage(stage) {
+    this.restartStatus = { ...this.restartStatus, stage };
+    this.emit('state', this.snapshot());
+  }
+
+  async waitUntilStopped(expected) {
+    const deadline = this.now() + 10_000;
+    while (true) {
+      const actual = await this.host.process(expected.pid);
+      if (!sameManagedProcess(expected, actual) && await this.available()) return;
+      if (this.now() >= deadline) throw new Error('Codex 内核未在 10 秒内退出；不会启动第二个实例。');
+      await this.wait(100);
+    }
+  }
+
+  failed(message) {
+    const retryMs = retryDelays[Math.min(this.retryAttempt++, retryDelays.length - 1)];
+    this.retryAfter = this.now() + retryMs;
+    this.publish({ state: 'failed', ready: false, error: message, retryAt: new Date(this.retryAfter).toISOString() });
+  }
+
+  publish(value) {
+    const changed = JSON.stringify(value) !== JSON.stringify(this.state);
+    this.state = value;
+    if (changed) this.emit('state', this.snapshot());
+  }
+
+  close() {
+    this.stopped = true;
+    this.client.close();
+  }
+}
+
+export function sameManagedProcess(record, actual) {
+  if (!record || !actual || record.pid !== actual.pid || record.created !== actual.created) return false;
+  if (String(record.executable || '').toLowerCase() !== String(actual.executable || '').toLowerCase()) return false;
+  const command = String(actual.command || '').toLowerCase();
+  return command.includes('app-server') && command.includes(managedAppServerUrl);
+}

package/dist/src/message-images.mjs

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import sharp from 'sharp';
+
+export function validateInlineImage(value) {
+  const data = typeof value === 'string' ? value.slice(value.indexOf(',') + 1) : '';
+  if (typeof value !== 'string' || value.length > Math.ceil(8 * 1024 * 1024 / 3) * 4 + 64 ||
+      !/^data:image\/(?:jpeg|png|webp);base64,/.test(value) || !data || data.length % 4 !== 0 ||
+      !/^[A-Za-z0-9+/]*={0,2}$/.test(data) || Buffer.byteLength(data, 'base64') > 8 * 1024 * 1024) {
+    throw new Error('图片必须是 JPEG、PNG 或 WebP 数据，且不超过 8 MiB。');
+  }
+  return value;
+}
+
+// Only the Desktop tool compatibility path needs a file visible to the host.
+export async function persistLegacyImage(value, directory) {
+  validateInlineImage(value);
+  const input = Buffer.from(value.slice(value.indexOf(',') + 1), 'base64');
+  const buffer = await sharp(input, { limitInputPixels: 40_000_000 }).rotate()
+    .resize({ width: 2560, height: 2560, fit: 'inside', withoutEnlargement: true }).webp({ quality: 88 }).toBuffer();
+  const id = crypto.createHash('sha256').update(buffer).digest('hex');
+  await fs.mkdir(directory, { recursive: true });
+  const file = path.join(directory, `${id}.webp`);
+  await fs.writeFile(file, buffer);
+  return file;
+}

package/dist/src/onboarding.mjs

@@ -0,0 +1,31 @@
+export const connectionModesText = [
+  '可选连接模式：',
+  '• 局域网：启动时会把当前 Wi-Fi/有线网络候选临时发给已配对设备；App 验证后保存，也可手动输入 IP。',
+  '• 私有中继：同一设备授权可跨网络长期重连；基础控制/完整控制能力由电脑当前 Bridge 状态决定。',
+  '• OpenAI 官方中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
+].join('\n');
+
+export function phonePairingSteps(transportMode, paired = false) {
+  const mode = transportMode === 'lan-shared' ? '局域网 · 完整控制' : transportMode === 'lan-legacy' ? '局域网 · 基础控制' : '局域网（按电脑实际控制方式选择）';
+  return paired ? [
+    `已有移动设备授权。手机可继续使用私有中继；${mode} 会显示验证成功的当前网络和历史记录。`,
+    '添加另一台设备时执行 relax pair；每台设备只需扫码配对一次。',
+  ] : [
+    '手机先安装 Code Relax。当前为鸿蒙 HarmonyOS 7 私测版，调试 HAP 需通过 DevEco/调试设备安装，尚无商店下载入口。',
+    '使用 App 扫描配对二维码；每台移动设备只需配对一次。',
+    `配对后可直接使用私有中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
+  ];
+}
+export const desktopSetupSteps = [
+  'Code Relax Skill 已随 npm 包自动安装。',
+  '安装完成后 Bridge 和受管 app-server 已启动，并默认在当前用户登录时启动。',
+  '如果安装时 Codex 仍在运行，手机完整控制仍可使用；可选择立即或稍后重启，让 Desktop 也接入同一受管服务。',
+  '基础控制首次聊天需要在 Codex 对话启动一次 Code Relax 绑定上下文；完整控制不需要。',
+  '尚无设备授权时执行 relax pair，打开并扫描配对二维码。',
+  '若工作站提示 Desktop 尚未接入受管服务，可在手机确认重新打开 Desktop，无需电脑脚本或快捷方式。',
+  '统一配对先建立电脑记录；进入该电脑后可另行完成 OpenAI 官方 Remote 配对。',
+];
+
+export function pairingDisplayText(nextSteps, notice) {
+  return ['Bridge 已就绪，请在手机上完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
+}

package/dist/src/platform/README.md

@@ -0,0 +1,12 @@
+# 被控主机平台适配
+
+当前只实现 Windows Codex：
+
+- `windows/runtime-paths.mjs`：固定服务、用户状态、Codex 数据、附件和长期凭据路径。
+- `windows/service-host.mjs`、`desktop-tools.mjs`：网卡、Desktop 工具管道、共享连接检测和旧状态迁移。
+- `windows/desktop-host.mjs`、PowerShell 脚本：普通/共享 Desktop、快捷方式和隐藏控制台启动。
+- `windows/credential-store.mjs/.ps1`：私有中继电脑凭据的 DPAPI 与 ACL。
+
+Windows 专有脚本兼容系统自带 PowerShell 5.1。通用生命周期使用 Node 接口；系统检测和凭据保护不扩散到业务代码。
+
+macOS、Linux 目录仅保留规划说明，尚无路径、IPC、进程或安装实现。接入排在控制端扩展之后，并需分别验证 Codex Desktop/app-server 的可用连接方式；只有独立 app-server 时不能宣称接管 Desktop 当前任务。

package/dist/src/platform/linux/README.md

@@ -0,0 +1,3 @@
+# linux 被控主机（预留）
+
+仅规划 Codex 的系统路径、进程/IPC 和运行环境适配，尚未实现。接入排在控制端扩展之后；不预设支持 Desktop 共享任务。

package/dist/src/platform/macos/README.md

@@ -0,0 +1,3 @@
+# macos 被控主机（预留）
+
+仅规划 Codex 的系统路径、进程/IPC 和运行环境适配，尚未实现。接入排在控制端扩展之后；不预设支持 Desktop 共享任务。

package/dist/src/platform/windows/IsolatedProcess.cs

@@ -0,0 +1,75 @@
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+// Only the three explicitly opened standard handles cross the process boundary.
+// In particular, inherited app-server sockets must not reach background workers.
+public static class IsolatedProcess {
+    [StructLayout(LayoutKind.Sequential)] struct Security { public int length; public IntPtr descriptor; public int inherit; }
+    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct Startup {
+        public int cb; public string reserved, desktop, title;
+        public int x,y,xSize,ySize,xCount,yCount,fill,flags; public short show,reservedSize;
+        public IntPtr reservedBytes,input,output,error;
+    }
+    [StructLayout(LayoutKind.Sequential)] struct StartupEx { public Startup startup; public IntPtr attributes; }
+    [StructLayout(LayoutKind.Sequential)] struct ProcessInfo { public IntPtr process,thread; public int pid,tid; }
+    [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFileW(string name,uint access,uint share,ref Security security,uint disposition,uint flags,IntPtr template);
+    [DllImport("kernel32.dll", SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list,int count,int flags,ref IntPtr size);
+    [DllImport("kernel32.dll", SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list,uint flags,IntPtr attribute,IntPtr value,IntPtr size,IntPtr previous,IntPtr returned);
+    [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+    [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcessW(string application,StringBuilder command,IntPtr processSecurity,IntPtr threadSecurity,bool inherit,uint flags,IntPtr environment,string cwd,ref StartupEx startup,out ProcessInfo info);
+    [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+    [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern uint GetFinalPathNameByHandleW(IntPtr handle,StringBuilder path,uint length,uint flags);
+    public static string ResolvePath(string path) {
+        var security=new Security {length=Marshal.SizeOf(typeof(Security))};
+        var handle=CreateFileW(path,0,7,ref security,3,0x02000000,IntPtr.Zero);
+        if(handle==new IntPtr(-1)) throw new Win32Exception(Marshal.GetLastWin32Error());
+        try {
+            var result=new StringBuilder(32768);
+            uint length=GetFinalPathNameByHandleW(handle,result,(uint)result.Capacity,0);
+            if(length==0 || length>=result.Capacity) throw new Win32Exception(Marshal.GetLastWin32Error());
+            var value=result.ToString();
+            return value.StartsWith(@"\\?\UNC\") ? @"\\"+value.Substring(8) : value.StartsWith(@"\\?\") ? value.Substring(4) : value;
+        } finally { CloseHandle(handle); }
+    }
+    static string Quote(string value) {
+        var result=new StringBuilder("\""); int slashes=0;
+        foreach(char c in value) {
+            if(c=='\\') { slashes++; continue; }
+            result.Append('\\', c=='"' ? slashes*2+1 : slashes); slashes=0; result.Append(c);
+        }
+        result.Append('\\',slashes*2); return result.Append('"').ToString();
+    }
+    static IntPtr File(string file,bool input) {
+        var sa=new Security { length=Marshal.SizeOf(typeof(Security)), inherit=1 };
+        // FILE_APPEND_DATA avoids truncating diagnostic history on recovery.
+        var handle=CreateFileW(file,input?0x80000000u:4u,7,ref sa,input?3u:4u,0x80,IntPtr.Zero);
+        if(handle==new IntPtr(-1)) throw new Win32Exception(Marshal.GetLastWin32Error());
+        return handle;
+    }
+    public static int Start(string executable,string[] arguments,string stdout,string stderr) {
+        IntPtr input=IntPtr.Zero,output=IntPtr.Zero,error=IntPtr.Zero,list=IntPtr.Zero,handles=IntPtr.Zero;
+        bool initialized=false;
+        try {
+            input=File("NUL",true); output=File(String.IsNullOrEmpty(stdout)?"NUL":stdout,false); error=File(String.IsNullOrEmpty(stderr)?"NUL":stderr,false);
+            IntPtr size=IntPtr.Zero; InitializeProcThreadAttributeList(IntPtr.Zero,1,0,ref size);
+            list=Marshal.AllocHGlobal(size);
+            if(!InitializeProcThreadAttributeList(list,1,0,ref size)) throw new Win32Exception(Marshal.GetLastWin32Error());
+            initialized=true; handles=Marshal.AllocHGlobal(IntPtr.Size*3);
+            Marshal.Copy(new IntPtr[]{input,output,error},0,handles,3);
+            if(!UpdateProcThreadAttribute(list,0,new IntPtr(0x20002),handles,new IntPtr(IntPtr.Size*3),IntPtr.Zero,IntPtr.Zero)) throw new Win32Exception(Marshal.GetLastWin32Error());
+            var startup=new StartupEx(); startup.startup.cb=Marshal.SizeOf(typeof(StartupEx));
+            startup.startup.flags=0x101; startup.startup.show=0;
+            startup.startup.input=input; startup.startup.output=output; startup.startup.error=error; startup.attributes=list;
+            var command=new StringBuilder(Quote(executable)); foreach(var argument in arguments) command.Append(' ').Append(Quote(argument));
+            ProcessInfo info;
+            if(!CreateProcessW(executable,command,IntPtr.Zero,IntPtr.Zero,true,0x80010,IntPtr.Zero,null,ref startup,out info)) throw new Win32Exception(Marshal.GetLastWin32Error());
+            CloseHandle(info.thread); CloseHandle(info.process); return info.pid;
+        } finally {
+            if(initialized) DeleteProcThreadAttributeList(list);
+            if(list!=IntPtr.Zero) Marshal.FreeHGlobal(list); if(handles!=IntPtr.Zero) Marshal.FreeHGlobal(handles);
+            if(input!=IntPtr.Zero) CloseHandle(input); if(output!=IntPtr.Zero) CloseHandle(output); if(error!=IntPtr.Zero) CloseHandle(error);
+        }
+    }
+}

package/dist/src/platform/windows/background-process.mjs

@@ -0,0 +1,25 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+export function startWindowsProcess(executable, args, environment, logs = []) {
+  return new Promise((resolve, reject) => {
+    const powershell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+    const helper = spawn(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+      fileURLToPath(new URL('./start-hidden-console.ps1', import.meta.url))], {
+      windowsHide: true, env: environment, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let output = '', error = '';
+    helper.stdout.setEncoding('utf8').on('data', chunk => { output += chunk; });
+    helper.stderr.setEncoding('utf8').on('data', chunk => { error += chunk; });
+    helper.once('error', reject); helper.stdin.on('error', reject);
+    helper.once('exit', code => {
+      helper.stdout.destroy(); helper.stderr.destroy(); helper.stdin.destroy();
+      if (code !== 0) return reject(new Error(error.trim() || `后台启动失败 (${code})`));
+      const pid = Number(output.trim());
+      if (!Number.isSafeInteger(pid) || pid <= 0) return reject(new Error('后台启动未返回有效 PID'));
+      resolve(pid);
+    });
+    helper.stdin.end(JSON.stringify({ executable, args, logs }));
+  });
+}

package/dist/src/platform/windows/credential-store.mjs

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runtimePaths } from './runtime-paths.mjs';
+
+// Secrets travel over stdin/stdout only; never PowerShell arguments or errors.
+export function credentialStore(action, record, root = runtimePaths().credentialsRoot) {
+  if (process.platform !== 'win32') throw new Error('Credential platform adapter unavailable');
+  return new Promise((resolve, reject) => {
+    const child = spawn(path.join(process.env.SystemRoot, 'System32/WindowsPowerShell/v1.0/powershell.exe'),
+      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+        fileURLToPath(new URL('./credential-store.ps1', import.meta.url))],
+      { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    let output = '', diagnostic = '';
+    const timer = setTimeout(() => child.kill(), 15000);
+    child.stdout.setEncoding('utf8'); child.stdout.on('data', data => { output += data; });
+    child.stderr.setEncoding('utf8'); child.stderr.on('data', data => { diagnostic += data; }); child.stdin.on('error', () => {});
+    child.once('error', () => { clearTimeout(timer); reject(new Error('无法启动 Windows 凭据保护组件')); });
+    child.once('close', code => {
+      clearTimeout(timer);
+      if (code !== 0) return reject(new Error('Windows 凭据保护失败，未使用明文替代；请检查目录权限或 Windows 用户是否一致；' + diagnostic.trim()));
+      try { resolve(JSON.parse(output.replace(/^\uFEFF/, ''))); }
+      catch { reject(new Error('Windows 凭据保护返回无效结果')); }
+    });
+    child.stdin.end(JSON.stringify({ action, root, record }));
+  });
+}

package/dist/src/platform/windows/credential-store.ps1

@@ -0,0 +1,49 @@
+$ErrorActionPreference = 'Stop'
+[Console]::InputEncoding = New-Object System.Text.UTF8Encoding($false)
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+try {
+  Add-Type -AssemblyName System.Security
+  $request = [Console]::In.ReadToEnd() | ConvertFrom-Json
+  $sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+  $directory = Join-Path ([System.IO.Path]::GetFullPath($request.root)) $sid.Value
+  if (!(Test-Path -LiteralPath $directory)) { New-Item -ItemType Directory -Path $directory -Force | Out-Null }
+  if ((Get-Item -LiteralPath $directory).Attributes -band [System.IO.FileAttributes]::ReparsePoint) { throw 'Invalid credential directory' }
+  $acl = New-Object System.Security.AccessControl.DirectorySecurity
+  $acl.SetAccessRuleProtection($true, $false)
+  foreach ($principal in @($sid.Value, 'S-1-5-18', 'S-1-5-32-544')) {
+    $identity = New-Object System.Security.Principal.SecurityIdentifier($principal)
+    $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($identity, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow')
+    $acl.AddAccessRule($rule)
+  }
+  [System.IO.Directory]::SetAccessControl($directory, $acl)
+  $file = Join-Path $directory 'self-relay.json'
+  if (Test-Path -LiteralPath $file) {
+    if ((Get-Item -LiteralPath $file).Attributes -band [System.IO.FileAttributes]::ReparsePoint) { throw 'Invalid credential file' }
+  }
+  if ($request.action -eq 'save') {
+    $plain = [System.Text.Encoding]::UTF8.GetBytes(($request.record | ConvertTo-Json -Depth 12 -Compress))
+    $encrypted = [System.Security.Cryptography.ProtectedData]::Protect($plain, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+    $json = @{ version = 1; protection = 'DPAPI-CurrentUser'; data = [Convert]::ToBase64String($encrypted) } | ConvertTo-Json -Compress
+    $temporary = Join-Path $directory ([Guid]::NewGuid().ToString() + '.tmp')
+    $backup = $temporary + '.bak'
+    try {
+      $stream = [System.IO.File]::Open($temporary, [System.IO.FileMode]::CreateNew, [System.IO.FileAccess]::Write)
+      try { $bytes = [System.Text.Encoding]::UTF8.GetBytes($json); $stream.Write($bytes, 0, $bytes.Length); $stream.Flush($true) } finally { $stream.Dispose() }
+      if (Test-Path -LiteralPath $file) { [System.IO.File]::Replace($temporary, $file, $backup) } else { [System.IO.File]::Move($temporary, $file) }
+    } finally {
+      if (Test-Path -LiteralPath $temporary) { Remove-Item -LiteralPath $temporary -Force }
+      if (Test-Path -LiteralPath $backup) { Remove-Item -LiteralPath $backup -Force }
+    }
+  } elseif ($request.action -ne 'load') { throw 'Invalid operation' }
+  $record = $null
+  if (Test-Path -LiteralPath $file) {
+    $envelope = [System.IO.File]::ReadAllText($file, [System.Text.Encoding]::UTF8) | ConvertFrom-Json
+    if ($envelope.version -ne 1 -or $envelope.protection -ne 'DPAPI-CurrentUser') { throw 'Invalid credential envelope' }
+    $plain = [System.Security.Cryptography.ProtectedData]::Unprotect([Convert]::FromBase64String($envelope.data), $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+    $record = [System.Text.Encoding]::UTF8.GetString($plain) | ConvertFrom-Json
+  }
+  [Console]::Write((@{ path = $file; record = $record } | ConvertTo-Json -Depth 12 -Compress))
+} catch {
+  [Console]::Error.WriteLine('Credential protection failed: ' + $_.Exception.GetType().Name + ' at line ' + $_.InvocationInfo.ScriptLineNumber)
+  exit 1
+}

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

@@ -0,0 +1,38 @@
+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 { 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 });
+  return stdout.trim();
+}
+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),
+  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 async function desktopShortcuts({ serviceRoot, nodeExecutable }, remove = false, 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());
+}

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

@@ -0,0 +1,16 @@
+param([int]$ProcessId = 0)
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+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 }
+    else { 'null' }
+    exit
+}
+$package = Get-AppxPackage OpenAI.Codex | Select-Object -First 1
+if (-not $package) { throw '未找到 Codex Desktop，请先安装并登录。' }
+$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