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

package/dist/web/history-cache.js

@@ -3,6 +3,9 @@
   const limit = 100 * 1024 * 1024;
   let opening, writes = Promise.resolve(), displayVersion = 0;
   const urls = new Map();
+  function metric(detail) {
+    try { window.codexNative?.reportSyncMetric?.(detail); } catch {}
+  }
   function database() {
     if (!opening) opening = new Promise((resolve, reject) => {
       const request = indexedDB.open('codex-remote-history-v1', 1);
@@ -22,11 +25,76 @@
       request.onerror = () => reject(request.error);
     });
   }
-  function release() { displayVersion++; for (const url of urls.values()) URL.revokeObjectURL(url); urls.clear(); }
+  function release() {
+    displayVersion++;
+    const released = urls.size;
+    for (const url of urls.values()) URL.revokeObjectURL(url);
+    urls.clear();
+    metric(`stage=image-cache;action=release-all;released=${released};version=${displayVersion}`);
+  }
+  function releaseUnused(value, reason = 'sync') {
+    const retained = new Set();
+    function collect(child) {
+      if (typeof child === 'string') { retained.add(child); return; }
+      if (Array.isArray(child)) { for (const item of child) collect(item); return; }
+      if (!child || typeof child !== 'object') return;
+      for (const item of Object.values(child)) collect(item);
+    }
+    collect(value);
+    let released = 0;
+    for (const [key, url] of urls) {
+      if (retained.has(url)) continue;
+      URL.revokeObjectURL(url); urls.delete(key); released++;
+    }
+    metric(`stage=image-cache;action=release-unused;reason=${reason};released=${released};retained=${urls.size}`);
+  }
+  function compactActivity(entry) {
+    if (!entry || entry.type !== 'activity') return entry;
+    if (entry.titleOnly || ['imageGeneration', 'imageView', 'lazyOperationGroup'].includes(entry.kind)) return entry;
+    return { type: 'activity', id: entry.id, kind: entry.kind, title: entry.title,
+      ...(entry.kind === 'reasoning' && entry.detail ? { detail: entry.detail } : {}),
+      ...(entry.kind === 'webSearch' ? { query: entry.query || '', ...(entry.action ? { action: entry.action } : {}) } : {}),
+      ...(entry.status ? { status: entry.status } : {}) };
+  }
+  function compactTimeline(data) {
+    if (!data || !Array.isArray(data.turns)) return data;
+    return { ...data, turns: data.turns.map(turn => {
+      const entries = Array.isArray(turn.entries) ? turn.entries : [];
+      const activities = entries.filter(entry => entry?.type === 'activity' && !entry.titleOnly);
+      const details = Array.isArray(turn.toolDetails) ? turn.toolDetails : [];
+      const byId = new Map(details.map((entry, index) => [entry?.id || `detail:${index}`, entry]));
+      for (const [index, entry] of activities.entries()) {
+        const key = entry?.id || `activity:${index}`;
+        if (!byId.has(key)) byId.set(key, entry);
+      }
+      return { ...turn, entries: entries.map((entry, index) => {
+        const compact = compactActivity(entry);
+        if (compact?.kind !== 'webSearch' || compact.query || compact.action) return compact;
+        return compactActivity(byId.get(entry?.id || `activity:${index}`) || entry);
+      }),
+        ...(byId.size ? { toolDetails: [...byId.values()] } : {}) };
+    }) };
+  }
+  function preserveToolDetails(data, previous) {
+    if (!data || !Array.isArray(data.turns) || !previous || !Array.isArray(previous.turns)) return data;
+    const previousTurns = new Map(compactTimeline(previous).turns.map(turn => [turn.id, turn]));
+    return { ...data, turns: data.turns.map(turn => {
+      const cached = previousTurns.get(turn.id)?.toolDetails || [];
+      if (!cached.length) return turn;
+      const current = Array.isArray(turn.toolDetails) ? turn.toolDetails : [];
+      const byId = new Map(cached.map((entry, index) => [entry?.id || `cached:${index}`, entry]));
+      for (const [index, entry] of current.entries()) {
+        const key = entry?.id || `current:${index}`;
+        if (!byId.has(key)) byId.set(key, entry);
+      }
+      return { ...turn, toolDetails: [...byId.values()] };
+    }) };
+  }
   async function get(scope, id) {
     const version = displayVersion;
     const db = await database(), record = await read(db, 'threads', JSON.stringify([scope, id]));
     if (!record) return null;
+    let created = 0, stale = 0;
     async function unpack(value) {
       if (version !== displayVersion) return null;
       if (value && typeof value === 'object' && value.cacheImage) {
@@ -36,30 +104,48 @@
           if (version !== displayVersion) return null;
           if (!image) throw new Error('缓存图片缺失');
           urls.set(key, URL.createObjectURL(image.blob));
+          created++;
         }
         return urls.get(key);
       }
+      // A persisted blob URL only belongs to the WebView document that created
+      // it. Treat older poisoned cache entries as missing so remotePath can
+      // reload the image instead of rendering a permanently broken URL.
+      if (typeof value === 'string' && value.startsWith('blob:')) { stale++; return ''; }
       if (Array.isArray(value)) { const result = []; for (const item of value) result.push(await unpack(item)); return result; }
       if (value && typeof value === 'object') { const result = {}; for (const [k, v] of Object.entries(value)) result[k] = await unpack(v); return result; }
       return value;
     }
