@walkhi/code-relax 0.1.0-beta.8 → 0.1.0-beta.81

package/dist/shared/timeline-sync.cjs

@@ -1,67 +1,173 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexTimelineSync = factory();
-})(globalThis, function () {
-  const equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-  function changedFields(previous, current, ignored) {
-    const set = {}, append = {}, unset = [];
-    for (const key of new Set([...Object.keys(previous || {}), ...Object.keys(current || {})])) {
-      if (ignored.has(key) || equal(previous?.[key], current?.[key])) continue;
-      if (!Object.hasOwn(current, key)) { unset.push(key); continue; }
-      const before = previous?.[key], after = current[key];
-      if (typeof before === 'string' && typeof after === 'string' && after.startsWith(before)) append[key] = after.slice(before.length);
-      else set[key] = after;
-    }
-    return { set, append, unset };
-  }
-  const nonempty = changes => Object.keys(changes.set).length || Object.keys(changes.append).length || changes.unset.length;
-  function diffTurn(previous, current) {
-    if (!previous || !current || previous.id !== current.id) return null;
-    const before = Array.isArray(previous.entries) ? previous.entries : [];
-    const after = Array.isArray(current.entries) ? current.entries : [];
-    if (after.length < before.length) return null;
-    const entries = [];
-    for (let index = 0; index < before.length; index++) {
-      if (before[index]?.id !== after[index]?.id || before[index]?.type !== after[index]?.type ||
-          before[index]?.role !== after[index]?.role || before[index]?.kind !== after[index]?.kind) return null;
-      const changes = changedFields(before[index], after[index], new Set(['id', 'type', 'role', 'kind']));
-      if (nonempty(changes)) entries.push({ id: after[index].id, index, ...changes });
-    }
-    const turn = changedFields(previous, current, new Set(['id', 'entries']));
-    const appended = after.slice(before.length);
-    return { id: current.id, ...turn, entries, appended };
-  }
-  function applyChanges(target, changes) {
-    const result = { ...target, ...(changes.set || {}) };
-    for (const key of changes.unset || []) delete result[key];
-    for (const [key, suffix] of Object.entries(changes.append || {})) {
-      if (typeof result[key] !== 'string' || typeof suffix !== 'string') throw new Error('增量字段类型不匹配');
-      result[key] += suffix;
-    }
-    return result;
-  }
-  function applyTurnPatch(turn, patch) {
-    if (!turn || turn.id !== patch?.id) throw new Error('增量轮次不存在');
-    const next = applyChanges(turn, patch), entries = (turn.entries || []).map(entry => ({ ...entry }));
-    for (const entryPatch of patch.entries || []) {
-      const entry = entries[entryPatch.index];
-      if (!entry || entry.id !== entryPatch.id) throw new Error('增量条目边界不匹配');
-      entries[entryPatch.index] = applyChanges(entry, entryPatch);
-    }
-    for (const entry of patch.appended || []) {
-      if (entries.some(existing => existing.id === entry.id)) throw new Error('增量条目重复');
-      entries.push(entry);
-    }
-    next.entries = entries; return next;
-  }
-  function acceptSyncUpdate(current, incoming) {
-    if (incoming.reset) return { reset: true, next: incoming };
-    const valid = current && incoming.id === current.id && incoming.epoch === current.epoch &&
-      Number.isSafeInteger(incoming.fromSeq) && incoming.fromSeq >= 1 &&
-      Number.isSafeInteger(incoming.toSeq) && incoming.toSeq >= incoming.fromSeq;
-    if (!valid || incoming.fromSeq > current.seq + 1) throw new Error('实时更新序号不连续');
-    if (incoming.toSeq <= current.seq) return { duplicate: true, next: current };
-    return { next: { ...current, seq: incoming.toSeq } };
-  }
-  return { diffTurn, applyTurnPatch, acceptSyncUpdate };
-});
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexTimelineSync = factory();
+})(globalThis, function () {
+  const equal = (left, right) => left === right || JSON.stringify(left) === JSON.stringify(right);
+  function changedFields(previous, current, ignored) {
+    const set = {}, append = {}, unset = [];
+    for (const key of new Set([...Object.keys(previous || {}), ...Object.keys(current || {})])) {
+      if (ignored.has(key) || equal(previous?.[key], current?.[key])) continue;
+      if (!Object.hasOwn(current, key)) { unset.push(key); continue; }
+      const before = previous?.[key], after = current[key];
+      if (typeof before === 'string' && typeof after === 'string' && after.startsWith(before)) append[key] = after.slice(before.length);
+      else set[key] = after;
+    }
+    return { set, append, unset };
+  }
+  const nonempty = changes => Object.keys(changes.set).length || Object.keys(changes.append).length || changes.unset.length;
+  // An ordered history range owns the order of its shared IDs. Keep entries
+  // outside that range at their existing shared anchors, never by timestamps.
+  function mergeOrderedEntries(existing, incoming, merge = (_previous, next) => next, incomingIsOlder = false) {
+    const incomingIds = new Set(incoming.map(entry => entry.id));
+    const existingById = new Map(existing.map(entry => [entry.id, entry]));
+    const before = new Map();
+    let pending = [], lastShared;
+    for (const entry of existing) {
+      if (incomingIds.has(entry.id)) {
+        before.set(entry.id, pending); pending = []; lastShared = entry.id;
+      } else pending.push(entry);
+    }
+    if (lastShared === undefined) return incomingIsOlder ? [...incoming, ...existing] : [...existing, ...incoming];
+    return incoming.flatMap(entry => [ ...(before.get(entry.id) || []),
+      existingById.has(entry.id) ? merge(existingById.get(entry.id), entry) : entry,
+      ...(entry.id === lastShared ? pending : []) ]);
+  }
+  function diffTurn(previous, current) {
+    if (!previous || !current || previous.id !== current.id) return null;
+    const before = Array.isArray(previous.entries) ? previous.entries : [];
+    const after = Array.isArray(current.entries) ? current.entries : [];
+    if (after.length < before.length) return null;
+    const entries = [];
+    for (let index = 0; index < before.length; index++) {
+      if (before[index]?.id !== after[index]?.id || before[index]?.type !== after[index]?.type ||
+          before[index]?.role !== after[index]?.role || before[index]?.kind !== after[index]?.kind) return null;
+      const changes = changedFields(before[index], after[index], new Set(['id', 'type', 'role', 'kind']));
+      if (nonempty(changes)) entries.push({ id: after[index].id, index, ...changes });
+    }
+    const turn = changedFields(previous, current, new Set(['id', 'entries']));
+    const appended = after.slice(before.length);
+    return { id: current.id, ...turn, entries, appended };
+  }
+  function applyChanges(target, changes) {
+    const result = { ...target, ...(changes.set || {}) };
+    for (const key of changes.unset || []) delete result[key];
+    for (const [key, suffix] of Object.entries(changes.append || {})) {
+      if (typeof result[key] !== 'string' || typeof suffix !== 'string') throw new Error('增量字段类型不匹配');
+      result[key] += suffix;
+    }
+    return result;
+  }
+  function applyTurnPatch(turn, patch) {
+    if (!turn || turn.id !== patch?.id) throw new Error('增量轮次不存在');
+    const next = applyChanges(turn, patch), entries = [...(turn.entries || [])];
+    for (const entryPatch of patch.entries || []) {
+      const index = entries.findIndex(entry => entry.id === entryPatch.id);
+      const entry = entries[index];
+      if (!entry || entry.id !== entryPatch.id) throw new Error('增量条目边界不匹配');
+      entries[index] = applyChanges(entry, entryPatch);
+    }
+    for (const entry of patch.appended || []) {
+      if (entries.some(existing => existing.id === entry.id)) throw new Error('增量条目重复');
+      entries.push(entry);
+    }
+    if (turn.itemPage && next.itemPage) next.itemPage = { ...next.itemPage,
+      olderCursor: turn.itemPage.olderCursor, hasLoadedOldest: turn.itemPage.hasLoadedOldest,
+      oldestItemId: turn.itemPage.oldestItemId };
+    next.entries = entries; return next;
+  }
+  function acceptSyncUpdate(current, incoming) {
+    if (incoming.reset) return { reset: true, next: incoming };
+    const valid = current && incoming.id === current.id && incoming.epoch === current.epoch &&
+      Number.isSafeInteger(incoming.fromSeq) && incoming.fromSeq >= 1 &&
+      Number.isSafeInteger(incoming.toSeq) && incoming.toSeq >= incoming.fromSeq;
+    if (!valid || incoming.fromSeq > current.seq + 1) throw new Error('实时更新序号不连续');
+    if (incoming.toSeq <= current.seq) return { duplicate: true, next: current };
+    return { next: { ...current, seq: incoming.toSeq } };
+  }
+  // A batch is acknowledged after consumption. Only an individual record is
+  // reassembled; the timeline itself is never serialized into one large string.
+  function* timelineBatches(timeline) {
+    function* entryRecords(value, kind, textField = '') {
+      const text = textField ? value[textField]?.text : value.text;
+      if (typeof text !== 'string' || text.length <= 4096) { yield { kind, value }; return; }
+      const metadata = textField ? { ...value, [textField]: { ...value[textField], text: '' } } : { ...value, text: '' };
+      yield { kind: 'entry-start', value: metadata, target: kind, textField };
+      for (let offset = 0; offset < text.length; offset += 4096) yield { kind: 'entry-text', value: text.slice(offset, offset + 4096) };
+      yield { kind: 'entry-end' };
+    }
+    function* records() {
+      const { turns, turnPatches, ...metadata } = timeline;
+      yield { kind: 'timeline', value: metadata };
+      for (const turn of turns) {
+        const { entries, ...metadata } = turn;
+        yield { kind: 'turn', value: metadata };
+        for (const entry of entries || []) yield* entryRecords(entry, 'entry');
+      }
+      for (const patch of turnPatches || []) {
+        const { entries, appended, ...metadata } = patch;
+        yield { kind: 'patch', value: metadata };
+        for (const entry of entries || []) yield* entryRecords(entry, 'patch-entry', entry.append?.text ? 'append' : 'set');
+        for (const entry of appended || []) yield* entryRecords(entry, 'patch-appended');
+      }
+    }
+    const encoder = new TextEncoder();
+    let batch = [], bytes = 0;
+    for (const record of records()) {
+      const json = JSON.stringify(record);
+      for (let offset = 0; offset < json.length; offset += 4096) {
+        const piece = { text: json.slice(offset, offset + 4096), end: offset + 4096 >= json.length };
+        const size = encoder.encode(JSON.stringify(piece)).length;
+        if (batch.length && bytes + size > 48 * 1024) { yield batch; batch = []; bytes = 0; }
+        batch.push(piece); bytes += size;
+      }
+    }
+    if (batch.length) yield batch;
+  }
+  function createTimelineReceiver() {
+    let timeline, turn, patch, entry, entryTarget, textField, textLength = 0, textParts = [], sequence = 0, parts = [], length = 0;
+    return {
+      accept(batch, pieces) {
+        if (batch !== ++sequence || !Array.isArray(pieces)) throw new Error('历史条目批次不连续');
+        const added = [];
+        const commitEntry = (target, value) => {
+          if (target === 'entry' && turn) { turn.entries.push(value); added.push({ turn, entry: value }); }
+          else if (target === 'patch-entry' && patch) patch.entries.push(value);
+          else if (target === 'patch-appended' && patch) patch.appended.push(value);
+          else throw new Error('历史条目目标无效');
+        };
+        for (const piece of pieces) {
+          if (typeof piece.text !== 'string' || typeof piece.end !== 'boolean') throw new Error('历史条目格式无效');
+          parts.push(piece.text); length += piece.text.length;
+          if (length > 32 * 1024 * 1024) throw new Error('单条历史内容超过接收限制');
+          if (!piece.end) continue;
+          const record = JSON.parse(parts.join('')); parts = []; length = 0;
+          if (entry && !['entry-text', 'entry-end'].includes(record.kind)) throw new Error('历史正文传输未完成');
+          if (record.kind === 'timeline' && !timeline) timeline = { ...record.value, turns: [] };
+          else if (record.kind === 'turn' && timeline) {
+            turn = { ...record.value, entries: [] }; timeline.turns.push(turn);
+          } else if (['entry', 'patch-entry', 'patch-appended'].includes(record.kind)) {
+            commitEntry(record.kind, record.value);
+          } else if (record.kind === 'entry-start' && !entry) {
+            entry = record.value; entryTarget = record.target; textField = record.textField; textParts = []; textLength = 0;
+          } else if (record.kind === 'entry-text' && entry && typeof record.value === 'string') {
+            textLength += record.value.length;
+            if (textLength > 32 * 1024 * 1024) throw new Error('单条历史正文超过接收限制');
+            textParts.push(record.value);
+          } else if (record.kind === 'entry-end' && entry) {
+            if (textField) entry[textField].text = textParts.join(''); else entry.text = textParts.join('');
+            textParts = []; commitEntry(entryTarget, entry); entry = null;
+          } else if (record.kind === 'patch' && timeline) {
+            patch = { ...record.value, entries: [], appended: [] };
+            (timeline.turnPatches ||= []).push(patch);
+          } else throw new Error('历史条目顺序无效');
+        }
+        return { timeline, added };
+      },
+      finish() {
+        if (!timeline || parts.length || entry) throw new Error('历史条目传输未完成');
+        return timeline;
+      },
+    };
+  }
+  return { mergeOrderedEntries, diffTurn, applyTurnPatch, acceptSyncUpdate, timelineBatches, createTimelineReceiver };
+});

