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

package/README.md

@@ -4,13 +4,13 @@ Bridge 让 HarmonyOS 客户端控制 Windows 上的 Codex Desktop。当前要求
 
 ## 安装
 
-计划发布到 npm 后在线安装；当前命令为发布占位，尚不能从 registry 执行：
+公开 beta 已发布到 npm，安装或更新使用：
 
 ```powershell
-npm.cmd install -g @walkhi/code-relax@beta
+npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax
 ```
 
-首次安装或更新前先保存工作，并从 Codex 菜单或 Windows 托盘完全退出 Codex。npm 全局安装会自动执行 `setup` 和 Skill 安装。`setup` 将完整服务部署到 `%LOCALAPPDATA%\Programs\CodexRemote\service`，记录安装所用 Node 的绝对路径，不复制 Node。配置、日志和二维码以 `installation.json.stateRoot` 为准，通常位于 `%LOCALAPPDATA%\CodexRemote`，MSIX 环境可能解析到包缓存目录；附件位于 `%ProgramData%\CodexRemote\attachments`。
+首次安装前先保存工作，并从 Codex 菜单或 Windows 托盘完全退出 Codex。更新无需先停止正在运行的 Bridge；安装器会短暂停止、替换并恢复服务。npm 全局安装会自动执行 `setup` 和 Skill 安装。`setup` 将完整服务部署到 `%LOCALAPPDATA%\Programs\CodexRemote\service`，记录安装所用 Node 的绝对路径，不复制 Node。配置、日志和二维码以 `installation.json.stateRoot` 为准，通常位于 `%LOCALAPPDATA%\CodexRemote`，MSIX 环境可能解析到包缓存目录；附件位于 `%ProgramData%\CodexRemote\attachments`。
 
 `setup` 立即启动 Bridge 和固定 45839 受管 app-server，并启用当前用户登录自启；自启不打开 Codex。受管实例健康后配置当前用户 `CODEX_APP_SERVER_WS_URL`，之后正常启动的 Desktop 自动接入。若安装时 Desktop 仍在运行，不中断现有任务，允许两个 app-server 暂时共存，并在手机提示立即或稍后重启。
 
@@ -64,7 +64,7 @@ relax dev-stop --json
 更新固定服务：
 
 ```powershell
-npm.cmd install -g @walkhi/code-relax@beta
+npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax
 ```
 
 `setup` 先暂存并校验新版本，再短暂停止 Bridge/中继完成切换；原服务此前正在运行时会自动恢复，新版本启动失败则回滚并启动旧版本。无需提前执行 `stop`。Node 路径变化或原 Node 被删除后需重新 setup。升级可能因 Node 可执行文件路径变化而再次触发 Windows 防火墙授权。
@@ -80,4 +80,4 @@ npm uninstall -g @walkhi/code-relax
 
 ## 发布边界
 
-包名为 `@walkhi/code-relax@0.1.0-beta.1`，主 CLI 为 `relax`，并保留 `code-relax` 兼容入口。首次公开 beta 发布前仍需确认 npm scope 所有权、第三方许可、新电脑首次安装、防火墙、升级/卸载和移动端到端验收。详细规则见 [npm 分发](../docs/npm-distribution.md)。
+当前包名为 `@walkhi/code-relax@0.1.0-beta.2`，主 CLI 为 `relax`，并保留 `code-relax` 兼容入口。当前已完成 npm scope 发布和本机 registry 在线安装；本版修复了另一台电脑首次安装时的 Windows broker 交接超时，仍需在原电脑复核。详细规则见 [npm 分发](../docs/npm-distribution.md)。

package/dist/bin/self-relay-server.mjs

@@ -12,6 +12,9 @@ if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Inv
 const stateFile = process.env.RELAY_STATE_FILE;
 if (!stateFile) throw new Error('RELAY_STATE_FILE is required');
 const debugAllowlistFile = process.env.RELAY_DEBUG_ALLOWLIST_FILE || '/etc/codex-relay/debug-allowlist.json';
