@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.41

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

@@ -1,16 +1,28 @@
-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 }) {
+import { EventEmitter } from 'node:events';
+import crypto from 'node:crypto';
+import { WebSocketServer, WebSocket } from 'ws';
+import timelineSync from '../shared/timeline-sync.cjs';
+import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_TOTAL_BYTES } from './file-upload-session.mjs';
+import { FILE_READ_LIMIT } from './file-transfer-range.mjs';
+
+// 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, onDeviceAuthorizationsChanged, onDeviceConnected, uploadsRoot }) {
   // 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';
+  const uploadWss = new WebSocketServer({ noServer: true, maxPayload: 512 * 1024, perMessageDeflate: false });
+  const activeUploads = new Map();
+  const deviceConnections = new Map();
+  const stopWatching = onDeviceAuthorizationsChanged?.(() => {
+    for (const connection of deviceConnections.values()) {
+      if (!authorizeDevice(connection.clientId, connection.credential)) connection.revoke();
+    }
+  });
+  server.on('upgrade', (request, socket, head) => {
+    const origin = request.headers.origin;
+    const upload = request.url === '/api/file-transfer' && Boolean(uploadsRoot);
+    let allowed = request.url === '/api/socket' || upload;
     // Packaged ArkWeb pages have an opaque ("null") origin; device authentication remains required.
     if (origin && origin !== 'null') {
       try {
@@ -21,35 +33,119 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
           (originUrl.host === request.headers.host || (nativeClient && originUrl.hostname === requestUrl.hostname));
       }
       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 (!allowed) { socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n'); return; }
+    const target = upload ? uploadWss : wss;
+    target.handleUpgrade(request, socket, head, ws => target.emit('connection', ws));
+  });
+  uploadWss.on('connection', ws => {
+    let authenticated = false, stopped = false, identity = '', upload, purpose, chunk;
+    let queued = 0;
+    let pending = Promise.resolve();
+    const authTimer = setTimeout(() => ws.close(1008, 'Authentication required'), 5000);
+    const reply = value => { if (!stopped && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(value)); };
+    ws.on('error', () => {});
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      deviceConnections.delete(ws);
+      clearTimeout(authTimer);
+      void pending.finally(async () => {
+        await upload?.close();
+        activeUploads.delete(ws);
+      });
+    };
+    ws.on('close', stop);
+    ws.on('message', (bytes, binary) => {
+      if (stopped || ws.readyState !== WebSocket.OPEN) return;
+      // Three upload chunks may be in flight, each with a header and binary frame.
+      if (++queued > 8) { stop(); ws.close(1013, 'File request queue exceeded'); return; }
+      pending = pending.then(async () => {
+        if (stopped || ws.readyState !== WebSocket.OPEN) return;
+        if (binary) {
+          if (!authenticated || purpose !== 'upload' || !chunk || bytes.length !== chunk.length) throw new Error('无效的文件分片');
+          const current = chunk; chunk = undefined;
+          reply(await upload.receive({ ...current, data: bytes })); return;
+        }
+        if (bytes.length > 16 * 1024 || chunk) throw new Error('无效的文件请求');
+        const message = JSON.parse(bytes.toString());
+        if (!authenticated) {
+          purpose = message.purpose;
+          if (!['upload', 'download'].includes(purpose)) throw new Error('文件通道用途无效');
+          if (message?.type === 'device-auth' && typeof message.clientId === 'string' &&
+              authorizeDevice(message.clientId, message.credential) === true) identity = `device:${message.clientId}`;
+          else if (token && message?.type === 'auth' && typeof message.token === 'string') {
+            const supplied = Buffer.from(message.token), expected = Buffer.from(token || '');
+            if (supplied.length === expected.length && crypto.timingSafeEqual(supplied, expected)) identity = 'local-token';
+          }
+          const same = [...activeUploads.values()].filter(item => item.identity === identity && item.purpose === purpose);
+          const uploads = [...activeUploads.values()].filter(item => item.purpose === 'upload').length;
+          if (!identity || same.length >= (purpose === 'upload' ? 1 : 3) || activeUploads.size >= 8 ||
+              (purpose === 'upload' && uploads >= 2)) throw new Error('文件身份无效或文件任务过多');
+          if (message.type === 'device-auth') deviceConnections.set(ws, {
+            clientId: message.clientId, credential: message.credential,
+            revoke() { stop(); ws.close(4401, 'Device authorization revoked'); },
+          });
+          activeUploads.set(ws, { identity, purpose }); authenticated = true; clearTimeout(authTimer);
+          if (message.type === 'device-auth') onDeviceConnected?.(message.clientId, message);
+          if (purpose === 'upload') upload = createFileUploadSession(uploadsRoot);
+          reply({ type: 'ready', version: 2, purpose, maxDownloadBytes: FILE_READ_LIMIT, maxFileBytes: MAX_FILE_BYTES, maxFileCount: MAX_FILE_COUNT,
+            maxTotalBytes: MAX_TOTAL_BYTES, chunkBytes: FILE_CHUNK_BYTES });
+          return;
+        }
+        if (purpose === 'download') {
+          if (message.type !== 'read' || typeof message.path !== 'string' || message.path.length > 12000 ||
+              !/^\/api\/(?:images\/[a-f0-9]{64}|files\/(?:local|[a-f0-9]{64})|code\/(?:image|binary)|desktop\/frames\/[a-f0-9]{32})(?:\?|$)/.test(message.path) || message.path.includes('#')) throw new Error('无效的文件读取请求');
+          await dispatch({ method: 'GET', url: message.path, headers: {}, socketRequest: true, fileTransfer: true }, {
+            json(status, body) { reply({ type: 'error', status, error: body?.error || '文件读取失败' }); },
+            filePart(metadata, data) {
+              if (stopped || ws.readyState !== WebSocket.OPEN) return;
+              if (!Buffer.isBuffer(data) || data.length > FILE_CHUNK_BYTES || ws.bufferedAmount > 1024 * 1024) throw new Error('文件接收过慢或分片无效');
+              reply({ type: 'part', ...metadata, length: data.length });
+              ws.send(data);
+            },
+          });
+          return;
+        }
+        if (message.type === 'chunk') {
+          if (!Number.isSafeInteger(message.length) || message.length < 1 || message.length > FILE_CHUNK_BYTES) throw new Error('文件分片大小无效');
+          chunk = message; return;
+        }
+        reply(await upload.receive(message));
+      }).catch(error => { reply({ type: 'error', error: error.message }); stop(); ws.close(1008, 'File request rejected'); })
+        .finally(() => { queued--; });
+    });
+  });
+  wss.on('connection', ws => {
+    let authenticated = false, alive = true, stopped = false;
+    const active = new Map();
+    const send = value => {
+      if (stopped || 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.
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      deviceConnections.delete(ws);
+      clearTimeout(authTimer); clearInterval(heartbeat);
+      for (const reply of active.values()) reply.end();
+      active.clear();
+    };
+    ws.on('close', stop);
+    ws.on('message', async (bytes, binary) => {
+      if (stopped || ws.readyState !== WebSocket.OPEN) return;
+      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') {
@@ -62,48 +158,109 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
         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(); } };
-}
+        if (message.type === 'device-auth') onDeviceConnected?.(message.clientId, message);
+        if (message.type === 'device-auth') deviceConnections.set(ws, {
+          clientId: message.clientId, credential: message.credential,
+          revoke() { stop(); ws.close(4401, 'Device authorization revoked'); },
+        });
+        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 === 'response-ack') { active.get(id)?.acknowledge?.(message.batch); return; }
+      if (type === 'cancel') { active.get(id)?.end(); 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|thread-events|turn-events|shared-recovery\/events|threads\/[^/?]+\/(?:events|dots-activity-events))(?:\?|$)/.test(path);
+      // Native recovery, usage, catalog, current chat, and the main Dot's sidebar
+      // share one station connection (including when viewing a delegated task).
+      if (active.size >= 32 || (subscription && [...active.values()].filter(r => r.subscription).length >= 5)) {
+        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', 'PUT', '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();
+      let waiting, batch = 0;
+      const sendPart = (pieces, pageEnd = false) => new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('历史接收确认超时')), 20000);
+        waiting = { resolve, reject, timer, batch: ++batch };
+        send({ type: subscription ? 'event-part' : 'response-part', id, batch, pieces, ...(pageEnd ? { pageEnd: true } : {}) });
+      });
+      const sendTimeline = async (status, body, event) => {
+        if (event) batch = 0;
+        try {
+          for (const pieces of timelineSync.timelineBatches(body)) {
+            if (reply.writableEnded) return;
+            await sendPart(pieces);
+          }
+          if (!reply.writableEnded) {
+            send(event ? { type: 'event', id, event, streamed: true } : { type: 'response', id, status, streamed: true });
+            if (!event) reply.end();
+          }
+        } catch (error) {
+          if (!reply.writableEnded) {
+            send(event ? { type: 'event', id, event: 'bridge-error', data: { error: error.message } }
+              : { type: 'response', id, status: 500, body: { error: error.message } });
+            reply.end();
+          }
+        }
+      };
+      Object.assign(reply, {
+        subscription, headersSent: false, writableEnded: false, destroyed: false,
+        async historyPage(page) {
+          const parts = timelineSync.timelineBatches(page);
+          let part = parts.next();
+          while (!part.done) {
+            if (this.writableEnded) throw new Error('历史读取已取消');
+            const next = parts.next();
+            await sendPart(part.value, next.done);
+            part = next;
+          }
+        },
+        json(status, body) {
+          if (this.writableEnded) return;
+          if (status < 400 && body?.schemaVersion === 1 && Array.isArray(body.turns)) {
+            void sendTimeline(status, body); return;
+          }
+          send({ type: 'response', id, status, body }); this.end();
+        },
+        acknowledge(sequence) {
+          if (!waiting || sequence !== waiting.batch) return;
+          const completed = waiting; waiting = null; clearTimeout(completed.timer);
+          this.emit('progress'); completed.resolve();
+        },
+        startEvents() {
+          if (this.writableEnded) return;
+          this.headersSent = true; send({ type: 'subscribed', id });
+        },
+        event(event, data) {
+          if (this.writableEnded) return;
+          if (event === 'update' && data?.schemaVersion === 1) return sendTimeline(200, data, event);
+          send({ type: 'event', id, event, data });
+        },
+        end() {
+          if (this.writableEnded) return;
+          this.writableEnded = this.destroyed = true; active.delete(id);
+          if (waiting) { clearTimeout(waiting.timer); waiting.reject(new Error('历史读取已取消')); waiting = null; }
+          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() {
+    stopWatching?.();
+    for (const ws of wss.clients) ws.terminate(); wss.close();
+    for (const ws of uploadWss.clients) ws.terminate(); uploadWss.close();
+  } };
+}

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

@@ -1,13 +1,16 @@
 import fs from 'node:fs';
+import { executableKey } from './platform/path-identity.mjs';
 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/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() {
@@ -30,9 +33,9 @@ export class ManagedAppServer extends EventEmitter {
     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.client.diagnosticIdentity = () => ({ kernelPid: this.state.pid ?? null, kernelCreated: this.state.created ?? null });
     this.restartStatus = null;
     this.stopped = true;
     this.restarting = false;
@@ -43,7 +46,11 @@ export class ManagedAppServer extends EventEmitter {
     });
   }
 
-  snapshot() { return { ...this.state, ...(this.restartStatus ? { restart: { ...this.restartStatus } } : {}) }; }
+  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;
@@ -65,36 +72,57 @@ export class ManagedAppServer extends EventEmitter {
     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; }
+      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 内核目录已被移除或缺少配套 code-mode-host：${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];
-        const pid = await this.host.start(info.cli, ['app-server', '--listen', managedAppServerUrl], childEnvironment,
+        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 内核启动后进程身份无法确认。');
-        record = actual = started;
+        actual = started;
+        record = { ...started, launcherRevision: managedAppServerLauncherRevision };
         writeRecord(this.recordPath, record);
       } else if (!readRecord(this.recordPath)) {
-        writeRecord(this.recordPath, actual);
+        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 内核协议初始化未完成。');
-      const preferredExecutable = path.resolve(info.cli);
-      const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
+      if (startedHere) {
+        try { await pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
+        catch (error) { console.error('旧版 Codex 内核文件清理失败：', error); }
+      }
+      const preferredExecutable = path.resolve(runtime.executable);
+      const updatePending = executableKey(actual.executable) !== executableKey(preferredExecutable);
+      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, url: managedAppServerUrl });
+        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));
@@ -133,15 +161,19 @@ export class ManagedAppServer extends EventEmitter {
     const previous = this.state;
     this.publish({ ...previous, state: 'restarting', ready: false, error: null });
     try {
-      const record = readRecord(this.recordPath) || readRecord(this.legacyRecordPath);
+      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.host.stop(actual.pid, actual);
         await this.waitUntilStopped(actual);
       } else if (!await this.available()) {
         throw new Error('45839 被未识别进程占用，未结束任何进程。');
@@ -152,6 +184,10 @@ export class ManagedAppServer extends EventEmitter {
       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());
@@ -201,7 +237,9 @@ export class ManagedAppServer extends EventEmitter {
 
 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;
+  if (!record.executable || !actual.executable || executableKey(record.executable) !== executableKey(actual.executable)) return false;
+  if (Array.isArray(actual.args)) return JSON.stringify(record.args) === JSON.stringify(actual.args)
+    && JSON.stringify(actual.args.slice(1)) === JSON.stringify(['app-server', '--listen', managedAppServerUrl]);
   const command = String(actual.command || '').toLowerCase();
   return command.includes('app-server') && command.includes(managedAppServerUrl);
 }

package/dist/src/message-images.mjs

@@ -1,8 +1,3 @@
-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 ||
@@ -12,16 +7,3 @@ export function validateInlineImage(value) {
   }
   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;
-}