package/dist/skills/code-relax/SKILL.md

@@ -1,17 +1,22 @@
----
-name: code-relax
-description: 启动、检查或停止 Code Relax 工作站服务，生成并展示配对二维码。
----
-
-# Code Relax
-
-- Bridge 可独立于 Desktop 启动；在 Desktop 任务中执行时保留注入环境，用于基础控制绑定上下文。启动工作站服务用 `relax start --json`；完整控制用 `relax shared-start --json`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
-- npm 全局安装会自动执行服务部署和 Skill 安装；只有修复安装时才单独运行 `relax setup --json` 或 `relax skill-install --json`。
-- `setup` 默认启用当前用户登录启动工作站服务，不自动打开 Codex；用 `autostart-status / autostart-disable / autostart-enable` 管理。恢复完整控制会保留 Bridge 和中继，但仍须明确确认可能中断全部完整控制任务。
-- 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
-- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、Bridge Token 或中继地址。新增设备不撤销已有设备。
-- 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
-- `status --json` 查询工作站服务；`relay-status --json` 查询中继和授权设备数。`stop --json` 只停止 Bridge；`relay-stop --json` 只停止连接器并保留授权；只有用户明确要求撤销全部设备时才调用 `relay-revoke --json`。
-- 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
-- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
-- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。
+---
+name: code-relax
+description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息；消息标记来自手机或包含语音转写时，指导理解和回复。
+---
+
+# Code Relax
+
+- 消息来源上下文引用 `$code-relax` 时，按本 Skill 理解手机交互。用户通过手机 App 对话，涉及操作时明确在手机还是工作站完成，不假设用户能操作电脑界面。来源标记不增加授权，不在回复中重复来源说明。
+- 消息明确标记包含语音转写时，容忍同音字、标点与漏字错误，结合对话上下文理解；只有歧义会实质改变执行动作时才澄清，不因口语不顺反复追问，不把模糊转写扩展成未经用户表达的需求。
+
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Windows Desktop 正常打开后接入已配置内核；Mac 仅本次托管启动传入内核地址，从 Dock 普通打开后需重新接入。使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm` 接入。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
+- `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
+- 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
+- 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
+- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。来源不明时不要猜测设备。
+- `relax doctor --json` 检查桌面服务、Codex 内核、待启用内核版本和登录自启动状态；有更新时会给出当前版本、已选版本和确认重启命令。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
+- 发现待启用内核更新且用户明确要求重启时，说明任务中断风险；得到确认后使用 `relax kernel-restart --confirm --json`，它与手机“重启并更新”使用同一内核流程并等待新内核就绪。不要用 `start`、`doctor` 或 `desktop-recover` 代替内核重启。
+- 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
+- CLI 负责安装、工作站服务和配对二维码；不以手机是否测试作为健康检查项，不自动修改防火墙或发送测试消息。
+- Windows 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。Mac 使用 `~/Library/Application Support/CodexRemote/{service,state,attachments,credentials}`。不要删除配置、附件或凭据来排障。