+const adminStateFile = process.env.RELAY_ADMIN_STATE_FILE || '/var/lib/codex-relay/admin.json';
+const maxRelaySessions = Number(process.env.RELAY_MAX_RELAY_SESSIONS || 8);
+if (!Number.isSafeInteger(maxRelaySessions) || maxRelaySessions < 1 || maxRelaySessions > 256) throw new Error('Invalid RELAY_MAX_RELAY_SESSIONS');
 const debugCommand = process.argv.find(value => ['--debug-list', '--debug-allow', '--debug-deny'].includes(value));
 if (debugCommand) {
   const records = deviceStore(stateFile).entries();
@@ -41,10 +44,10 @@ if (revokeIndex >= 0) {
   store.save({ ...record, status: 'revoked', clientHash: undefined, clientId: undefined, revision: record.revision + 1, updatedAt: new Date().toISOString() });
   console.log('Computer and phone authorization revoked'); process.exit(0);
 }
-const relay = await startSelfRelay({ port, hostKey, stateFile, debugAllowlistFile,
+const relay = await startSelfRelay({ port, hostKey, stateFile, debugAllowlistFile, adminStateFile, maxRelaySessions,
   publicRelayUrl: process.env.RELAY_PUBLIC_URL || '', appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || '',
   log: entry => console.log(JSON.stringify({ time: new Date().toISOString(), ...entry })) });
-console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32,
+console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32, maxRelaySessions,
   maxFrameMiB: 8, encryption: 'TLS must be supplied by reverse proxy; no end-to-end encryption' }));
 await new Promise(resolve => { process.once('SIGTERM', resolve); process.once('SIGINT', resolve); });
 await relay.close();

package/dist/shared/app-server-events.cjs

