@walkhi/code-relax 0.1.0-beta.26 → 0.1.0-beta.28

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

@@ -1,238 +1,241 @@
-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';
-import { pruneRetainedDesktopRuntimes, resolveCodexRuntime, runtimeFilesAvailable } from './platform/windows/codex-runtime.mjs';
-
-export const managedAppServerUrl = 'ws://127.0.0.1:45839';
-export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
-export const managedAppServerLauncherRevision = 2;
-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.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,
-      version: this.state.ready && this.client.ready ? this.client.serverVersion || null : null,
-      ...(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 });
-      let record = null, actual = null;
-      const candidate = readRecord(this.recordPath);
-      const process = candidate?.pid ? await this.host.process(candidate.pid) : null;
-      if (sameManagedProcess(candidate, process)) { record = candidate; actual = process; }
-      const startedHere = !actual;
-      const savedRuntime = actual ? readRecord(path.join(this.stateRoot, 'codex-runtime.json')) : null;
-      const runtime = actual && savedRuntime?.executable && runtimeFilesAvailable(savedRuntime.executable)
-        ? savedRuntime
-        : await resolveCodexRuntime(this.stateRoot, { refresh: !actual, environment: this.environment });
-      if (actual && !runtimeFilesAvailable(actual.executable)) {
-        throw new Error(`运行中的 Codex 内核目录已被移除或缺少 codex-code-mode-host.exe：${actual.executable}；已找到可用内核 ${runtime.executable}，请确认重启内核。`);
-      }
-      if (!actual) {
-        if (!await this.available()) throw new Error('45839 被未识别进程占用，未启动或结束任何进程。');
-        const childEnvironment = { ...this.environment };
-        childEnvironment.CODEX_HOME = runtime.codexHome;
-        for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnvironment[key];
-        for (const key of Object.keys(childEnvironment)) {
-          if (/^npm_/iu.test(key) || key.toUpperCase() === 'INIT_CWD') delete childEnvironment[key];
-        }
-        const pid = await this.host.start(runtime.executable, ['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 内核启动后进程身份无法确认。');
-        actual = started;
-        record = { ...started, launcherRevision: managedAppServerLauncherRevision };
-        writeRecord(this.recordPath, record);
-      } else if (!readRecord(this.recordPath)) {
-        record = { ...actual, launcherRevision: Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0 };
-        writeRecord(this.recordPath, record);
-      }
-      await this.waitUntilReady(actual);
-      await this.client.connect();
-      if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
-      if (startedHere) {
-        try { pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
-        catch (error) { console.error('旧版 Codex 内核文件清理失败：', error); }
-      }
-      const preferredExecutable = path.resolve(runtime.executable);
-      const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
-      const launcherRevision = Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0;
-      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, launcherRevision, selectedVersion: runtime.version, source: runtime.source,
-        launcherRestartRequired: launcherRevision !== managedAppServerLauncherRevision,
-        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);
-      const actual = record?.pid ? await this.host.process(record.pid) : null;
-      if (actual && !sameManagedProcess(record, actual)) {
-        throw new Error('Codex 内核进程身份已经变化，未结束任何进程。');
-      }
-      if (!actual && !await this.available()) throw new Error('45839 被未识别进程占用，未结束任何进程。');
-      this.restartStage('stopping');
-      // Resolve the replacement before stopping the current working process.
-      const runtime = await resolveCodexRuntime(this.stateRoot, { refresh: true, environment: this.environment });
-      const desktop = await this.host.prepareKernelRestart?.();
-      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 内核未能重新启动。');
-      const desktopEnvironment = { ...this.environment, CODEX_HOME: runtime.codexHome, CODEX_APP_SERVER_WS_URL: managedAppServerUrl };
-      delete desktopEnvironment.CODEX_APP_SERVER_FORCE_CLI;
-      delete desktopEnvironment.CODEX_APP_TOOLS_PIPE_PATH;
-      await this.host.resumeAfterKernelRestart?.(desktop, desktopEnvironment);
-      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);
-}
+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';
+import { pruneRetainedDesktopRuntimes, resolveCodexRuntime, runtimeFilesAvailable } from './platform/windows/codex-runtime.mjs';
+
+export const managedAppServerUrl = 'ws://127.0.0.1:45839';
+export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
+export const managedAppServerLauncherRevision = 3;
+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.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,
+      version: this.state.ready && this.client.ready ? this.client.serverVersion || null : null,
+      ...(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 });
+      let record = null, actual = null;
+      const candidate = readRecord(this.recordPath);
+      const process = candidate?.pid ? await this.host.process(candidate.pid) : null;
+      if (sameManagedProcess(candidate, process)) { record = candidate; actual = process; }
+      const startedHere = !actual;
+      const savedRuntime = actual ? readRecord(path.join(this.stateRoot, 'codex-runtime.json')) : null;
+      const runtime = actual && savedRuntime?.executable && runtimeFilesAvailable(savedRuntime.executable)
+        ? savedRuntime
+        : await resolveCodexRuntime(this.stateRoot, { refresh: !actual, environment: this.environment });
+      if (actual && !runtimeFilesAvailable(actual.executable)) {
+        throw new Error(`运行中的 Codex 内核目录已被移除或缺少 codex-code-mode-host.exe：${actual.executable}；已找到可用内核 ${runtime.executable}，请确认重启内核。`);
+      }
+      if (!actual) {
+        if (!await this.available()) throw new Error('45839 被未识别进程占用，未启动或结束任何进程。');
+        const childEnvironment = { ...this.environment };
+        childEnvironment.CODEX_HOME = runtime.codexHome;
+        // Desktop's inherited INFO tracing can emit enter/exit on every poll.
+        // The managed background kernel retains warnings and errors only.
+        childEnvironment.RUST_LOG = 'warn';
+        for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnvironment[key];
+        for (const key of Object.keys(childEnvironment)) {
+          if (/^npm_/iu.test(key) || key.toUpperCase() === 'INIT_CWD') delete childEnvironment[key];
+        }
+        const pid = await this.host.start(runtime.executable, ['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 内核启动后进程身份无法确认。');
+        actual = started;
+        record = { ...started, launcherRevision: managedAppServerLauncherRevision };
+        writeRecord(this.recordPath, record);
+      } else if (!readRecord(this.recordPath)) {
+        record = { ...actual, launcherRevision: Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0 };
+        writeRecord(this.recordPath, record);
+      }
+      await this.waitUntilReady(actual);
+      await this.client.connect();
+      if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
+      if (startedHere) {
+        try { pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
+        catch (error) { console.error('旧版 Codex 内核文件清理失败：', error); }
+      }
+      const preferredExecutable = path.resolve(runtime.executable);
+      const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
+      const launcherRevision = Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0;
+      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, launcherRevision, selectedVersion: runtime.version, source: runtime.source,
+        launcherRestartRequired: launcherRevision !== managedAppServerLauncherRevision,
+        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);
+      const actual = record?.pid ? await this.host.process(record.pid) : null;
+      if (actual && !sameManagedProcess(record, actual)) {
+        throw new Error('Codex 内核进程身份已经变化，未结束任何进程。');
+      }
+      if (!actual && !await this.available()) throw new Error('45839 被未识别进程占用，未结束任何进程。');
+      this.restartStage('stopping');
+      // Resolve the replacement before stopping the current working process.
+      const runtime = await resolveCodexRuntime(this.stateRoot, { refresh: true, environment: this.environment });
+      const desktop = await this.host.prepareKernelRestart?.();
+      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 内核未能重新启动。');
+      const desktopEnvironment = { ...this.environment, CODEX_HOME: runtime.codexHome, CODEX_APP_SERVER_WS_URL: managedAppServerUrl };
+      delete desktopEnvironment.CODEX_APP_SERVER_FORCE_CLI;
+      delete desktopEnvironment.CODEX_APP_TOOLS_PIPE_PATH;
+      await this.host.resumeAfterKernelRestart?.(desktop, desktopEnvironment);
+      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-upload-files.mjs

@@ -0,0 +1,74 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import media from '../shared/code-browser.cjs';
+import { validateInlineImage } from './message-images.mjs';
+import { MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_TOTAL_BYTES } from './file-upload-session.mjs';
+
+const mimeTypes = { pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
+  json: 'application/json', zip: 'application/zip', doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
+
+async function localFile(file, directory) {
+  if (typeof file?.path !== 'string' || typeof file.name !== 'string' || !file.name || /[\r\n\0]/.test(file.name)) {
+    throw new Error('附件信息无效，请重新选择。');
+  }
+  const root = await fs.realpath(directory), resolved = await fs.realpath(file.path);
+  if (path.relative(root, path.dirname(resolved)) !== '') throw new Error('附件必须来自本次工作站上传目录。');
+  const handle = await fs.open(resolved, 'r');
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1 || stat.size > MAX_FILE_BYTES) throw new Error('附件为空或超过 20 MiB。');
+    const bytes = await handle.readFile();
+    if (bytes.length !== stat.size) throw new Error('附件在读取时发生变化，请重新上传。');
+    const mimeType = media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream';
+    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType)) throw new Error('附件类型无效。');
+    return { name: file.name, mimeType, bytes };
+  } finally { await handle.close(); }
+}
+
+export async function readMessageUploads(body, uploadsRoot) {
+  const images = body.images ?? [], originals = body.originalImages ?? [], files = body.files ?? [];
+  if (![images, originals, files].every(Array.isArray) || images.length + originals.length > 4 || files.length + originals.length > MAX_FILE_COUNT) {
+    throw new Error('每条消息最多 4 张图片、4 个文件。');
+  }
+  const uploads = [];
+  let imageBytes = 0, fileBytes = 0;
+  for (const image of images) {
+    let file;
+    if (typeof image === 'string' && image.startsWith('data:')) {
+      validateInlineImage(image);
+      const mimeType = image.slice(5, image.indexOf(';'));
+      file = { name: `image.${mimeType.split('/')[1]}`, mimeType, bytes: Buffer.from(image.slice(image.indexOf(',') + 1), 'base64') };
+    } else {
+      if (typeof image !== 'string' || !/^[a-f0-9]{64}$/.test(image)) throw new Error('图片标识无效。');
+      let extension = 'webp';
+      try { await fs.access(path.join(uploadsRoot, `${image}.webp`)); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; extension = 'png'; }
+      file = await localFile({ path: path.join(uploadsRoot, `${image}.${extension}`), name: `image.${extension}` }, uploadsRoot);
+    }
+    imageBytes += file.bytes.length;
+    if (imageBytes > 8 * 1024 * 1024) throw new Error('压缩图片合计不能超过 8 MiB。');
+    uploads.push(file);
+  }
+  for (const original of originals) {
+    if (typeof original !== 'string' || !/\.(png|jpe?g|webp|gif)$/i.test(original)) throw new Error('原图路径无效。');
+  }
+  for (const file of [...originals.map(value => ({ path: value, name: path.basename(value) })), ...files]) {
+    const uploaded = await localFile(file, path.join(uploadsRoot, 'incoming'));
+    fileBytes += uploaded.bytes.length;
+    if (fileBytes > MAX_TOTAL_BYTES) throw new Error('文件合计不能超过 40 MiB。');
+    uploads.push(uploaded);
+  }
+  for (const file of uploads) {
+    if (/^image\/(?:png|jpeg|webp|gif)$/.test(file.mimeType)) {
+      const metadata = await sharp(file.bytes).metadata();
+      file.width = metadata.width; file.height = metadata.height;
+      if (!file.width || !file.height) throw new Error('无法读取 图片尺寸。');
+    }
+  }
+  if (uploads.filter(file => file.width).length > 4) throw new Error('每条消息最多 4 张图片。');
+  return uploads;
+}

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

@@ -0,0 +1,48 @@
+param(
+    [Parameter(Mandatory=$true)][string]$Executable,
+    [Parameter(Mandatory=$true)][string]$AppServerUrl
+)
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+$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')