@walkhi/code-relax 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/src/file-upload-session.mjs

@@ -0,0 +1,124 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MAX_FILE_BYTES = 20 * 1024 * 1024;
+export const MAX_FILE_COUNT = 4;
+export const MAX_TOTAL_BYTES = 40 * 1024 * 1024;
+export const FILE_CHUNK_BYTES = 256 * 1024;
+
+function validName(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 180 &&
+    value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value) && !/[. ]$/.test(value) &&
+    !/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value);
+}
+
+async function uniqueDestination(directory, name, partial) {
+  const dot = name.lastIndexOf('.');
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const extension = dot > 0 ? name.slice(dot) : '';
+  for (let index = 0; ; index++) {
+    const suffix = index ? ` (${index})` : '';
+    const candidate = index ? `${stem.slice(0, 180 - extension.length - suffix.length)}${suffix}${extension}` : name;
+    if (!candidate || candidate.length > 180) throw new Error('同名文件过多，文件名无法继续编号');
+    const destination = path.join(directory, candidate);
+    try {
+      await fs.link(partial, destination);
+      await fs.unlink(partial);
+      return { name: candidate, path: destination };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+  }
+}
+
+export function createFileUploadSession(root) {
+  let upload;
+  const completed = new Map();
+  let completedBytes = 0;
+  const directory = path.join(root, 'incoming');
+  const clearActive = async () => {
+    const current = upload;
+    upload = undefined;
+    if (!current) return;
+    await current.handle.close().catch(() => {});
+    await fs.unlink(current.partial).catch(() => {});
+  };
+  const clear = async () => {
+    await clearActive();
+    for (const file of completed.values()) await fs.unlink(file.path).catch(() => {});
+    completed.clear(); completedBytes = 0;
+  };
+  return {
+    async receive(message) {
+      if (!message || typeof message !== 'object') throw new Error('无效的文件上传请求');
+      if (message.type === 'cancel') { await clear(); return { type: 'cancelled' }; }
+      if (message.type === 'commit') {
+        if (upload) throw new Error('文件尚未上传完成');
+        completed.clear(); completedBytes = 0;
+        return { type: 'committed' };
+      }
+      if (message.type === 'remove') {
+        if (upload) throw new Error('请等待当前文件上传完成');
+        const file = completed.get(message.id);
+        if (!file) throw new Error('文件上传会话已失效');
+        await fs.unlink(file.path);
+        completed.delete(message.id); completedBytes -= file.size;
+        return { type: 'removed', id: message.id };
+      }
+      if (message.type === 'start') {
+        if (upload) throw new Error('已有文件正在上传');
+        if (!validName(message.name)) throw new Error('文件名无效');
+        if (!Number.isSafeInteger(message.size) || message.size < 1 || message.size > MAX_FILE_BYTES) {
+          throw new Error('单个文件不得超过 20 MiB');
+        }
+        if (completed.size >= MAX_FILE_COUNT || completedBytes + message.size > MAX_TOTAL_BYTES) {
+          throw new Error('每条消息最多 4 个文件，合计不超过 40 MiB');
+        }
+        if (!/^[a-f0-9]{64}$/i.test(message.sha256 || '')) throw new Error('文件校验值无效');
+        const id = crypto.randomUUID();
+        await fs.mkdir(directory, { recursive: true });
+        const partial = path.join(directory, `.upload-${id}`);
+        const handle = await fs.open(partial, 'wx');
+        upload = { id, partial, handle, name: message.name, size: message.size,
+          expected: message.sha256.toLowerCase(), hash: crypto.createHash('sha256'), offset: 0 };
+        return { type: 'started', id, offset: 0, chunkBytes: FILE_CHUNK_BYTES };
+      }
+      const current = upload;
+      if (!current || message.id !== current.id) throw new Error('文件上传会话已失效');
+      if (message.type === 'chunk') {
+        if (!Number.isSafeInteger(message.offset) || message.offset !== current.offset) {
+          return { type: 'offset', id: current.id, offset: current.offset };
+        }
+        if (typeof message.data !== 'string' || message.data.length > Math.ceil(FILE_CHUNK_BYTES / 3) * 4 + 4 ||
+            !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(message.data)) {
+          throw new Error('文件分片格式无效');
+        }
+        const bytes = Buffer.from(message.data, 'base64');
+        if (!bytes.length || bytes.length > FILE_CHUNK_BYTES || current.offset + bytes.length > current.size) {
+          throw new Error('文件分片大小无效');
+        }
+        await current.handle.writeFile(bytes);
+        current.hash.update(bytes);
+        current.offset += bytes.length;
+        return { type: 'offset', id: current.id, offset: current.offset };
+      }
+      if (message.type === 'finish') {
+        if (current.offset !== current.size || current.hash.digest('hex') !== current.expected) {
+          await clear(); throw new Error('文件大小或 SHA-256 校验失败');
+        }
+        await current.handle.sync();
+        await current.handle.close();
+        upload = undefined;
+        let saved;
+        try { saved = await uniqueDestination(directory, current.name, current.partial); }
+        catch (error) { await fs.unlink(current.partial).catch(() => {}); throw error; }
+        const result = { type: 'completed', id: current.id, ...saved, size: current.size };
+        completed.set(current.id, result); completedBytes += current.size;
+        return result;
+      }
+      throw new Error('不支持的文件上传操作');
+    },
+    close: clear,
+  };
+}

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

@@ -1,16 +1,20 @@
 import { EventEmitter } from 'node:events';
 import crypto from 'node:crypto';
-import { WebSocketServer, WebSocket } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
+import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_TOTAL_BYTES } from './file-upload-session.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 }) {
+export function attachLanSocket(server, { token, dispatch, authorizeDevice = () => false, 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 uploadWss = new WebSocketServer({ noServer: true, maxPayload: 512 * 1024, perMessageDeflate: false });
+  const activeUploads = new Set();
+  server.on('upgrade', (request, socket, head) => {
     const origin = request.headers.origin;
-    let allowed = request.url === '/api/socket';
+    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 {
@@ -23,8 +27,44 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       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));
-  });
+    const target = upload ? uploadWss : wss;
+    target.handleUpgrade(request, socket, head, ws => target.emit('connection', ws));
+  });
+  uploadWss.on('connection', ws => {
+    let authenticated = false, identity = '', upload;
+    let pending = Promise.resolve();
+    const authTimer = setTimeout(() => ws.close(1008, 'Authentication required'), 5000);
+    const reply = value => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(value)); };
+    ws.on('error', () => {});
+    ws.on('close', () => {
+      clearTimeout(authTimer);
+      void pending.finally(async () => {
+        await upload?.close();
+        if (identity) activeUploads.delete(identity);
+      });
+    });
+    ws.on('message', (bytes, binary) => {
+      pending = pending.then(async () => {
+        if (binary || bytes.length > 512 * 1024) throw new Error('无效的上传分片');
+        const message = JSON.parse(bytes.toString());
+        if (!authenticated) {
+          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';
+          }
+          if (!identity || activeUploads.has(identity) || activeUploads.size >= 2) throw new Error('上传身份无效或工作站已有上传任务');
+          activeUploads.add(identity); authenticated = true; clearTimeout(authTimer);
+          upload = createFileUploadSession(uploadsRoot);
+          reply({ type: 'ready', maxFileBytes: MAX_FILE_BYTES, maxFileCount: MAX_FILE_COUNT,
+            maxTotalBytes: MAX_TOTAL_BYTES, chunkBytes: FILE_CHUNK_BYTES });
+          return;
+        }
+        reply(await upload.receive(message));
+      }).catch(error => { reply({ type: 'error', error: error.message }); ws.close(1008, 'Upload rejected'); });
+    });
+  });
   wss.on('connection', ws => {
     let authenticated = false, alive = true;
     const active = new Map();
@@ -70,7 +110,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       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);
+      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|turn-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;
       }
