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

package/dist/src/code-browser.mjs

@@ -0,0 +1,101 @@
+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);
+  const [base, real] = await Promise.all([fs.realpath(root), fs.realpath(target)]);
+  if (!protocol.inside(base, real)) protocol.fail('此链接指向项目目录之外，无法浏览。', 403);
+  return real;
+}
+
+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);
+  const context = await protocol.context(rpc, query);
+  if (operation === 'roots') return { ...context, workspaceDiff: true, sizeCheckedBeforeRead: true };
+  if (operation === 'changes') return protocol.changes(rpc, query);
+  const root = protocol.selectedRoot(context, query);
+  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.maxFileBytes) protocol.fail('文件超过预览上限（20 MiB）。', 413);
+      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 result = await rpc('fs/readDirectory', { path: target });
+    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 = await rpc('fs/readFile', { path: target });
+    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);
+}

package/dist/src/desktop-launcher.mjs

@@ -1,46 +1,46 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { readRecord } from './service-lifecycle.mjs';
-import { ManagedAppServer, managedAppServerUrl as sharedUrl, managedPortAvailable as portAvailable } from './managed-app-server.mjs';
-export { portAvailable };
-export async function launchDesktop({ stateRoot, host, environment = process.env, available = portAvailable, wait = delay, timeout = 30000, recoveryId, progress = () => {} }) {
-  fs.mkdirSync(stateRoot, { recursive: true });
-  const recovery = readRecord(path.join(stateRoot, 'shared-recovery.lock'));
-  if (recovery && recovery.operationId !== recoveryId) throw new Error('Codex 内核正在启动，请用 relax doctor 查看恢复状态。');
+import fs from 'node:fs';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { readRecord } from './service-lifecycle.mjs';
+import { ManagedAppServer, managedAppServerUrl as sharedUrl, managedPortAvailable as portAvailable } from './managed-app-server.mjs';
+export { portAvailable };
+export async function launchDesktop({ stateRoot, host, environment = process.env, available = portAvailable, wait = delay, timeout = 30000, recoveryId, progress = () => {} }) {
+  fs.mkdirSync(stateRoot, { recursive: true });
+  const recovery = readRecord(path.join(stateRoot, 'shared-recovery.lock'));
+  if (recovery && recovery.operationId !== recoveryId) throw new Error('Codex 内核正在启动，请用 relax doctor 查看恢复状态。');
   const lock = path.join(stateRoot, 'desktop-launch.lock');
-  let descriptor;
-  let managed;
+  let descriptor;
+  let managed;
   try { descriptor = fs.openSync(lock, 'wx'); }
   catch (error) {
     if (error.code === 'EEXIST') throw new Error('另一个 Desktop 启动操作正在进行；若上次异常退出，请确认没有启动器运行后移除 desktop-launch.lock。');
     throw error;
   }
   try {
-    const info = await host.inspect();
-    if (!info.desktop) throw new Error('未安装 Codex Desktop，请使用 relax start 启动工作站。');
+    const info = await host.inspect();
+    if (!info.desktop) throw new Error('未安装 Codex Desktop，请使用 relax start 启动工作站。');
     const connected = await host.sharedServiceUrl();
     if (info.running) {
-      if (connected) return { reused: true };
-      throw new Error('请先保存任务并完全退出 Codex Desktop，再接入 Codex 内核；不会自动结束正在运行的任务。');
+      if (connected) return { reused: true };
+      throw new Error('请先保存任务并完全退出 Codex Desktop，再接入 Codex 内核；不会自动结束正在运行的任务。');
     }
-    const childEnv = { ...environment };
+    const childEnv = { ...environment };
     for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnv[key];
-    progress('starting-app-server');
-    managed = new ManagedAppServer({ stateRoot, host, environment, available, wait, timeout });
-    if (!await managed.start()) throw new Error(managed.snapshot().error || 'Codex 内核未就绪。');
-    const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
-    if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
-    childEnv.CODEX_APP_SERVER_WS_URL = sharedUrl;
-    progress('starting-desktop');
-    await host.start(info.desktop, [], childEnv, []);
+    progress('starting-app-server');
+    managed = new ManagedAppServer({ stateRoot, host, environment, available, wait, timeout });
+    if (!await managed.start()) throw new Error(managed.snapshot().error || 'Codex 内核未就绪。');
+    const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
+    if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
+    childEnv.CODEX_APP_SERVER_WS_URL = sharedUrl;
+    progress('starting-desktop');
+    await host.startDesktop(info.desktop, childEnv);
     const deadline = Date.now() + timeout;
     while (true) {
-      const ready = await host.sharedServiceUrl();
+      const ready = await host.desktopReady();
       if (ready) break;
-      if (Date.now() >= deadline) throw new Error('Desktop 尚未接入 Codex 内核。请查看 Desktop 窗口后重试。');
+      if (Date.now() >= deadline) throw new Error('Desktop 尚未接入 Codex 内核。请查看 Desktop 窗口后重试。');
       await wait(500);
     }
-    return { reused: false };
-  } finally { managed?.close(); fs.closeSync(descriptor); fs.rmSync(lock, { force: true }); }
-}
+    return { reused: false };
+  } finally { managed?.close(); fs.closeSync(descriptor); fs.rmSync(lock, { force: true }); }
+}

