@walkhi/code-relax 0.1.0-beta.27 → 0.1.0-beta.29

package/dist/src/shared-thread-stream.mjs

@@ -1,86 +1,164 @@
 // Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
 import timelineSync from '../shared/timeline-sync.cjs';
-const threadListNotificationMethods = new Set([
+export const threadListNotificationMethods = new Set([
   'thread/started', 'thread/status/changed', 'thread/name/updated',
   'thread/archived', 'thread/unarchived', 'thread/deleted',
   'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
 ]);
 export async function streamSharedThread(response, threadId, client, normalize, requestedSync) {
   response.startEvents();
-  let closed = false, timer, subscription, streamReady = false, flushing = false;
+  let closed = false, timer, subscription, releaseActivity, streamReady = false, flushing = false;
+  let tracePending = false, pendingReset;
   const pending = new Map(), sentTurns = new Map();
   let fromSeq, toSeq, syncId = requestedSync?.id, epoch = requestedSync?.epoch;
   let finish;
   const done = new Promise(resolve => { finish = resolve; });
   const emit = (name, value) => { if (!closed) return response.event(name, value); };
+  let historySync;
+  const publishHistorySync = () => {
+    if (typeof client.isHistorySyncing !== 'function') return;
+    const active = client.isHistorySyncing(threadId);
+    // End the notice only after the recovered body has been delivered, not
+    // when the upstream read finishes while its update is still being flushed.
+    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
+    if (historySync === active) return;
+    historySync = active;
+    emit('history-sync', { threadId, active });
+  };
   const flush = async () => {
     clearTimeout(timer); timer = null;
     const record = client.threads.get(threadId);
-    if (closed || flushing || !streamReady || !record || !pending.size) return;
+    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
     flushing = true;
     try {
-      const base = normalize({ thread: { ...record.thread, turns: [] }, sync: { id: syncId, epoch, fromSeq, toSeq } });
+      if (pendingReset) {
+        const snapshot = pendingReset;
+        pendingReset = undefined;
+        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
+        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
+        if (!pending.size) toSeq = undefined;
+        tracePending = [...pending.values()].some(change => change.immediate);
+        const normalized = await normalize(snapshot);
+        if (closed) return;
+        await emit('update', normalized);
+        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
+        sentTurns.clear();
+        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
+          turnOrder: normalized.turns.map(turn => turn.id) });
+        return;
+      }
+      const batch = structuredClone([...pending.values()].map(change => change.turn));
+      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
+      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
+      const trace = tracePending;
+      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
+      const base = await normalize({ thread, sync });
       const turns = [], turnPatches = [];
-      for (const turn of pending.values()) {
-        const normalized = normalize({ thread: { ...record.thread, turns: [turn] } }).turns[0];
+      const normalizedTurns = [];
+      for (const turn of batch) {
+        if (turn.cacheStub) continue;
+        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
         const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
         if (patch) turnPatches.push(patch); else turns.push(normalized);
-        sentTurns.set(turn.id, normalized);
+        normalizedTurns.push(normalized);
       }
-      const retained = new Set(record.thread.turns.map(turn => turn.id));
-      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
-      pending.clear();
-      fromSeq = toSeq = undefined;
+      if (closed) return;
       await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
+      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
+      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
+      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
+        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
+        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
+        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
+      }
     } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
     finally {
       flushing = false;
-      if (!closed && pending.size && !timer) timer = setTimeout(flush, 0);
+      publishHistorySync();
+      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
     }
   };
   const onTurn = ({ thread, turn, sequence, immediate }) => {
     if (thread.id !== threadId) return;
     if (!fromSeq) fromSeq = sequence;
     toSeq = sequence;
-    pending.set(turn.id, turn);
+    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
+    if (immediate) tracePending = true;
     if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
   };
+  const onReset = snapshot => {
+    if (snapshot.thread.id !== threadId) return;
+    pendingReset = structuredClone(snapshot);
+    pendingReset.sync.reset = true;
+    flush();
+  };
   const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
   const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
   const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
-  const onNotification = ({ method, params }) => {
-    if (!threadListNotificationMethods.has(method)) return;
-    emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
-  };
   const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
+  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
+  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
+  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
   response.once('close', () => { closed = true; finish(); });
   client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('timeline-reset', onReset);
   client.on('queue-changed', onQueue);
   client.on('requests-changed', onRequests);
-  client.on('notification', onNotification);
+  client.on('history-invalidated', onInvalidated);
+  client.on('history-sync', onHistorySync);
+  client.on('chat-error', onChatError);
+  publishHistorySync();
   try {
+    const started = performance.now();
+    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
     subscription = await client.acquire(threadId, requestedSync);
     syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
     if (!closed) {
-      const normalized = normalize(subscription.record);
-      // The acquired snapshot/catchup already includes pre-acquire notifications.
-      pending.clear(); fromSeq = toSeq = undefined;
-      if (subscription.snapshot) await emit('update', normalized);
-      else if (subscription.catchup) await emit('update', normalize(subscription.catchup));
-      for (const turn of normalized.turns) sentTurns.set(turn.id, turn);
+      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
+      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
+      // Only discard notifications certified by the acquired snapshot/catchup.
+      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
+      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
+      if (!pending.size) toSeq = undefined;
+      tracePending = [...pending.values()].some(change => change.immediate);
+      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
+      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
+      const sent = Boolean(delivered) && !closed;
+      if (sent) await emit('update', delivered);
+      // A timestamp-confirmed cache only needs the new subscription boundary,
+      // never an empty replacement window or a repeated body snapshot.
+      if (subscription.confirmed && !closed) await emit('sync-ready', {
+        thread: normalized.thread, sync: normalized.sync,
+      });
+      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
+        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
+        deliveredSync: sent ? delivered.sync : undefined,
+        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
+        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
+      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
       emit('queue-changed', {});
       onRequests(threadId);
       streamReady = true;
+      publishHistorySync();
+      if (!closed && typeof client.acquireActivity === 'function') {
+        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
+      }
       flush();
     }
     await done;
   } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
   finally {
+    client.traceSync?.('stream-close', threadId, { ready: streamReady });
     clearTimeout(timer);
+    releaseActivity?.();
     client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('timeline-reset', onReset);
     client.off('queue-changed', onQueue);
     client.off('requests-changed', onRequests);
-    client.off('notification', onNotification);
+    client.off('history-invalidated', onInvalidated);
+    client.off('history-sync', onHistorySync);
+    client.off('chat-error', onChatError);
     if (subscription) await subscription.release();
   }
 }