-    const data = await unpack(record.data);
-    return version === displayVersion ? { ...data, cached: true, nextCursor: null } : null;
+    const data = compactTimeline(await unpack(record.data));
+    metric(`stage=image-cache;action=read;created=${created};stale=${stale};active=${urls.size}`);
+    return version === displayVersion ? { ...data, cached: true } : null;
   }
   function save(scope, data, hash, id = data.thread.id) {
     // Snapshot at scheduling time; live events may mutate the UI model while hashing.
-    const snapshot = structuredClone({ ...data, turns: data.turns.slice(-40) });
+    let snapshot = structuredClone(compactTimeline({ ...data, turns: data.turns.slice(-40) }));
     const key = JSON.stringify([scope, id]);
     const work = writes.then(async () => {
+      let outcome = { retained: true, evictedThreads: 0, size: 0 };
       const db = await database(), images = new Map(), byUrl = new Map(), referenced = new Set(), previousImages = new Map();
+      const objectUrlKeys = new Map([...urls].map(([imageKey, url]) => [url, imageKey]));
       const previous = await read(db, 'threads', key);
+      snapshot = preserveToolDetails(snapshot, previous?.data);
       function collect(value) {
         if (!value || typeof value !== 'object') return;
-        if (value.remotePath && value.url?.cacheImage) previousImages.set(value.remotePath, value.url.cacheImage);
+        if (value.remotePath && (value.url?.cacheImage || value.thumbnailUrl?.cacheImage)) {
+          previousImages.set(value.remotePath, {
+            original: value.url?.cacheImage || '', thumbnail: value.thumbnailUrl?.cacheImage || '',
+          });
+        }
         for (const child of Object.values(value)) collect(child);
       }
       collect(previous?.data);
       async function pack(value) {
+        if (value && typeof value === 'object' && value.cacheImage) { referenced.add(value.cacheImage); return value; }
+        if (typeof value === 'string' && objectUrlKeys.has(value)) {
+          const imageKey = objectUrlKeys.get(value); referenced.add(imageKey); return { cacheImage: imageKey };
+        }
+        if (typeof value === 'string' && value.startsWith('blob:')) return '';
         if (typeof value === 'string' && value.startsWith('data:image/')) {
           if (!byUrl.has(value)) byUrl.set(value, (async () => {
             const key = JSON.stringify([scope, await hash(value)]);
@@ -73,16 +159,19 @@
         }
         if (Array.isArray(value)) return Promise.all(value.map(pack));
         if (value && typeof value === 'object') {
-          if (value.remotePath && !value.url && previousImages.has(value.remotePath)) {
-            const key = previousImages.get(value.remotePath); referenced.add(key);
-            return { ...value, available: true, url: { cacheImage: key }, thumbnailUrl: { cacheImage: key } };
+          let source = value;
+          if (value.remotePath && previousImages.has(value.remotePath)) {
+            const cached = previousImages.get(value.remotePath);
+            if (!value.url && cached.original) { referenced.add(cached.original); source = { ...source, available: true, url: { cacheImage: cached.original } }; }
+            if (!value.thumbnailUrl && cached.thumbnail) { referenced.add(cached.thumbnail); source = { ...source, available: true, thumbnailUrl: { cacheImage: cached.thumbnail } }; }
           }
-          return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([k, v]) => [k, await pack(v)])));
+          return Object.fromEntries(await Promise.all(Object.entries(source).map(async ([k, v]) => [k, await pack(v)])));
         }
         return value;
       }
       const packed = await pack(snapshot);
       const record = { key, data: packed, at: Date.now(), imageKeys: [...referenced], size: new TextEncoder().encode(JSON.stringify(packed)).length };
+      outcome.size = record.size;
       await new Promise((resolve, reject) => {
         const tx = db.transaction(['threads', 'images', 'blobs'], 'readwrite');
         tx.oncomplete = resolve; tx.onerror = () => reject(tx.error); tx.onabort = () => reject(tx.error || new Error('缓存写入中止'));
@@ -90,30 +179,35 @@
         threads.put(record);
         for (const image of images.values()) { metadata.put({ key: image.key, size: image.size }); blobs.put({ key: image.key, blob: image.blob }); }
         const allThreads = threads.getAll(), allImages = metadata.getAll();
-        let records, sizes;
+        let records, sizes, pruned = false;
         function prune() {
-          if (!records || !sizes) return;
+          if (!records || !sizes || pruned) return;
+          pruned = true;
           records.sort((a, b) => b.at - a.at);
-          const keep = new Set(); let bytes = 0;
+          const keep = new Set(), keptThreads = new Set(); let bytes = 0;
           for (const [index, item] of records.entries()) {
-            const added = item.size + item.imageKeys.reduce((sum, image) => sum + (keep.has(image) ? 0 : sizes.get(image) || 0), 0);
-            if (index >= 20 || bytes + added > limit) { threads.delete(item.key); continue; }
-            bytes += added; for (const image of item.imageKeys) keep.add(image);
+            const imageKeys = item.imageKeys || [];
+            const added = item.size + imageKeys.reduce((sum, image) => sum + (keep.has(image) ? 0 : sizes.get(image) || 0), 0);
+            if (index >= 20 || bytes + added > limit) { threads.delete(item.key); outcome.evictedThreads++; continue; }
+            keptThreads.add(item.key); bytes += added; for (const image of imageKeys) keep.add(image);
           }
+          outcome.retained = keptThreads.has(key);
           for (const image of sizes.keys()) if (!keep.has(image)) { metadata.delete(image); blobs.delete(image); }
         }
         allThreads.onsuccess = () => { records = allThreads.result; prune(); };
         allImages.onsuccess = () => { sizes = new Map(allImages.result.map(image => [image.key, image.size])); prune(); };
       });
+      return outcome;
     });
     writes = work.catch(() => {});
     return work;
   }
-  async function getImage(scope, id, path) {
+  async function getImage(scope, id, path, variant = 'original') {
     const db = await database(), record = await read(db, 'threads', JSON.stringify([scope, id]));
     function find(value) {
       if (!value || typeof value !== 'object') return null;
-      if (value.remotePath === path && value.url?.cacheImage) return value.url.cacheImage;
+      const source = variant === 'thumbnail' ? value.thumbnailUrl : value.url;
+      if (value.remotePath === path && source?.cacheImage) return source.cacheImage;
       for (const child of Object.values(value)) { const key = find(child); if (key) return key; }
       return null;
     }
@@ -142,5 +236,5 @@
     const record = records.filter(item => JSON.parse(item.key)[0] === scope).sort((a, b) => b.at - a.at)[0];
     return record ? get(scope, JSON.parse(record.key)[1]) : null;
   }
-  window.codexHistoryCache = { get, getImage, save, latest, clear, release };
+  window.codexHistoryCache = { get, getImage, save, latest, clear, release, releaseUnused };
 })();

package/dist/web/history-controller.js

@@ -0,0 +1,167 @@
+(function (root, factory) {
+  const create = factory(root);
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createHistoryController = create;
+})(globalThis, function (root) {
+  function createHistoryController(options) {
+    const { state, transport, api, isThreadRunning, report, onCacheError } = options;
+    let saveTimer, readVersion = 0, writeVersion = 0;
+
+    function updateCache(patch) {
+      state.historyCache = { ...state.historyCache, ...patch, changedAt: Date.now() };
+    }
+
+    function metric(action, fields) {
+      report(`stage=cache;action=${action};${Object.entries(fields).map(([key, value]) => `${key}=${value}`).join(';')}`);
+    }
+
+    async function read(id, thread, reason = 'select') {
+      const version = ++readVersion;
+      const started = performance.now();
+      if (!transport.has('historyCache')) {
+        updateCache({ threadId: id, read: 'unavailable', readMs: 0, turns: 0, error: '' });
+        metric('read', { reason, result: 'unavailable', ms: 0, turns: 0 });
+        return null;
+      }
+      updateCache({ threadId: id, read: 'loading', readMs: 0, turns: 0, error: '' });
+      try {
+        const cached = await transport.readCached(id, thread);
+        const ms = Math.round(performance.now() - started), turns = cached?.turns?.length || 0;
+        if (version === readVersion) updateCache({ threadId: id, read: cached ? 'hit' : 'miss', readMs: ms, turns, error: '' });
+        metric('read', { reason, result: cached ? 'hit' : 'miss', ms, turns });
+        return cached || null;
+      } catch (error) {
+        const ms = Math.round(performance.now() - started);
+        if (version === readVersion) updateCache({ threadId: id, read: 'error', readMs: ms, turns: 0, error: error.message });
+        metric('read', { reason, result: 'error', ms, turns: 0 });
+        onCacheError(error);
+        return null;
+      }
+    }
+
+    async function readLatest(reason = 'startup') {
+      const version = ++readVersion;
+      const started = performance.now();
+      if (!transport.has('historyCache')) {
+        updateCache({ threadId: '', read: 'unavailable', readMs: 0, turns: 0, error: '' });
+        metric('read', { reason, result: 'unavailable', ms: 0, turns: 0 });
+        return null;
+      }
+      updateCache({ threadId: '', read: 'loading', readMs: 0, turns: 0, error: '' });
+      try {
+        const cached = await transport.readLastCached();
+        const ms = Math.round(performance.now() - started), turns = cached?.turns?.length || 0;
+        if (version === readVersion) updateCache({ threadId: cached?.thread?.id || '', read: cached ? 'hit' : 'miss', readMs: ms, turns, error: '' });
+        metric('read', { reason, result: cached ? 'hit' : 'miss', ms, turns });
+        return cached || null;
+      } catch (error) {
+        const ms = Math.round(performance.now() - started);
+        if (version === readVersion) updateCache({ threadId: '', read: 'error', readMs: ms, turns: 0, error: error.message });
+        metric('read', { reason, result: 'error', ms, turns: 0 });
+        onCacheError(error);
+        return null;
+      }
+    }
+
+    function cancelSave() {
+      clearTimeout(saveTimer);
+      saveTimer = undefined;
+    }
+
+    async function saveNow(timeline, thread, reason = 'sync') {
+      if (!transport.has('historyCache') || !timeline || timeline.cached || !thread) return false;
+      const version = ++writeVersion;
+      const started = performance.now();
+      updateCache({ threadId: thread.id, write: 'writing', writeMs: 0, error: '' });
+      try {
+        const outcome = await transport.saveCached({ ...timeline, thread });
+        const ms = Math.round(performance.now() - started);
+        if (version === writeVersion) updateCache({ threadId: thread.id, write: 'saved', writeMs: ms,
+          retained: outcome?.retained !== false, evicted: Number(outcome?.evictedThreads) || 0, error: '' });
+        metric('write', { reason, result: 'saved', ms, retained: outcome?.retained === false ? 0 : 1,
+          evicted: Number(outcome?.evictedThreads) || 0 });
+        return true;
+      } catch (error) {
+        const ms = Math.round(performance.now() - started);
+        if (version === writeVersion) updateCache({ threadId: thread.id, write: 'error', writeMs: ms, error: error.message });
+        metric('write', { reason, result: 'error', ms, retained: 0, evicted: 0 });
+        onCacheError(error);
+        return false;
+      }
+    }
+
+    function scheduleSave(timeline, thread, historyLoading) {
+      if (!transport.has('historyCache') || !timeline || timeline.cached || historyLoading || !thread) return;
+      cancelSave();
+      const snapshot = { ...timeline, thread };
+      saveTimer = setTimeout(() => {
+        saveTimer = undefined;
+        void saveNow(snapshot, thread, 'settled');
+      }, 500);
+    }
+
+    function release() {
+      root.codexHistoryCache?.release();
+    }
+
+    function releaseUnused(timeline, reason) {
+      root.codexHistoryCache?.releaseUnused?.(timeline, reason);
+    }
+
+    async function recover(id, previous, isCurrent, hostId = '') {
+      const previousTurns = previous?.thread?.id === id && Array.isArray(previous.turns) ? previous.turns : [];
+      const listed = state.threads.find(thread => thread.id === id);
+      const previousUpdatedAt = Number(previous?.thread?.updatedAt) || 0;
+      const latestCached = previousTurns.at(-1);
+      const listConfirmsCache = transport.has('incrementalEvents') && transport.transportMode() !== 'relay'
+        && listed && !isThreadRunning(listed) && Number(listed.updatedAt) > 0
+        && Number(listed.updatedAt) === previousUpdatedAt
+        && latestCached?.id && latestCached.status !== 'inProgress';
+      if (listConfirmsCache) {
+        return { timeline: { ...previous, thread: { ...previous.thread, ...listed }, cached: false },
+          unchanged: true, partial: false, listTrusted: true };
+      }
+      const query = new URLSearchParams({ turnLimit: '10' });
+      if (hostId) query.set('hostId', hostId);
+      const previousLatest = previousTurns.at(-1);
+      if (previousLatest?.id) {
+        if (previousUpdatedAt > 0) query.set('knownUpdatedAt', previousUpdatedAt.toString());
+        query.set('knownTurnId', previousLatest.id);
+        if (previousLatest.status) query.set('knownTurnStatus', previousLatest.status);
+        if (previous.historyView) query.set('knownHistoryView', previous.historyView);
+      }
+      const data = await api(`/api/threads/${encodeURIComponent(id)}/timeline?${query}`);
+      if (!isCurrent()) return null;
+      if (data.notModified === true) {
+        const { notModified, ...fresh } = data;
+        return { timeline: { ...previous, ...fresh, thread: { ...previous.thread, ...data.thread },
+          turns: previousTurns, nextCursor: previous.nextCursor, cached: false }, unchanged: true };
+      }
+      let partial = false;
+      if (data.partialFromTurnId) {
+        const start = previousTurns.findIndex(turn => turn.id === data.partialFromTurnId);
+        if (start >= 0) {
+          data.turns = [...previousTurns.slice(0, start), ...data.turns];
+          if (Object.prototype.hasOwnProperty.call(previous, 'nextCursor')) data.nextCursor = previous.nextCursor;
+          partial = true;
+        }
+        delete data.partialFromTurnId;
+      }
+      const freshIds = new Set(data.turns.map(turn => turn.id));
+      const firstOverlap = previousTurns.findIndex(turn => freshIds.has(turn.id));
+      if (firstOverlap >= 0) {
+        data.turns.unshift(...previousTurns.slice(0, firstOverlap).filter(turn => !freshIds.has(turn.id)));
+        if (Object.prototype.hasOwnProperty.call(previous, 'nextCursor')) data.nextCursor = previous.nextCursor;
+        if (previous.historyGapBeforeTurnId) data.historyGapBeforeTurnId = previous.historyGapBeforeTurnId;
+      } else if (previousTurns.length && data.turns.length && data.nextCursor) {
+        data.turns = [...previousTurns, ...data.turns];
+        data.historyGapBeforeTurnId = data.turns[previousTurns.length]?.id || '';
+      }
+      return { timeline: data, unchanged: false, partial };
+    }
+
+    return Object.freeze({ read, readLatest, saveNow, scheduleSave, cancelSave, release, releaseUnused, recover });
+  }
+
+  return createHistoryController;
+});