@@ -105,5 +145,8 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       catch (error) { reply.json(500, { error: error.message }); }
     });
   });
-  return { close() { for (const ws of wss.clients) ws.terminate(); wss.close(); } };
-}
+  return { close() {
+    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

@@ -5,9 +5,11 @@ 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() {
@@ -30,7 +32,6 @@ 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.restartStatus = null;
@@ -43,7 +44,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 +70,54 @@ 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 内核目录已被移除或缺少 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];
-        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);
+      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, 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,12 +156,16 @@ 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);
@@ -152,6 +179,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());

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;
-}

package/dist/src/onboarding.mjs

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

package/dist/src/platform/README.md

@@ -3,7 +3,7 @@
 当前只实现 Windows Codex：
 
 - `windows/runtime-paths.mjs`：固定服务、用户状态、Codex 数据、附件和长期凭据路径。
-- `windows/service-host.mjs`、`desktop-tools.mjs`：网卡、Desktop 工具管道、共享连接检测和旧状态迁移。
+- `windows/service-host.mjs`：网卡、Bridge 进程环境和旧状态迁移。
 - `windows/desktop-host.mjs`、PowerShell 脚本：普通/共享 Desktop、快捷方式和隐藏控制台启动。
 - `windows/credential-store.mjs/.ps1`：私有中继电脑凭据的 DPAPI 与 ACL。
 

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

@@ -25,6 +25,6 @@ export function startWindowsProcess(executable, args, environment, logs = []) {
       if (!Number.isSafeInteger(pid) || pid <= 0) return reject(new Error('后台启动未返回有效 PID'));
       resolve(pid);
     });
-    helper.stdin.end(JSON.stringify({ executable, args, logs, environment }));
+    helper.stdin.end(JSON.stringify({ brokerExecutable: process.execPath, executable, args, logs, environment }));
   });
 }