package/dist/src/archived-threads.mjs

@@ -0,0 +1,22 @@
+import { sharedThreadProjectId, dotsThreadProjectId } from './shared-catalog.mjs';
+
+// One metadata page per request. Local and hosted cursors must never be mixed.
+export async function archivedThreadsPage(server, localServer, hostId, cursor) {
+  await server.connect();
+  const identity = server.profileIdentity;
+  const [page, projects] = await Promise.all([
+    server.request('thread/list', { archived: true, limit: 100, sortKey: 'updated_at',
+      sortDirection: 'desc', ...(hostId === 'local' ? { useStateDbOnly: true } : {}),
+      ...(cursor ? { cursor } : {}) }),
+    localServer.projects(),
+  ]);
+  if (hostId === 'durable' && identity !== server.profileIdentity) throw new Error('云端账号已变化，请重新读取归档列表。');
+  const group = hostId === 'durable' ? dotsThreadProjectId : sharedThreadProjectId;
+  return { nextCursor: page.nextCursor || null,
+    threads: page.data.filter(thread => hostId === 'durable' ? thread.threadSource === 'aeon_child' : thread.threadSource !== 'aeon')
+      .map(thread => ({ id: thread.id, hostId, kind: 'codex', threadSource: thread.threadSource,
+        title: thread.name || thread.preview || '', projectId: group(thread, projects),
+        cwd: thread.cwd, updatedAt: thread.updatedAt, recencyAt: thread.recencyAt ?? thread.updatedAt,
+        status: typeof thread.status === 'string' ? thread.status : thread.status?.type || 'unknown',
+        activeFlags: Array.isArray(thread.status?.activeFlags) ? thread.status.activeFlags : [] })) };
+}

package/dist/src/bounded-process-log.mjs

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+
+export const processLogMaxBytes = 8 * 1024 * 1024;
+const retryMs = 30_000;
+
+// The broker drains output even when storage fails, so logging cannot crash
+// the child or build an unbounded in-memory queue.
+export function attachProcessLog(stream, file, { maxBytes = processLogMaxBytes, now = Date.now } = {}) {
+  let retryAt = 0, dropped = 0, lastError = '';
+  function append(bytes) {
+    let size = 0;
+    try { size = fs.statSync(file).size; }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    // Apply the same retention bound to a log left by an earlier launch.
+    if (size > maxBytes) {
+      const fd = fs.openSync(file, 'r+');
+      try {
+        const tail = Buffer.alloc(maxBytes);
+        const count = fs.readSync(fd, tail, 0, maxBytes, size - maxBytes);
+        fs.ftruncateSync(fd, 0);
+        writeAll(fd, tail.subarray(0, count));
+        size = count;
+      } finally { fs.closeSync(fd); }
+    }
+    for (let offset = 0; offset < bytes.length;) {
+      if (size >= maxBytes) {
+        fs.rmSync(`${file}.2`, { force: true });
+        try { fs.renameSync(`${file}.1`, `${file}.2`); }
+        catch (error) { if (error.code !== 'ENOENT') throw error; }
+        fs.renameSync(file, `${file}.1`);
+        size = 0;
+      }
+      const part = bytes.subarray(offset, offset + maxBytes - size);
+      const fd = fs.openSync(file, 'a');
+      try { writeAll(fd, part); } finally { fs.closeSync(fd); }
+      offset += part.length;
+      size += part.length;
+    }
+  }
+  stream.on('data', chunk => {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (now() < retryAt) { dropped += bytes.length; return; }
+    try {
+      if (dropped) append(Buffer.from(`\n[log recovered ${new Date(now()).toISOString()}; previous error: ${lastError}; discarded output bytes: ${dropped}]\n`));
+      append(bytes);
+      dropped = 0;
+      retryAt = 0;
+    } catch (error) {
+      dropped += bytes.length;
+      lastError = error.code || error.message;
+      retryAt = now() + retryMs;
+    }
+  });
+}
+
+function writeAll(fd, bytes) {
+  let offset = 0;
+  while (offset < bytes.length) {
+    const count = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+    if (!count) throw new Error('Log write made no progress.');
+    offset += count;
+  }
+}

package/dist/src/celsius-client.mjs

@@ -0,0 +1,107 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+
+// Shared Celsius framing and acknowledged topic lifecycle; callers own identity and HTTP.
+export class CelsiusClient extends EventEmitter {
+  constructor({ getConnection, topics = [] }) {
+    super(); this.getConnection = getConnection; this.initialTopics = topics;
+    this.generation = 0; this.topics = new Map(); this.commands = new Map();
+    this.nextId = 0; this.topicLoads = new Map();
+  }
+  async connect() {
+    if (this.ready) return;
+    if (this.connecting) return this.connecting;
+    const generation = this.generation;
+    const work = (async () => {
+      const value = await this.getConnection();
+      if (generation !== this.generation) throw new Error('消息连接已变化。');
+      const url = new URL(value.websocket_url);
+      if (url.protocol !== 'wss:' || url.username || url.password) throw new Error('消息推送地址无效。');
+      await new Promise((resolve, reject) => {
+        const socket = new WebSocket(url, { handshakeTimeout: 15000, maxPayload: 8 * 1024 * 1024 });
+        this.socket = socket;
+        const timer = setTimeout(() => { reject(new Error('消息推送订阅超时。')); socket.terminate(); }, 30000);
+        const current = () => this.socket === socket && generation === this.generation;
+        socket.on('error', () => {}); // Do not expose the signed URL in library errors.
+        socket.on('open', async () => {
+          try {
+            await this.command({ type: 'connect', presence: { type: 'presence', state: 'background' } });
+            for (const topic of this.initialTopics) await this.subscribe(topic);
+            if (!current()) throw new Error('消息连接已变化。');
+            this.ready = true; clearTimeout(timer); resolve(); this.emit('connected');
+          } catch (error) { clearTimeout(timer); reject(error); socket.terminate(); }
+        });
+        socket.on('message', data => {
+          if (!current()) return;
+          let frames; try { frames = JSON.parse(data.toString()); } catch { return; }
+          if (!Array.isArray(frames)) return;
+          for (const frame of frames) {
+            if (frame.type === 'message') this.receive(frame);
+            else if (frame.id != null) this.commands.get(frame.id)?.resolve(frame.reply);
+          }
+        });
+        socket.on('close', code => {
+          clearTimeout(timer); reject(new Error('消息推送连接已断开。'));
+          if (!current()) return;
+          this.ready = false; this.socket = null;
+          for (const entry of this.commands.values()) entry.reject(new Error('消息推送连接已断开。'));
+          this.commands.clear(); this.topics.clear(); this.topicLoads.clear();
+          this.emit('disconnected', { source: 'celsius', code });
+        });
+      });
+    })();
+    this.connecting = work;
+    try { await work; } finally { if (this.connecting === work) this.connecting = null; }
+  }
+
+  command(command) {
+    if (this.socket?.readyState !== WebSocket.OPEN) return Promise.reject(new Error('消息推送尚未连接。'));
+    const id = ++this.nextId;
+    const socket = this.socket;
+    return new Promise((resolve, reject) => {
+      const finish = (error, value) => {
+        if (!this.commands.has(id)) return;
+        clearTimeout(timer); this.commands.delete(id);
+        if (error) reject(error); else resolve(value);
+      };
+      const timer = setTimeout(() => { finish(new Error('消息推送请求超时。')); socket.terminate(); }, 30000);
+      this.commands.set(id, { resolve: value => finish(null, value), reject: error => finish(error) });
+      socket.send(JSON.stringify([{ id, command }]), error => { if (error) finish(new Error('消息推送连接已断开。')); });
+    });
+  }
+
+  async subscribe(name, { offset, requireRecovery = false } = {}) {
+    if (this.topics.has(name)) return;
+    if (this.topicLoads.has(name)) return this.topicLoads.get(name);
+    const generation = this.generation, socket = this.socket;
+    // Every transport reconnection invalidates chat snapshots and reads a new
+    // latest window. An old offset never certifies the new snapshot by itself.
+    const work = this.command({ type: 'subscribe', topic_id: name, ...(offset == null ? {} : { offset }) }).then(reply => {
+      if (socket !== this.socket || generation !== this.generation) throw new Error('消息连接已变化。');
+      if (reply?.type !== 'subscribe' || reply.topic_id !== name) throw new Error('消息推送订阅未确认。');
+      if (requireRecovery && !reply.recovered) throw new Error('ChatGPT 输出历史未完整接续，请核对原消息。');
+      this.topics.set(name, reply.last_offset || null);
+      if (reply.recovered) for (const message of reply.catchups || []) this.receive(message);
+    });
+    this.topicLoads.set(name, work);
+    try { await work; } finally { if (this.topicLoads.get(name) === work) this.topicLoads.delete(name); }
+  }
+
+  async unsubscribe(name) {
+    if (!this.topics.delete(name) || this.socket?.readyState !== WebSocket.OPEN) return;
+    await this.command({ type: 'unsubscribe', topic_id: name });
+  }
+
+  receive(frame) {
+    if (frame.offset) this.topics.set(frame.topic_id, frame.offset);
+    this.emit('message', frame.topic_id, frame.payload);
+  }
+
+
+  close() {
+    this.generation++; this.ready = false; this.connecting = null;
+    const socket = this.socket; this.socket = null; socket?.terminate();
+    for (const entry of this.commands.values()) entry.reject(new Error('消息推送连接已结束。'));
+    this.commands.clear(); this.topics.clear(); this.topicLoads.clear();
+  }
+}

