@walkhi/code-relax 0.1.0-beta.30 → 0.1.0-beta.32

package/dist/src/hosted-history-app-server.mjs

@@ -1,103 +1,103 @@
-import { SharedAppServer } from './shared-app-server.mjs';
-import { historyCacheScope, completedHistory, turnMetadata } from './hosted-history-cache.mjs';
-
-// Hosted history uses a disk range cache; local kernel history retains its own storage.
-export class HostedHistoryAppServer extends SharedAppServer {
-  constructor(url, historyCache) {
-    super(url);
-    this.historyCache = historyCache;
-    this.historyHeadKey = 'latest';
-    this.diskHeads = new Map(); this.invalidatedTurns = new Set(); this.windowSaves = new Map();
-    this.historyVersions = new Map();
-    this.on('disconnected', () => { this.diskHeads.clear(); this.invalidatedTurns.clear(); this.historyVersions.clear(); });
-  }
-
-  historyScope(threadId) { return historyCacheScope(this.historyIdentity, this.historySource, threadId); }
-  historyVersion(threadId) { return `${this.epoch}:${this.historyVersions.get(threadId) || 0}`; }
-
-  async restoreHistoryHead(threadId) {
-    const scope = this.historyScope(threadId);
-    const result = await this.historyCache?.get(scope, this.historyHeadKey);
-    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-    return result;
-  }
-
-  saveHistoryWindow(threadId, immediate = false) {
-    const record = this.threads.get(threadId), scope = this.historyScope(threadId);
-    if (!this.historyCache || !scope || !record || record.hydrating || record.needsReload
-      || record.historyTrimmed || record.metadataOnly || record.readOnly || !completedHistory(record.thread.turns)) return;
-    const value = structuredClone({ updatedAt: record.thread.updatedAt, turns: record.thread.turns,
-      nextCursor: record.nextCursor, revision: record.thread.chatRevision,
-      ...(record.approvalBeforeMs !== undefined ? { approvalBeforeMs: record.approvalBeforeMs } : {}) });
-    const pending = this.windowSaves.get(scope);
-    if (pending) { clearTimeout(pending); this.windowSaves.delete(scope); }
-    const save = () => { this.windowSaves.delete(scope); return this.historyCache.put(scope, this.historyHeadKey, value); };
-    if (immediate) return save();
-    const timer = setTimeout(save, 200); timer.unref(); this.windowSaves.set(scope, timer);
-  }
-
-  invalidateHistory(method, params) {
-    const id = params.threadId || params.thread?.id, scope = this.historyScope(id);
-    if (!scope || !this.historyCache) return;
-    const turnId = params.turnId || params.turn?.id;
-    const whole = ['thread/deleted', 'thread/compacted'].includes(method);
-    if (!whole && (!turnId || !/^(?:item\/|turn\/)/.test(method))) return;
-    this.historyVersions.set(id, (this.historyVersions.get(id) || 0) + 1);
-    clearTimeout(this.windowSaves.get(scope)); this.windowSaves.delete(scope);
-    const key = `${scope}:${turnId}`;
-    if (whole || !this.invalidatedTurns.has(key)) {
-      this.invalidatedTurns.add(key); this.diskHeads.delete(id);
-      void this.historyCache.invalidate(scope, whole ? undefined : turnId);
-    }
-    if (whole) {
-      const record = this.threads.get(id);
-      if (record) record.needsReload = true;
-      this.emit('history-invalidated', id);
-    }
-    if (method === 'turn/completed') this.invalidatedTurns.delete(key);
-  }
-
-  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
-    const scope = this.historyScope(threadId), candidate = this.diskHeads.get(threadId);
-    const version = this.historyVersion(threadId);
-    if (cursor && !turn.status && this.historyCache) {
-      const final = await this.historyCache.get(scope, `turn:${turn.id}`);
-      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-      if (final) turn = { ...final.turns[0], ...turn };
-    }
-    const saved = !cursor && candidate?.head?.turns.find(value => value.id === turn.id);
-    if (scope && this.historyCache && saved && candidate.scope === scope && candidate.updatedAt != null
-      && candidate.head.updatedAt === candidate.updatedAt && completedHistory([saved])
-      && turnMetadata(saved) === turnMetadata(turn)) {
-      const result = { ...saved, ...turn, items: saved.items, itemPage: saved.itemPage };
-      apply?.(result); return result;
-    }
-    const result = await super.compactTurn(threadId, turn, cursor, apply, limit);
-    if (this.historyCache && scope === this.historyScope(threadId) && version === this.historyVersion(threadId)
-      && completedHistory([{ ...turn, items: [] }])) {
-      const { items, itemPage, ...metadata } = turn;
-      await this.historyCache.put(scope, `turn:${turn.id}`, { turns: [metadata] });
-    }
-    return result;
-  }
-
-  async history(threadId, cursor, options = {}) {
-    await this.connect();
-    let position;
-    try { position = JSON.parse(cursor); } catch { position = null; }
-    if (position?.threadId !== threadId) return super.history(threadId, cursor, options);
-    const scope = this.historyScope(threadId);
-    const version = this.historyVersion(threadId);
-    const key = JSON.stringify(['history', position.turnId, position.itemCursor, position.turnCursor, options.itemLimit ?? 100]);
-    const cached = await this.historyCache?.get(scope, key);
-    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-    if (cached && version === this.historyVersion(threadId)) return { thread: { id: threadId, turns: cached.turns },
-      nextCursor: cached.position ? JSON.stringify(cached.position) : null };
-    const result = await super.history(threadId, cursor, options);
-    if (scope === this.historyScope(threadId) && version === this.historyVersion(threadId) && completedHistory(result.thread.turns)) {
-      const next = result.nextCursor ? JSON.parse(result.nextCursor) : null;
-      await this.historyCache?.put(scope, key, { turns: result.thread.turns, position: next });
-    }
-    return result;
-  }
-}
+import { SharedAppServer } from './shared-app-server.mjs';
+import { historyCacheScope, completedHistory, turnMetadata } from './hosted-history-cache.mjs';
+
+// Hosted history uses a disk range cache; local kernel history retains its own storage.
+export class HostedHistoryAppServer extends SharedAppServer {
+  constructor(url, historyCache) {
+    super(url);
+    this.historyCache = historyCache;
+    this.historyHeadKey = 'latest';
+    this.diskHeads = new Map(); this.invalidatedTurns = new Set(); this.windowSaves = new Map();
+    this.historyVersions = new Map();
+    this.on('disconnected', () => { this.diskHeads.clear(); this.invalidatedTurns.clear(); this.historyVersions.clear(); });
+  }
+
+  historyScope(threadId) { return historyCacheScope(this.historyIdentity, this.historySource, threadId); }
+  historyVersion(threadId) { return `${this.epoch}:${this.historyVersions.get(threadId) || 0}`; }
+
+  async restoreHistoryHead(threadId) {
+    const scope = this.historyScope(threadId);
+    const result = await this.historyCache?.get(scope, this.historyHeadKey);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    return result;
+  }
+
+  saveHistoryWindow(threadId, immediate = false) {
+    const record = this.threads.get(threadId), scope = this.historyScope(threadId);
+    if (!this.historyCache || !scope || !record || record.hydrating || record.needsReload
+      || record.historyTrimmed || record.metadataOnly || record.readOnly || !completedHistory(record.thread.turns)) return;
+    const value = structuredClone({ updatedAt: record.thread.updatedAt, turns: record.thread.turns,
+      nextCursor: record.nextCursor, revision: record.thread.chatRevision,
+      ...(record.approvalBeforeMs !== undefined ? { approvalBeforeMs: record.approvalBeforeMs } : {}) });
+    const pending = this.windowSaves.get(scope);
+    if (pending) { clearTimeout(pending); this.windowSaves.delete(scope); }
+    const save = () => { this.windowSaves.delete(scope); return this.historyCache.put(scope, this.historyHeadKey, value); };
+    if (immediate) return save();
+    const timer = setTimeout(save, 200); timer.unref(); this.windowSaves.set(scope, timer);
+  }
+
+  invalidateHistory(method, params) {
+    const id = params.threadId || params.thread?.id, scope = this.historyScope(id);
+    if (!scope || !this.historyCache) return;
+    const turnId = params.turnId || params.turn?.id;
+    const whole = ['thread/deleted', 'thread/compacted'].includes(method);
+    if (!whole && (!turnId || !/^(?:item\/|turn\/)/.test(method))) return;
+    this.historyVersions.set(id, (this.historyVersions.get(id) || 0) + 1);
+    clearTimeout(this.windowSaves.get(scope)); this.windowSaves.delete(scope);
+    const key = `${scope}:${turnId}`;
+    if (whole || !this.invalidatedTurns.has(key)) {
+      this.invalidatedTurns.add(key); this.diskHeads.delete(id);
+      void this.historyCache.invalidate(scope, whole ? undefined : turnId);
+    }
+    if (whole) {
+      const record = this.threads.get(id);
+      if (record) record.needsReload = true;
+      this.emit('history-invalidated', id);
+    }
+    if (method === 'turn/completed') this.invalidatedTurns.delete(key);
+  }
+
+  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
+    const scope = this.historyScope(threadId), candidate = this.diskHeads.get(threadId);
+    const version = this.historyVersion(threadId);
+    if (cursor && !turn.status && this.historyCache) {
+      const final = await this.historyCache.get(scope, `turn:${turn.id}`);
+      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+      if (final) turn = { ...final.turns[0], ...turn };
+    }
+    const saved = !cursor && candidate?.head?.turns.find(value => value.id === turn.id);
+    if (scope && this.historyCache && saved && candidate.scope === scope && candidate.updatedAt != null
+      && candidate.head.updatedAt === candidate.updatedAt && completedHistory([saved])
+      && turnMetadata(saved) === turnMetadata(turn)) {
+      const result = { ...saved, ...turn, items: saved.items, itemPage: saved.itemPage };
+      apply?.(result); return result;
+    }
+    const result = await super.compactTurn(threadId, turn, cursor, apply, limit);
+    if (this.historyCache && scope === this.historyScope(threadId) && version === this.historyVersion(threadId)
+      && completedHistory([{ ...turn, items: [] }])) {
+      const { items, itemPage, ...metadata } = turn;
+      await this.historyCache.put(scope, `turn:${turn.id}`, { turns: [metadata] });
+    }
+    return result;
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect();
+    let position;
+    try { position = JSON.parse(cursor); } catch { position = null; }
+    if (position?.threadId !== threadId) return super.history(threadId, cursor, options);
+    const scope = this.historyScope(threadId);
+    const version = this.historyVersion(threadId);
+    const key = JSON.stringify(['history', position.turnId, position.itemCursor, position.turnCursor, options.itemLimit ?? 100]);
+    const cached = await this.historyCache?.get(scope, key);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    if (cached && version === this.historyVersion(threadId)) return { thread: { id: threadId, turns: cached.turns },
+      nextCursor: cached.position ? JSON.stringify(cached.position) : null };
+    const result = await super.history(threadId, cursor, options);
+    if (scope === this.historyScope(threadId) && version === this.historyVersion(threadId) && completedHistory(result.thread.turns)) {
+      const next = result.nextCursor ? JSON.parse(result.nextCursor) : null;
+      await this.historyCache?.put(scope, key, { turns: result.thread.turns, position: next });
+    }
+    return result;
+  }
+}

package/dist/src/hosted-history-cache.mjs

@@ -1,113 +1,113 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { createHash } from 'node:crypto';
-
-const threadBudget = 8 * 1024 * 1024;
-const totalBudget = 128 * 1024 * 1024;
-const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
-
-// Store confirmed ranges, not connection tokens, execution context or image bytes.
-export function historyCacheScope(identity, source, threadId) {
-  return identity?.accountId && threadId ? digest([identity.accountId, identity.userId || '', source, threadId]) : null;
-}
-
-export function completedHistory(turns) {
-  if (!turns?.length || turns.some(turn => !['completed', 'failed', 'interrupted'].includes(turn.status)
-    || turn.cacheStub || turn.items?.some(item => item.dotsStreaming
-      || item.type === 'imageGeneration' && !item.savedPath && item.result))) return false;
-  // Signed media addresses and embedded bytes must be reread/refreshed, not replayed from disk.
-  const media = value => value && typeof value === 'object' && Object.entries(value).some(([key, part]) =>
-    typeof part === 'string' && (/^data:/.test(part) || /[?&](?:X-Amz-|X-Goog-|signature=|sig=|token=)/i.test(part))
-    || key === 'imageBytes' || media(part));
-  return !media(turns);
-}
-
-export function turnMetadata(turn) {
-  return digest(Object.entries(turn || {}).filter(([key]) => !['items', 'itemPage', 'cacheStub'].includes(key))
-    .sort(([a], [b]) => a.localeCompare(b)));
-}
-
-export class HostedHistoryCache {
-  constructor(stateRoot, { report = error => console.error(`托管历史缓存失败：${error.message}`), maxThreadBytes = threadBudget, maxTotalBytes = totalBudget } = {}) {
-    this.directory = path.join(stateRoot, 'hosted-history');
-    this.report = report; this.maxThreadBytes = maxThreadBytes; this.maxTotalBytes = maxTotalBytes;
-    this.tail = Promise.resolve();
-  }
-
-  async record(scope) {
-    try {
-      const record = JSON.parse(await fs.readFile(path.join(this.directory, `${scope}.json`), 'utf8'));
-      if (record.version !== 1 || !record.entries || Array.isArray(record.entries) || typeof record.entries !== 'object') {
-        throw new Error('历史缓存结构无效，需重新读取云端历史。');
-      }
-      if (Object.values(record.entries).some(entry => !Number.isFinite(entry.at) || !entry.value
-        || !Array.isArray(entry.value.turns) && !Array.isArray(entry.value.data))) {
-        throw new Error('历史缓存页结构无效，需重新读取云端历史。');
-      }
-      return record;
-    } catch (error) { if (error.code !== 'ENOENT') this.report(error); return { version: 1, entries: {} }; }
-  }
-
-  run(operation, fallback) {
-    const work = this.tail.then(operation).catch(error => { this.report(error); return fallback; });
-    this.tail = work.then(() => {}); return work;
-  }
-
-  get(scope, key) {
-    if (!scope) return Promise.resolve(null);
-    return this.run(async () => (await this.record(scope)).entries?.[key]?.value ?? null, null);
-  }
-
-  put(scope, key, value) {
-    if (!scope) return Promise.resolve();
-    // Freeze before queuing; live events may mutate the source window during disk I/O.
-    const snapshot = structuredClone(value);
-    return this.run(async () => {
-      const record = await this.record(scope);
-      record.entries ||= {};
-      record.entries[key] = { at: Date.now(), value: snapshot };
-      let text = JSON.stringify(record);
-      for (const [oldKey] of Object.entries(record.entries).sort((a, b) => a[1].at - b[1].at)) {
-        if (Buffer.byteLength(text) <= this.maxThreadBytes) break;
-        delete record.entries[oldKey]; text = JSON.stringify(record);
-      }
-      await this.write(scope, text);
-      await this.prune(scope);
-    });
-  }
-
-  invalidate(scope, turnId) {
-    if (!scope) return Promise.resolve();
-    return this.run(async () => {
-      const record = await this.record(scope);
-      for (const [key, entry] of Object.entries(record.entries || {})) {
-        if (!turnId || entry.value.turnIds?.includes(turnId) || entry.value.turns?.some(turn => turn.id === turnId)
-          || entry.value.thread?.turns?.some(turn => turn.id === turnId)) delete record.entries[key];
-      }
-      await this.write(scope, JSON.stringify(record));
-    });
-  }
-
-  async write(scope, text) {
-    if (!/^[a-f0-9]{64}$/.test(scope)) throw new Error('历史缓存身份无效');
-    await fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
-    const file = path.join(this.directory, `${scope}.json`), temporary = `${file}.tmp`;
-    try {
-      await fs.writeFile(temporary, text, { mode: 0o600 });
-      await fs.rename(temporary, file);
-    } finally {
-      try { await fs.unlink(temporary); } catch (error) { if (error.code !== 'ENOENT') this.report(error); }
-    }
-  }
-
-  async prune(current) {
-    const files = await Promise.all((await fs.readdir(this.directory)).filter(name => /^[a-f0-9]{64}\.json$/.test(name))
-      .map(async name => ({ name, ...await fs.stat(path.join(this.directory, name)) })));
-    let bytes = files.reduce((sum, file) => sum + file.size, 0);
-    for (const file of files.sort((a, b) => a.mtimeMs - b.mtimeMs)) {
-      if (bytes <= this.maxTotalBytes) break;
-      if (file.name === `${current}.json`) continue;
-      await fs.unlink(path.join(this.directory, file.name)); bytes -= file.size;
-    }
-  }
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+const threadBudget = 8 * 1024 * 1024;
+const totalBudget = 128 * 1024 * 1024;
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+
+// Store confirmed ranges, not connection tokens, execution context or image bytes.
+export function historyCacheScope(identity, source, threadId) {
+  return identity?.accountId && threadId ? digest([identity.accountId, identity.userId || '', source, threadId]) : null;
+}
+
+export function completedHistory(turns) {
+  if (!turns?.length || turns.some(turn => !['completed', 'failed', 'interrupted'].includes(turn.status)
+    || turn.cacheStub || turn.items?.some(item => item.dotsStreaming
+      || item.type === 'imageGeneration' && !item.savedPath && item.result))) return false;
+  // Signed media addresses and embedded bytes must be reread/refreshed, not replayed from disk.
+  const media = value => value && typeof value === 'object' && Object.entries(value).some(([key, part]) =>
+    typeof part === 'string' && (/^data:/.test(part) || /[?&](?:X-Amz-|X-Goog-|signature=|sig=|token=)/i.test(part))
+    || key === 'imageBytes' || media(part));
+  return !media(turns);
+}
+
+export function turnMetadata(turn) {
+  return digest(Object.entries(turn || {}).filter(([key]) => !['items', 'itemPage', 'cacheStub'].includes(key))
+    .sort(([a], [b]) => a.localeCompare(b)));
+}
+
+export class HostedHistoryCache {
+  constructor(stateRoot, { report = error => console.error(`托管历史缓存失败：${error.message}`), maxThreadBytes = threadBudget, maxTotalBytes = totalBudget } = {}) {
+    this.directory = path.join(stateRoot, 'hosted-history');
+    this.report = report; this.maxThreadBytes = maxThreadBytes; this.maxTotalBytes = maxTotalBytes;
+    this.tail = Promise.resolve();
+  }
+
+  async record(scope) {
+    try {
+      const record = JSON.parse(await fs.readFile(path.join(this.directory, `${scope}.json`), 'utf8'));
+      if (record.version !== 1 || !record.entries || Array.isArray(record.entries) || typeof record.entries !== 'object') {
+        throw new Error('历史缓存结构无效，需重新读取云端历史。');
+      }
+      if (Object.values(record.entries).some(entry => !Number.isFinite(entry.at) || !entry.value
+        || !Array.isArray(entry.value.turns) && !Array.isArray(entry.value.data))) {
+        throw new Error('历史缓存页结构无效，需重新读取云端历史。');
+      }
+      return record;
+    } catch (error) { if (error.code !== 'ENOENT') this.report(error); return { version: 1, entries: {} }; }
+  }
+
+  run(operation, fallback) {
+    const work = this.tail.then(operation).catch(error => { this.report(error); return fallback; });
+    this.tail = work.then(() => {}); return work;
+  }
+
+  get(scope, key) {
+    if (!scope) return Promise.resolve(null);
+    return this.run(async () => (await this.record(scope)).entries?.[key]?.value ?? null, null);
+  }
+
+  put(scope, key, value) {
+    if (!scope) return Promise.resolve();
+    // Freeze before queuing; live events may mutate the source window during disk I/O.
+    const snapshot = structuredClone(value);
+    return this.run(async () => {
+      const record = await this.record(scope);
+      record.entries ||= {};
+      record.entries[key] = { at: Date.now(), value: snapshot };
+      let text = JSON.stringify(record);
+      for (const [oldKey] of Object.entries(record.entries).sort((a, b) => a[1].at - b[1].at)) {
+        if (Buffer.byteLength(text) <= this.maxThreadBytes) break;
+        delete record.entries[oldKey]; text = JSON.stringify(record);
+      }
+      await this.write(scope, text);
+      await this.prune(scope);
+    });
+  }
+
+  invalidate(scope, turnId) {
+    if (!scope) return Promise.resolve();
+    return this.run(async () => {
+      const record = await this.record(scope);
+      for (const [key, entry] of Object.entries(record.entries || {})) {
+        if (!turnId || entry.value.turnIds?.includes(turnId) || entry.value.turns?.some(turn => turn.id === turnId)
+          || entry.value.thread?.turns?.some(turn => turn.id === turnId)) delete record.entries[key];
+      }
+      await this.write(scope, JSON.stringify(record));
+    });
+  }
+
+  async write(scope, text) {
+    if (!/^[a-f0-9]{64}$/.test(scope)) throw new Error('历史缓存身份无效');
+    await fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
+    const file = path.join(this.directory, `${scope}.json`), temporary = `${file}.tmp`;
+    try {
+      await fs.writeFile(temporary, text, { mode: 0o600 });
+      await fs.rename(temporary, file);
+    } finally {
+      try { await fs.unlink(temporary); } catch (error) { if (error.code !== 'ENOENT') this.report(error); }
+    }
+  }
+
+  async prune(current) {
+    const files = await Promise.all((await fs.readdir(this.directory)).filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+      .map(async name => ({ name, ...await fs.stat(path.join(this.directory, name)) })));
+    let bytes = files.reduce((sum, file) => sum + file.size, 0);
+    for (const file of files.sort((a, b) => a.mtimeMs - b.mtimeMs)) {
+      if (bytes <= this.maxTotalBytes) break;
+      if (file.name === `${current}.json`) continue;
+      await fs.unlink(path.join(this.directory, file.name)); bytes -= file.size;
+    }
+  }
+}