@@ -2,31 +2,58 @@
   if (typeof module === 'object' && module.exports) module.exports = factory();
   else root.CodexAppServerEvents = factory();
 })(globalThis, function () {
-  function mergeItems(existing, incoming = []) {
-    for (const item of incoming) {
-      const index = existing.findIndex(current => current.id === item.id);
-      if (index < 0) existing.push(item);
-      else existing[index] = { ...existing[index], ...item };
+  function mergeItems(existing, incoming = []) {
+    for (const source of incoming) {
+      const item = compactItem(source);
+      const index = existing.findIndex(current => current.id === item.id);
+      if (index < 0) existing.push(item);
+      else existing[index] = { ...existing[index], ...item };
     }
-    return existing;
-  }
+    return existing;
+  }
+
+  function compactItem(item) {
+    if (!item || typeof item !== 'object') return item;
+    if (item.type === 'commandExecution') {
+      const { aggregatedOutput, output, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'mcpToolCall') {
+      const { result, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'dynamicToolCall') {
+      const { contentItems, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'imageGeneration') {
+      const { result, ...metadata } = item;
+      return metadata;
+    }
+    return item;
+  }
+
+  function compactTurn(turn) {
+    return { ...turn, items: Array.isArray(turn?.items) ? turn.items.map(compactItem) : [] };
+  }
 
   // Both relay and local WebSocket carry these same app-server notifications.
   // Mutate one thread and return only the affected turn for incremental rendering.
   function applyNotification(thread, method, p) {
     if (method === 'thread/status/changed') thread.status = p.status;
     else if (method === 'thread/name/updated') thread.name = p.threadName;
-    else if (!['turn/started', 'turn/completed', 'item/started', 'item/completed', 'item/agentMessage/delta',
-      'item/reasoning/summaryTextDelta', 'item/reasoning/summaryPartAdded', 'item/commandExecution/outputDelta'].includes(method)) return null;
+    else if (!['turn/started', 'turn/completed', 'item/started', 'item/completed', 'item/agentMessage/delta',
+      'item/reasoning/summaryTextDelta', 'item/reasoning/summaryPartAdded'].includes(method)) return null;
     thread.turns ||= [];
     let turn = thread.turns.find(t => t.id === (p.turnId || p.turn?.id));
-    if (!turn && p.turnId && p.item) { turn = { id: p.turnId, status: 'inProgress', items: [] }; thread.turns.push(turn); }
-    if (p.turn) {
-      if (!turn) { turn = { ...p.turn, items: p.turn.items || [] }; thread.turns.push(turn); }
-      else Object.assign(turn, { ...p.turn, items: mergeItems(turn.items || [], p.turn.items) });
-      thread.status = method === 'turn/started' ? 'active' : method === 'turn/completed' ? 'idle' : thread.status;
-    }
-    if (p.item && turn) mergeItems(turn.items, [p.item]);
+    if (!turn && p.turnId && p.item) { turn = { id: p.turnId, status: 'inProgress', items: [] }; thread.turns.push(turn); }
+    if (p.turn) {
+      const incomingTurn = compactTurn(p.turn);
+      if (!turn) { turn = incomingTurn; thread.turns.push(turn); }
+      else Object.assign(turn, { ...incomingTurn, items: mergeItems(turn.items || [], incomingTurn.items) });
+      thread.status = method === 'turn/started' ? 'active' : method === 'turn/completed' ? 'idle' : thread.status;
+    }
+    if (p.item && turn) mergeItems(turn.items, [compactItem(p.item)]);
     const item = turn?.items.find(item => item.id === p.itemId);
     if (item) {
       if (method === 'item/agentMessage/delta') item.text = (item.text || '') + p.delta;
@@ -34,8 +61,7 @@
         item.summary ||= []; item.summary[p.summaryIndex] = (item.summary[p.summaryIndex] || '') + p.delta;
       }
       if (method === 'item/reasoning/summaryPartAdded') { item.summary ||= []; item.summary[p.summaryIndex] ??= ''; }
-      if (method === 'item/commandExecution/outputDelta') item.aggregatedOutput = (item.aggregatedOutput || '') + p.delta;
-    }
+    }
     return turn || (['thread/status/changed', 'thread/name/updated'].includes(method) ? thread.turns.at(-1) : null);
   }
   function mergeAvailable(previous, incoming) {
@@ -261,6 +287,6 @@
     }
     return readQueue(request, threadId);
   }
-  return { createThread, readQueue, addQueue, changeQueue, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, projectlessThreadTarget, updateSettings,
+  return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, projectlessThreadTarget, updateSettings,
     permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
 });

package/dist/shared/p2p-data-channel.cjs

@@ -0,0 +1,50 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxP2pDataFramer = factory();
+})(globalThis, () => {
+  const CHUNK_CHARS = 12000;
+  const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+  const MAX_PARTS = 1024;
+  const byteLength = value => new TextEncoder().encode(value).length;
+
+  return class {
+    constructor() { this.inbound = undefined; }
+    create(payload, id) {
+      if (typeof payload !== 'string' || !/^[a-f0-9]{32}-[0-9]{1,10}$/.test(id)) throw new Error('Invalid P2P payload');
+      const bytes = byteLength(payload);
+      if (bytes > MAX_MESSAGE_BYTES) throw new Error('Code Relax 直连消息超过 8 MiB');
+      const total = Math.max(1, Math.ceil(payload.length / CHUNK_CHARS));
+      if (total > MAX_PARTS) throw new Error('Code Relax 直连消息分片过多');
+      return { id, payload, bytes, index: 0, total };
+    }
+    frame(item) {
+      if (!item || item.index >= item.total) return undefined;
+      const start = item.index * CHUNK_CHARS;
+      return JSON.stringify({ type: 'data', id: item.id, index: item.index, total: item.total,
+        payload: item.payload.slice(start, start + CHUNK_CHARS) });
+    }
+    commit(item) { item.index++; return item.index >= item.total; }
+    accept(message) {
+      if (!message || message.type !== 'data') return { handled: false };
+      if (!/^[a-f0-9]{32}-[0-9]{1,10}$/.test(message.id || '') || !Number.isSafeInteger(message.index) ||
+          !Number.isSafeInteger(message.total) || message.total < 1 || message.total > MAX_PARTS ||
+          message.index < 0 || message.index >= message.total || typeof message.payload !== 'string' ||
+          message.payload.length > CHUNK_CHARS) throw new Error('Invalid P2P data frame');
+      if (!this.inbound) {
+        if (message.index !== 0) throw new Error('Invalid P2P data order');
+        this.inbound = { id: message.id, total: message.total, next: 0, bytes: 0, parts: [] };
+      }
+      const current = this.inbound;
+      if (current.id !== message.id || current.total !== message.total || current.next !== message.index) {
+        throw new Error('Invalid P2P data order');
+      }
+      current.bytes += byteLength(message.payload);
+      if (current.bytes > MAX_MESSAGE_BYTES) throw new Error('P2P data message too large');
+      current.parts.push(message.payload); current.next++;
+      if (current.next !== current.total) return { handled: true, complete: false };
+      this.inbound = undefined;
+      return { handled: true, complete: true, payload: current.parts.join('') };
+    }
+    reset() { this.inbound = undefined; }
+  };
+});

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

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
 import path from 'node:path';