package/dist/src/usage-reset.mjs

@@ -0,0 +1,17 @@
+export async function consumeUsageReset(client, body) {
+  if (typeof body?.idempotencyKey !== 'string' || !body.idempotencyKey.trim() || body.idempotencyKey.length > 200
+    || typeof body.creditId !== 'string' || !body.creditId.trim() || body.creditId.length > 200) {
+    throw Object.assign(new Error('请选择重置卡并确认使用。'), { statusCode: 400, code: 'usage_reset_not_submitted' });
+  }
+  let usage;
+  try { usage = await client.usage(); }
+  catch (error) { throw Object.assign(new Error('用量尚未确认，请恢复连接后重新选择重置卡。', { cause: error }),
+    { statusCode: 503, code: 'usage_reset_not_submitted' }); }
+  if ((usage.accountId || null) !== (body.accountId || null)) {
+    throw Object.assign(new Error('Codex 账号已变化，请重新打开用量详情。'), { statusCode: 409, code: 'usage_reset_not_submitted' });
+  }
+  // The core owns eligibility and the idempotent redemption outcome.
+  return client.request('account/rateLimitResetCredit/consume', {
+    idempotencyKey: body.idempotencyKey, creditId: body.creditId,
+  });
+}

package/dist/src/workstation-downloads.mjs