package/dist/src/dots-approval-timeline.mjs

@@ -0,0 +1,99 @@
+const itemTime = item => item.dotsReceipt?.sentAt ? Date.parse(item.dotsReceipt.sentAt)
+  : item.startedAtMs ?? item.receivedAtMs;
+const terminal = status => ['resolved', 'expired'].includes(status);
+
+// Approval records have their own official room source. Keep them with the
+// account-scoped hosted cache, then place them in the chat's observed positions.
+export class DotsApprovalTimeline {
+  constructor(server) { this.server = server; this.states = new Map(); }
+
+  async state(threadId) {
+    const scope = this.server.historyScope(threadId);
+    if (!scope) throw new Error('读取点点审批历史需要账号身份。');
+    let state = this.states.get(scope);
+    if (!state) {
+      state = { scope, threadId, epoch: this.server.epoch, records: new Map() };
+      state.ready = (async () => {
+        const saved = await this.server.historyCache?.get(scope, 'approval-records');
+        for (const record of saved?.data || []) {
+          // A display record never reactivates an old pending request.
+          state.records.set(this.key(record), terminal(record.status) ? record : { ...record, status: 'expired' });
+        }
+      })();
+      this.states.set(scope, state);
+    }
+    await state.ready;
+    this.check(threadId, state);
+    return state;
+  }
+
+  check(threadId, state) {
+    if (state.scope !== this.server.historyScope(threadId) || state.epoch !== this.server.epoch) throw new Error('点点审批历史的账号连接已变化。');
+  }
+
+  key(item) { return JSON.stringify([typeof item.requestId, item.requestId]); }
+
+  merge(state, incoming) {
+    let changed = false;
+    for (const item of incoming) {
+      const key = this.key(item), previous = state.records.get(key);
+      const merged = { ...previous, ...item, id: previous?.id || item.id,
+        receivedAtMs: previous?.receivedAtMs ?? item.receivedAtMs,
+        ...(previous?.result && item.result == null ? { result: previous.result } : {}),
+        ...(previous?.afterItemId ? { afterItemId: previous.afterItemId } : {}) };
+      if (JSON.stringify(previous) !== JSON.stringify(merged)) { state.records.set(key, merged); changed = true; }
+    }
+    return changed;
+  }
+
+  save(state) {
+    return this.server.historyCache?.put(state.scope, 'approval-records', { data: [...state.records.values()] });
+  }
+
+  targets(sourceThreadId) {
+    return [...this.states.values()].filter(state => state.scope === this.server.historyScope(state.threadId)
+      && [...state.records.values()].some(record => record.params.threadId === sourceThreadId)).map(state => state.threadId);
+  }
+
+  async observe(threadId, records, turns) {
+    const state = await this.state(threadId);
+    const incoming = records.map(record => {
+      const turn = turns?.find(turn => turn.id === record.turnId);
+      const afterItemId = turn?.items.filter(item => item.type !== 'approval').at(-1)?.id;
+      return { ...record, ...(afterItemId ? { afterItemId } : {}) };
+    });
+    if (this.merge(state, incoming)) await this.save(state);
+    this.check(threadId, state);
+  }
+
+  overlay(threadId, turns, range = {}) {
+    const state = this.states.get(this.server.historyScope(threadId));
+    if (!state) return turns;
+    const ids = new Set([...state.records.values()].map(item => item.id));
+    const result = turns.map(turn => ({ ...turn, items: turn.items.filter(item => item.type !== 'approval' || !ids.has(item.id)) }));
+    for (const approval of [...state.records.values()].sort((a, b) => a.receivedAtMs - b.receivedAtMs)) {
+      if (Number.isFinite(range.fromMs) && approval.receivedAtMs < range.fromMs
+        || Number.isFinite(range.toMs) && approval.receivedAtMs > range.toMs) continue;
+      let turn = result.find(turn => turn.id === approval.roomMessageId || turn.id === approval.turnId);
+      if (!turn) {
+        if (!Number.isFinite(range.fromMs)) continue;
+        const positions = result.flatMap(turn => turn.items.map(item => ({ turn, item, time: itemTime(item) })))
+          .filter(position => Number.isFinite(position.time));
+        turn = positions.filter(position => position.time <= approval.receivedAtMs).at(-1)?.turn || positions[0]?.turn;
+      }
+      if (!turn) continue;
+      const after = turn.items.findIndex(item => item.id === approval.afterItemId);
+      if (after >= 0) {
+        let index = after + 1;
+        while (turn.items[index]?.type === 'approval' && turn.items[index].receivedAtMs <= approval.receivedAtMs) index++;
+        turn.items.splice(index, 0, approval);
+      } else {
+        const next = turn.items.findIndex(item => Number.isFinite(itemTime(item)) && itemTime(item) > approval.receivedAtMs);
+        turn.items.splice(next < 0 ? turn.items.length : next, 0, approval);
+      }
+    }
+    return result;
+  }
+
+  clear() { this.states.clear(); }
+}

package/dist/src/dots-avatar.mjs

@@ -0,0 +1,42 @@
+import sharp from 'sharp';
+
+// Resolve Desktop's saved snapshot on the workstation. Signed URLs never go to the phone.
+export function createDotsAvatarReader(localServer) {
+  const cache = new Map();
+  return async (profile, identity) => {
+    if (!profile.avatarFileId) return '';
+    const key = JSON.stringify([identity.accountId, identity.userId, profile.avatarFileId]);
+    if (!cache.has(key)) {
+      const work = (async () => {
+        const auth = await localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+        const principal = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url'))['https://api.openai.com/auth'];
+        if (principal?.chatgpt_account_id !== identity.accountId || principal.chatgpt_user_id !== identity.userId) {
+          throw new Error('头像账号已变化，请刷新对话。');
+        }
+        const response = await fetch(`https://chatgpt.com/backend-api/files/download/${encodeURIComponent(profile.avatarFileId)}?download_intent=false&inline=true`, {
+          headers: { Authorization: `Bearer ${auth.authToken}`, 'ChatGPT-Account-Id': identity.accountId },
+          redirect: 'error', signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) { await response.body?.cancel(); throw new Error(`点点头像资料读取失败（${response.status}）`); }
+        const { download_url: downloadUrl } = await response.json();
+        const url = new URL(downloadUrl);
+        const authenticated = url.origin === 'https://chatgpt.com' && url.pathname === '/backend-api/estuary/content';
+        if (url.protocol !== 'https:' || !(authenticated || url.hostname.endsWith('.oaiusercontent.com'))) throw new Error('点点头像下载地址无效。');
+        const image = await fetch(url, { redirect: 'error', signal: AbortSignal.timeout(15000),
+          ...(authenticated ? { headers: { Authorization: `Bearer ${auth.authToken}`, 'ChatGPT-Account-Id': identity.accountId } } : {}) });
+        if (!image.ok) { await image.body?.cancel(); throw new Error(`点点头像下载失败（${image.status}）`); }
+        const chunks = []; let size = 0;
+        for await (const chunk of image.body) {
+          size += chunk.length;
+          if (size > 4 * 1024 * 1024) throw new Error('点点头像超过 4 MiB。');
+          chunks.push(chunk);
+        }
+        const thumbnail = await sharp(Buffer.concat(chunks)).resize(96, 96, { fit: 'inside', withoutEnlargement: true }).webp().toBuffer();
+        return `data:image/webp;base64,${thumbnail.toString('base64')}`;
+      })();
+      cache.set(key, work);
+      work.catch(() => { if (cache.get(key) === work) cache.delete(key); });
+    }
+    return cache.get(key);
+  };
+}

package/dist/src/dots-chat-projection.mjs

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+import { dotsImageReference } from './dots-message-images.mjs';
+
+const nonempty = value => typeof value === 'string' && value.trim().length > 0;
+
+export function dotsChatRevision(turns) {
+  const latest = dotsChatTailRevision(turns);
+  const message = dotsChatMessageRevision(turns);
+  // A message can keep streaming while a later agent action is already visible.
+  return !latest || latest === message ? latest
+    : createHash('sha256').update(JSON.stringify([latest, message])).digest('hex');
+}
+
+// A bounded disk-head probe compares the same last visible item on both sides.
+// The full transcript revision also tracks an earlier streaming message.
+export function dotsChatTailRevision(turns) {
+  return chatItemRevision(turns.at(-1)?.items.at(-1));
+}
+
+export function dotsChatMessageRevision(turns) {
+  for (let turnIndex = turns.length - 1; turnIndex >= 0; turnIndex--) {
+    const items = turns[turnIndex].items;
+    for (let itemIndex = items.length - 1; itemIndex >= 0; itemIndex--) {
+      const item = items[itemIndex];
+      if (item.type === 'userMessage' || item.type === 'agentMessage') return chatItemRevision(item);
+    }
+  }
+  // A recent window containing only agent actions cannot acknowledge a chat message.
+  return undefined;
+}
+
+function chatItemRevision(item) {
+  if (!item) return '';
+  const content = item.type === 'userMessage' ? item.content.map(part => {
+    const reference = dotsImageReference(part);
+    if (!reference?.url) return part;
+    // Renewing an official storage signature does not create a new message.
+    const url = new URL(reference.url);
+    return { ...part, url: url.origin + url.pathname };
+  }) : item.type === 'subAgentActivity' ? [item.kind, item.agentThreadId, item.agentPath]
+    : [item.text || '', item.attachments || []];
+  // Identity and displayed content survive reconnects; internal work does not affect this marker.
+  return createHash('sha256').update(JSON.stringify([item.id, item.type, content])).digest('hex');
+}
+// Execution events remain separate from room user/agent messages.
+export function projectDotsChatItem(item) {
+  if (item?.type !== 'subAgentActivity' || !nonempty(item.id) || !nonempty(item.agentThreadId)
+    || !['started', 'interacted', 'completed', 'interrupted'].includes(item.kind)) return null;
+  return { type: item.type, id: item.id, kind: item.kind, agentThreadId: item.agentThreadId, agentPath: item.agentPath || '' };
+}