-import { AppServerRpcError } from './app-server-client.mjs';
+import events from '../shared/app-server-events.cjs';
 
 const STORE_SCHEMA_VERSION = 1;
 
@@ -45,7 +45,7 @@ export class AppServerTaskStore {
   }
 
   list() {
-    return [...this.records.values()].sort((left, right) => Number(right.updatedAt) - Number(left.updatedAt));
+    return [...this.records.values()].sort((left, right) => taskRecency(right) - taskRecency(left));
   }
 
   upsert(task) {
@@ -126,6 +126,7 @@ export class AppServerTaskTransport extends EventEmitter {
       projectId: projectId || null,
       createdAt: Number(started.thread.createdAt) || now,
       updatedAt: Number(started.thread.updatedAt) || now,
+      recencyAt: Number(started.thread.recencyAt) || Number(started.thread.updatedAt) || now,
       status: threadStatus(started.thread.status),
       activeFlags: threadActiveFlags(started.thread.status),
       model: model || started.model || started.thread.model || '',
@@ -142,7 +143,7 @@ export class AppServerTaskTransport extends EventEmitter {
     if (model) turnParams.model = model;
     if (effort) turnParams.effort = effort;
     const turn = await this.client.request('turn/start', turnParams, 60_000);
-    this.store.upsert({ ...record, status: 'active', activeFlags: [], updatedAt: Math.floor(Date.now() / 1000) });
+    this.store.upsert({ ...record, status: 'active', activeFlags: [] });
     return { thread: started.thread, turn: turn.turn, record: this.store.get(record.id) };
   }
 
@@ -163,6 +164,7 @@ export class AppServerTaskTransport extends EventEmitter {
         title: thread.name || record.title,
         cwd: thread.cwd || record.cwd,
         updatedAt: Number(thread.updatedAt) || record.updatedAt,
+        recencyAt: Number(thread.recencyAt) || record.recencyAt || record.updatedAt,
         status: threadStatus(thread.status),
         activeFlags: threadActiveFlags(thread.status),
         model: thread.model || record.model,
@@ -179,24 +181,17 @@ export class AppServerTaskTransport extends EventEmitter {
   async readTask(threadId, { includeTurns = true, turnLimit = 10 } = {}) {
     this.record(threadId);
     await this.client.start();
-    try {
-      const result = await this.readInitializedThread({ threadId, includeTurns });
-      if (includeTurns && Array.isArray(result.thread?.turns)) {
-        result.thread.turns = result.thread.turns.slice(-turnLimit);
-      }
-      return result.thread;
-    } catch (error) {
-      if (!includeTurns || !(error instanceof AppServerRpcError) || error.code !== -32601) throw error;
-      const [threadResult, turnsResult] = await Promise.all([
-        this.readInitializedThread({ threadId, includeTurns: false }),
-        this.client.request('thread/turns/list', {
-          threadId,
-          limit: turnLimit,
-          sortDirection: 'desc',
-        }, 30_000),
-      ]);
-      return { ...threadResult.thread, turns: [...(turnsResult.data || [])].reverse() };
-    }
+    if (!includeTurns) return (await this.readInitializedThread({ threadId, includeTurns: false })).thread;
+    const [threadResult, turnsResult] = await Promise.all([
+      this.readInitializedThread({ threadId, includeTurns: false }),
+      this.client.request('thread/turns/list', {
+        threadId,
+        limit: turnLimit,
+        sortDirection: 'desc',
+        itemsView: 'full',
+      }, 30_000),
+    ]);
+    return { ...threadResult.thread, turns: [...(turnsResult.data || [])].reverse().map(events.compactTurn) };
   }
 
   async readInitializedThread(params) {
@@ -225,7 +220,6 @@ export class AppServerTaskTransport extends EventEmitter {
       ...record,
       status: 'active',
       activeFlags: [],
-      updatedAt: Math.floor(Date.now() / 1000),
       model: model || record.model,
       effort: effort || record.effort,
     });
@@ -245,11 +239,13 @@ export class AppServerTaskTransport extends EventEmitter {
       throw error;
     }
     if (result.thread.id !== thread.id) throw new Error('恢复后的聊天 ID 不一致。');
-    const now = Math.floor(Date.now() / 1000);
     const record = this.store.upsert({
       id: thread.id, title: thread.title || result.thread.name || thread.id,
       cwd: result.thread.cwd, projectId: thread.projectId || null,
-      createdAt: result.thread.createdAt || now, updatedAt: now,
+      createdAt: Number(result.thread.createdAt) || Number(thread.createdAt) || 0,
+      updatedAt: Number(result.thread.updatedAt) || Number(thread.updatedAt) || 0,
+      recencyAt: Number(result.thread.recencyAt) || Number(thread.recencyAt)
+        || Number(result.thread.updatedAt) || Number(thread.updatedAt) || 0,
       status: threadStatus(result.thread.status), activeFlags: threadActiveFlags(result.thread.status),
       origin: 'desktop', transport: 'app-server',
     });
@@ -288,7 +284,7 @@ export class AppServerTaskTransport extends EventEmitter {
     if (!threadId || !this.owns(threadId)) return;
     const current = this.store.get(threadId);
     if (current && ['thread/status/changed', 'turn/started', 'turn/completed', 'thread/name/updated'].includes(record.method)) {
-      const next = { ...current, updatedAt: Math.floor(Date.now() / 1000) };
+      const next = { ...current };
       if (record.method === 'thread/status/changed') {
         next.status = threadStatus(record.params?.status);
         next.activeFlags = threadActiveFlags(record.params?.status);
@@ -297,6 +293,7 @@ export class AppServerTaskTransport extends EventEmitter {
       if (record.method === 'turn/completed') { next.status = 'idle'; next.activeFlags = []; }
       if (record.method === 'thread/name/updated' && record.params?.threadName) next.title = record.params.threadName;
       this.store.upsert(next);
+      this.hydratedGeneration = 0;
     }
     this.emit('thread-event', { threadId, record });
   }
@@ -311,6 +308,7 @@ export function summaryFromRecord(record, status = record.status || 'unknown') {
     cwd: record.cwd,
     projectId: record.projectId,
     updatedAt: record.updatedAt,
+    recencyAt: record.recencyAt ?? record.updatedAt,
     status,
     activeFlags: Array.isArray(record.activeFlags) ? record.activeFlags : [],
     transport: 'app-server',
@@ -324,6 +322,7 @@ function summaryFromThread(thread, record) {
     title: thread.name || record.title || thread.preview || thread.id,
     cwd: thread.cwd || record.cwd,
     updatedAt: Number(thread.updatedAt) || record.updatedAt,
+    recencyAt: Number(thread.recencyAt) || record.recencyAt || record.updatedAt,
   };
 }
 
@@ -333,6 +332,10 @@ function validTaskRecord(task) {
     && Number.isFinite(Number(task.createdAt)) && Number.isFinite(Number(task.updatedAt));
 }
 
+function taskRecency(task) {
+  return Number(task?.recencyAt ?? task?.updatedAt) || 0;
+}
+
 function delay(milliseconds) {
   return new Promise(resolve => setTimeout(resolve, milliseconds));
 }

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

@@ -13,8 +13,14 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
     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; }
+      try {
+        const originUrl = new URL(origin);
+        const requestUrl = new URL(`http://${request.headers.host}`);
+        const nativeClient = request.headers['x-code-relax-native'] === '1';
+        allowed &&= ['http:', 'https:'].includes(originUrl.protocol) &&
+          (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));

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

@@ -48,8 +48,8 @@ public static class IsolatedProcess {
         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;
+    public static int Start(string executable,string[] arguments,string stdout,string stderr,string[] environment) {
+        IntPtr input=IntPtr.Zero,output=IntPtr.Zero,error=IntPtr.Zero,list=IntPtr.Zero,handles=IntPtr.Zero,environmentBlock=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);
@@ -63,12 +63,16 @@ public static class IsolatedProcess {
             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));
+            Array.Sort(environment,StringComparer.OrdinalIgnoreCase);
+            var environmentBytes=Encoding.Unicode.GetBytes(String.Join("\0",environment)+"\0\0");
+            environmentBlock=Marshal.AllocHGlobal(environmentBytes.Length); Marshal.Copy(environmentBytes,0,environmentBlock,environmentBytes.Length);
             ProcessInfo info;
-            if(!CreateProcessW(executable,command,IntPtr.Zero,IntPtr.Zero,true,0x80010,IntPtr.Zero,null,ref startup,out info)) throw new Win32Exception(Marshal.GetLastWin32Error());
+            if(!CreateProcessW(executable,command,IntPtr.Zero,IntPtr.Zero,true,0x80410,environmentBlock,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(environmentBlock!=IntPtr.Zero) Marshal.FreeHGlobal(environmentBlock);
             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

@@ -5,9 +5,14 @@ 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 helperEnvironment = {};
+    for (const name of ['SystemRoot', 'windir', 'LOCALAPPDATA', 'USERPROFILE', 'TEMP', 'TMP', 'PSModulePath']) {
+      const key = Object.keys(process.env).find(item => item.toLowerCase() === name.toLowerCase());
+      if (key) helperEnvironment[key] = process.env[key];
+    }
     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'],
+      windowsHide: true, env: helperEnvironment, stdio: ['pipe', 'pipe', 'pipe'],
     });
     let output = '', error = '';
     helper.stdout.setEncoding('utf8').on('data', chunk => { output += chunk; });
@@ -20,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 }));
+    helper.stdin.end(JSON.stringify({ executable, args, logs, environment }));
   });
 }

package/dist/src/platform/windows/launch-worker.ps1

@@ -1,13 +1,20 @@
+param(
+    [Parameter(Mandatory=$true)][string]$RequestPath,
+    [Parameter(Mandatory=$true)][string]$ReadyPath,
+    [Parameter(Mandatory=$true)][string]$Instance
+)
 $ErrorActionPreference = 'Stop'
-$spec = $env:CODEX_REMOTE_PROCESS_SPEC | ConvertFrom-Json
-Remove-Item Env:CODEX_REMOTE_PROCESS_SPEC
-$result = @{instance=$spec.instance; brokerPid=$PID}
+$result = @{instance=$Instance; brokerPid=$PID}
 try {
+    $spec = Get-Content -LiteralPath $RequestPath -Raw -Encoding UTF8 | ConvertFrom-Json
+    if ($spec.instance -ne $Instance) { throw 'Windows process broker request identity mismatch.' }
+    Remove-Item -LiteralPath $RequestPath -Force
     Add-Type -Path (Join-Path $PSScriptRoot 'IsolatedProcess.cs')
     $stdout = if ($spec.logs.Count -gt 0) { [string]$spec.logs[0] } else { 'NUL' }
     $stderr = if ($spec.logs.Count -gt 1) { [string]$spec.logs[1] } else { 'NUL' }
-    $result.pid = [IsolatedProcess]::Start([string]$spec.executable, [string[]]$spec.args, $stdout, $stderr)
+    $environment = @($spec.environment.PSObject.Properties | ForEach-Object { $_.Name + '=' + [string]$_.Value })
+    $result.pid = [IsolatedProcess]::Start([string]$spec.executable, [string[]]$spec.args, $stdout, $stderr, [string[]]$environment)
 } catch { $result.error = $_.Exception.Message }
-$temporary = $spec.ready + '.tmp'
+$temporary = $ReadyPath + '.tmp'
 [IO.File]::WriteAllText($temporary, ($result | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false)))
-[IO.File]::Move($temporary, $spec.ready)
+[IO.File]::Move($temporary, $ReadyPath)

package/dist/src/platform/windows/start-hidden-console.ps1

@@ -10,22 +10,24 @@ try {
     Add-Type -Path (Join-Path $PSScriptRoot 'IsolatedProcess.cs')
     $launchRoot = [IsolatedProcess]::ResolvePath($launchRoot)
     $ready = Join-Path $launchRoot ($instance + '.json')
+    $request = Join-Path $launchRoot ($instance + '.request.json')
     $spec | Add-Member -NotePropertyName instance -NotePropertyValue $instance
-    $spec | Add-Member -NotePropertyName ready -NotePropertyValue $ready
-    $environment = @(Get-ChildItem Env: | Where-Object { $_.Name -ne 'CODEX_REMOTE_PROCESS_SPEC' } | ForEach-Object { $_.Name + '=' + $_.Value })
-    $environment += 'CODEX_REMOTE_PROCESS_SPEC=' + ($spec | ConvertTo-Json -Compress -Depth 10)
+    $requestTemporary = $request + '.tmp'
+    [IO.File]::WriteAllText($requestTemporary, ($spec | ConvertTo-Json -Compress -Depth 10), (New-Object Text.UTF8Encoding($false)))
+    [IO.File]::Move($requestTemporary, $request)
+    $environment = @(Get-ChildItem Env: | ForEach-Object { $_.Name + '=' + $_.Value })
     $startup = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{
         ShowWindow=[uint16]0; CreateFlags=[uint32]0x1000010; EnvironmentVariables=[string[]]$environment
     }
     $powershell = Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
-    $command = '"' + $powershell + '" -NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File "' + (Join-Path $PSScriptRoot 'launch-worker.ps1') + '"'
+    $command = '"' + $powershell + '" -NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File "' + (Join-Path $PSScriptRoot 'launch-worker.ps1') + '" -RequestPath "' + $request + '" -ReadyPath "' + $ready + '" -Instance "' + $instance + '"'
     $broker = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{
         CommandLine=$command; CurrentDirectory=$env:USERPROFILE; ProcessStartupInformation=$startup
     }
     if ($broker.ReturnValue -ne 0) { throw ('Windows process broker failed: ' + $broker.ReturnValue) }
-    $deadline = [DateTime]::UtcNow.AddSeconds(20)
+    $deadline = [DateTime]::UtcNow.AddSeconds(30)
     while (-not (Test-Path -LiteralPath $ready)) {
-        if ([DateTime]::UtcNow -gt $deadline) { throw 'Windows process broker handoff timed out.' }
+        if ([DateTime]::UtcNow -gt $deadline) { throw ('Windows process broker handoff timed out (broker PID ' + $broker.ProcessId + ').') }
         Start-Sleep -Milliseconds 50
     }
     $result = Get-Content -LiteralPath $ready -Raw -Encoding UTF8 | ConvertFrom-Json
@@ -36,4 +38,7 @@ try {
 } catch {
     [Console]::Error.WriteLine($_.Exception.Message)
     exit 1
+} finally {
+    if ($request -and (Test-Path -LiteralPath $request)) { Remove-Item -LiteralPath $request -Force }
+    if ($requestTemporary -and (Test-Path -LiteralPath $requestTemporary)) { Remove-Item -LiteralPath $requestTemporary -Force }
 }

package/dist/src/self-relay/admin-state.mjs

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export function relayAdminState(file, initialMaxRelaySessions) {
+  let value = { version: 1, maxRelaySessions: initialMaxRelaySessions, announcement: null };
+  if (file && fs.existsSync(file)) value = validate(JSON.parse(fs.readFileSync(file, 'utf8')));
+
+  function save(next) {
+    value = validate(next);
+    if (!file) return value;
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    let descriptor;
+    try {
+      descriptor = fs.openSync(temporary, 'wx', 0o600);
+      fs.writeFileSync(descriptor, JSON.stringify(value));
+      fs.fsyncSync(descriptor); fs.closeSync(descriptor); descriptor = undefined;
+      fs.renameSync(temporary, file);
+      if (process.platform !== 'win32') {
+        const directory = fs.openSync(path.dirname(file), 'r');
+        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
+      }
+    } finally {
+      if (descriptor !== undefined) fs.closeSync(descriptor);
+      fs.rmSync(temporary, { force: true });
+    }
+    return value;
+  }
+
+  return {
+    read: () => structuredClone(value),
+    setMaxRelaySessions(maxRelaySessions) { return save({ ...value, maxRelaySessions }); },
+    publish(title, message) {
+      return save({ ...value, announcement: { id: randomUUID(), title: clean(title, 80), message: clean(message, 2000),
+        publishedAt: new Date().toISOString() } });
+    },
+    withdraw() { return save({ ...value, announcement: null }); },
+  };
+}
+
+function validate(source) {
+  if (!source || source.version !== 1 || !Number.isSafeInteger(source.maxRelaySessions) ||
+      source.maxRelaySessions < 1 || source.maxRelaySessions > 256) throw new Error('Invalid relay admin state');
+  let announcement = null;
+  if (source.announcement !== null && source.announcement !== undefined) {
+    const item = source.announcement;
+    if (!item || !/^[\w-]{16,128}$/.test(item.id) || !Number.isFinite(Date.parse(item.publishedAt))) {
+      throw new Error('Invalid relay announcement');
+    }
+    announcement = { id: item.id, title: clean(item.title, 80), message: clean(item.message, 2000), publishedAt: item.publishedAt };
+  }
+  return { version: 1, maxRelaySessions: source.maxRelaySessions, announcement };
+}
+
+function clean(value, limit) {
+  if (typeof value !== 'string' || !value.trim() || value.trim().length > limit || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
+    throw new Error('Invalid announcement text');
+  }
+  return value.trim();
+}

package/dist/src/self-relay/client.mjs

@@ -27,6 +27,7 @@ export function connectRelayClient({ relayUrl, room, code, credential, clientId,
         else if (message.type === 'lan-candidates') events.emit('lan-candidates', message.candidates);
         else if (message.type === 'official-computer') events.emit('official-computer', message.computer);
         else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
+        else if (message.type === 'announcement') events.emit('announcement', message.announcement);
         else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
         else if (message.type === 'data') {
           const body = decode(message.payload, false), request = pending.get(body.id);
@@ -50,6 +51,7 @@ export function connectRelayClient({ relayUrl, room, code, credential, clientId,
       });
     },
     send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
+    routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
     recordOfficialComputer(computer) {
       if (!connected || !observe) throw new Error('Metadata channel not ready');
       return send(socket, { type: 'official-computer', ...computer });