package/dist/src/code-browser.mjs

@@ -0,0 +1,99 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import protocol from '../shared/code-browser.cjs';
+import { fileRange, fileRevision } from './file-transfer-range.mjs';
+
+async function checkedPath(root, relative) {
+  const target = protocol.child(root, relative);
+  return fs.realpath(target);
+}
+
+function git(cwd, args) {
+  return new Promise((resolve, reject) => execFile('git', ['--no-optional-locks', '--literal-pathspecs', '-c', 'core.quotePath=false', ...args],
+    { cwd, encoding: 'utf8', maxBuffer: protocol.maxBytes, timeout: 15000, windowsHide: true },
+    (error, stdout, stderr) => {
+      if (error) reject(Object.assign(new Error(error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER'
+        ? 'Git 输出超过预览上限（1 MiB）。' : String(stderr || error.message).trim()), { statusCode: 422 }));
+      else resolve(stdout);
+    }));
+}
+
+export async function browseCode(rpc, operation, query) {
+  if (operation === 'change') return protocol.change(rpc, query);
+  if (operation === 'changes') return protocol.changes(rpc, query);
+  if (operation === 'roots') return { ...await protocol.context(rpc, query), workspaceDiff: true, sizeCheckedBeforeRead: true };
+  const root = query.get('root');
+  if (typeof root !== 'string' || !path.isAbsolute(root)) protocol.fail('请输入电脑上的绝对目录路径。');
+  if (operation === 'workspace' || operation === 'workspace-file') {
+    const realRoot = await checkedPath(root, '');
+    const repository = (await git(realRoot, ['rev-parse', '--show-toplevel'])).trim();
+    const scope = path.relative(repository, realRoot).replaceAll('\\', '/') || '.';
+    if (scope.startsWith('..') || path.isAbsolute(scope)) protocol.fail('无法确认 Git 仓库范围。', 403);
+    const toRelative = name => protocol.relative(realRoot, path.resolve(repository, name));
+    if (operation === 'workspace-file') {
+      const group = query.get('group');
+      if (!['staged', 'unstaged'].includes(group)) protocol.fail('未知的变更来源。');
+      const names = [query.get('path'), query.get('oldPath')].filter(Boolean);
+      if (!names.length) protocol.fail('请选择变更文件。');
+      const paths = names.map(name => path.relative(repository, protocol.child(realRoot, name)).replaceAll('\\', '/'));
+      const diff = await git(repository, ['diff', ...(group === 'staged' ? ['--cached'] : []), '--no-ext-diff', '--no-textconv', '--no-color', names.length > 1 ? '--find-renames' : '--no-renames', '--', ...paths]);
+      return { diff, scope: group === 'staged' ? '当前工作区 · 已暂存' : '当前工作区 · 未暂存' };
+    }
+    const entries = [];
+    for (const group of ['unstaged', 'staged']) {
+      const fields = (await git(repository, ['diff', ...(group === 'staged' ? ['--cached'] : []), '--name-status', '-z', '--find-renames', '--no-ext-diff', '--no-textconv', '--', scope])).split('\0');
+      for (let i = 0; i < fields.length && fields[i];) {
+        const status = fields[i++], first = fields[i++];
+        const renamed = /^[RC]/.test(status), last = renamed ? fields[i++] : first;
+        const name = toRelative(last), oldPath = renamed ? toRelative(first) : null;
+        if (name == null) { if (oldPath != null) entries.push({ path: oldPath, oldPath: null, status: 'D', group }); continue; }
+        entries.push({ path: name, oldPath, status: renamed && oldPath == null ? 'A' : status, group });
+      }
+    }
+    for (const name of (await git(repository, ['ls-files', '--others', '--exclude-standard', '-z', '--', scope])).split('\0').filter(Boolean)) {
+      const relative = toRelative(name);
+      if (relative != null) entries.push({ path: relative, status: '?', group: 'untracked' });
+    }
+    if (entries.length > protocol.maxEntries) protocol.fail('变更文件超过 4000 项，暂不支持展示。', 413);
+    return { root, entries, scope: '当前工作区快照 · 非本次任务归属' };
+  }
+  const relative = query.get('path') || '';
+  const target = await checkedPath(root, relative);
+  if ((operation === 'image' || operation === 'binary')) {
+    const handle = await fs.open(target, 'r');
+    try {
+      const before = await handle.stat();
+      if (!before.isFile()) protocol.fail('请选择普通文件。', 415);
+      if (!before.size) protocol.fail('文件为空。', 415);
+      const revision = fileRevision(before);
+      const { offset, length } = fileRange(query, before.size, revision);
+      const header = Buffer.alloc(12);
+      await handle.read(header, 0, header.length, 0);
+      const mimeType = operation === 'binary' ? 'application/octet-stream' : protocol.imageMime(header);
+      const data = Buffer.alloc(length);
+      const { bytesRead } = await handle.read(data, 0, data.length, offset);
+      const real = await checkedPath(root, relative), after = await handle.stat(), onDisk = await fs.stat(real);
+      if (real !== target || bytesRead !== data.length || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || after.size !== before.size || onDisk.ino !== before.ino || onDisk.dev !== before.dev || onDisk.mtimeMs !== before.mtimeMs || onDisk.size !== before.size) protocol.fail('读取期间文件发生变化，请重新打开。', 409);
+      return { name: path.basename(target), size: before.size, offset, revision, mimeType, data };
+    } finally { await handle.close(); }
+  }
+  if (operation === 'directory') {
+    const entries = await fs.readdir(target, { withFileTypes: true });
+    const result = { entries: entries.map(entry => ({ fileName: entry.name, isDirectory: entry.isDirectory(), isFile: entry.isFile() })) };
+    await checkedPath(root, relative);
+    return protocol.directory(result);
+  }
+  if (operation === 'file') {
+    const before = await fs.stat(target);
+    if (!before.isFile()) protocol.fail('请选择普通文件。', 415);
+    if (before.size > protocol.maxBytes) protocol.fail('文件超过只读预览上限（1 MiB）。', 413);
+    const result = { dataBase64: (await fs.readFile(target)).toString('base64') };
+    const real = await checkedPath(root, relative), after = await fs.stat(real);
+    if (real !== target || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ino !== after.ino) {
+      protocol.fail('读取期间文件发生变化，请刷新。', 409);
+    }
+    return { ...protocol.fromBase64(result.dataBase64), modifiedAtMs: after.mtimeMs };
+  }
+  protocol.fail('未知的代码浏览操作。', 404);
+}