@@ -0,0 +1,120 @@
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileRevision, FILE_PART_BYTES, FILE_READ_LIMIT } from './file-transfer-range.mjs';
+import { readRecord, writeRecord } from './service-lifecycle.mjs';
+
+const fail = (message, statusCode = 400) => { throw Object.assign(new Error(message), { statusCode }); };
+const pathKey = value => process.platform === 'win32' ? value.toLowerCase() : value;
+const validName = value => typeof value === 'string' && value.length > 0
+  && !/[<>:"/\\|?*\x00-\x1f]/.test(value) && !/[ .]$/.test(value) && !['.', '..'].includes(value)
+  && !/^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(value);
+
+// A saved copy belongs to the authorized external asset, rather than its current chat page.
+export class WorkstationDownloads {
+  constructor(stateRoot) {
+    this.recordPath = path.join(stateRoot, 'external-file-copies.json');
+    this.copies = readRecord(this.recordPath) || {};
+  }
+
+  async copy(sourceId) {
+    const record = this.copies[sourceId];
+    if (!record) return null;
+    try {
+      const stat = await fs.stat(record.path);
+      return stat.isFile() && fileRevision(stat) === record.revision && stat.size === record.size ? record : null;
+    } catch (error) { if (['ENOENT', 'ENOTDIR'].includes(error.code)) return null; throw error; }
+  }
+
+  async folder(rpc, locations, selection) {
+    let root;
+    if (selection.target === 'downloads') root = locations.downloads;
+    else if (selection.target === 'project' && typeof selection.projectId === 'string' && selection.projectId) {
+      const { project } = await rpc('project/read', { projectId: selection.projectId });
+      const selected = selection.root || project.roots[0]?.path;
+      root = project.roots.find(item => pathKey(item.path) === pathKey(selected))?.path;
+    }
+    if (!root || !path.isAbsolute(root)) fail('请选择电脑项目或下载目录。');
+    const relative = selection.path || '';
+    if (typeof relative !== 'string' || relative.split('/').some(part => part && !validName(part))) fail('子文件夹路径无效。');
+    const realRoot = await fs.realpath(root), target = path.join(realRoot, ...relative.split('/'));
+    const realTarget = await fs.realpath(target), difference = path.relative(realRoot, realTarget);
+    if (difference === '..' || difference.startsWith('..' + path.sep) || path.isAbsolute(difference)) fail('只能选择当前目录内的子文件夹。');
+    if (!(await fs.stat(realTarget)).isDirectory()) fail('所选路径不是文件夹。');
+    return { root, path: relative, absolutePath: target, realPath: realTarget,
+      parent: relative ? relative.split('/').slice(0, -1).join('/') : null };
+  }
+
+  async browse(rpc, locations, selection) {
+    const folder = await this.folder(rpc, locations, selection);
+    const entries = (await fs.readdir(folder.realPath, { withFileTypes: true })).filter(entry => entry.isDirectory())
+      .map(entry => ({ name: entry.name, path: [folder.path, entry.name].filter(Boolean).join('/') }))
+      .sort((a, b) => a.name.localeCompare(b.name, 'zh-CN', { numeric: true }));
+    const { realPath, ...visible } = folder;
+    return { ...visible, entries };
+  }
+
+  async save(rpc, locations, selection, asset, readPart, signal) {
+    const folder = await this.folder(rpc, locations, selection);
+    const partial = path.join(folder.realPath, `.code-relax-${crypto.randomUUID()}.download.part`);
+    let handle, result, created = false;
+    try {
+      signal?.throwIfAborted();
+      handle = await fs.open(partial, 'wx', 0o600);
+      created = true;
+      let offset = 0, size, revision, name, mimeType;
+      do {
+        signal?.throwIfAborted();
+        const query = new URLSearchParams({ offset: String(offset), length: String(FILE_PART_BYTES) });
+        if (revision) query.set('revision', revision);
+        const part = await readPart(asset, query);
+        signal?.throwIfAborted();
+        if (offset === 0) {
+          size = part.size; revision = part.revision; name = part.name || asset.name; mimeType = part.mimeType || asset.mimeType;
+          if (!validName(name)) fail('文件名无效，请修正来源文件的名称。');
+          if (!Number.isSafeInteger(size) || size < 1 || size > FILE_READ_LIMIT || !revision) fail('文件大小无效或超过 20 MiB 上限。');
+        }
+        if (part.size !== size || part.revision !== revision || part.offset !== offset
+          || !part.bytes?.length || part.bytes.length > Math.min(FILE_PART_BYTES, size - offset)) fail('文件内容发生变化或分片不完整。', 409);
+        let written = 0;
+        while (written < part.bytes.length) {
+          const { bytesWritten } = await handle.write(part.bytes, written, part.bytes.length - written, offset + written);
+          if (!bytesWritten) fail('电脑文件写入不完整。', 502);
+          written += bytesWritten;
+        }
+        offset += part.bytes.length;
+      } while (offset < size);
+      await handle.close(); handle = null;
+      signal?.throwIfAborted();
+      // Recheck the destination after the remote read, before creating the final copy.
+      const current = await this.folder(rpc, locations, selection);
+      if (pathKey(current.realPath) !== pathKey(folder.realPath)) fail('目标目录发生变化，请重新选择。', 409);
+      const extension = path.extname(name), body = name.slice(0, name.length - extension.length);
+      for (let number = 0; ; number++) {
+        const filename = number ? `${body} (${number})${extension}` : name;
+        const destination = path.join(folder.realPath, filename);
+        try {
+          await fs.copyFile(partial, destination, constants.COPYFILE_EXCL);
+          const stat = await fs.stat(destination);
+          if (stat.size !== size) { await fs.unlink(destination); fail('电脑副本大小核对失败。', 502); }
+          result = { path: destination, name: filename, size, revision: fileRevision(stat), mimeType };
+          break;
+        } catch (error) { if (error.code !== 'EEXIST') throw error; }
+      }
+      this.copies[asset.id] = result;
+      try { writeRecord(this.recordPath, this.copies); }
+      catch (error) { result.warning = '文件已保存，副本记录未能持久保存；重启后请从原文件重新选择。'; console.error('电脑副本记录保存失败', error); }
+      return result;
+    } finally {
+      await handle?.close();
+      if (created) {
+        try { await fs.rm(partial, { force: true }); }
+        catch (error) {
+          if (!result) throw error;
+          result.warning = '文件已保存，下载临时文件未能清理。'; console.error('电脑下载临时文件清理失败', error);
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.27",
+  "version": "0.1.0-beta.29",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {