@walkhi/code-relax 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/web/history-cache.js

@@ -1,240 +0,0 @@
-/* Device-local display cache. Never supplies execution state or credentials. */
-(() => {
-  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);
-      request.onupgradeneeded = () => {
-        for (const name of ['threads', 'images', 'blobs']) request.result.createObjectStore(name, { keyPath: 'key' });
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-      request.onblocked = () => reject(new Error('缓存数据库正在被旧页面占用'));
-    });
-    return opening;
-  }
-  function read(db, store, key) {
-    return new Promise((resolve, reject) => {
-      const request = db.transaction(store).objectStore(store).get(key);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
-  }
-  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) {
-        const key = value.cacheImage;
-        if (!urls.has(key)) {
-          const image = await read(db, 'blobs', key);
-          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 = 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.
-    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 || 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)]);
-            referenced.add(key);
-            const comma = value.indexOf(','), mime = value.slice(5, value.indexOf(';'));
-            const bytes = Uint8Array.from(atob(value.slice(comma + 1)), c => c.charCodeAt(0));
-            images.set(key, { key, blob: new Blob([bytes], { type: mime }), size: bytes.length });
-            return { cacheImage: key };
-          })());
-          return byUrl.get(value);
-        }
-        if (Array.isArray(value)) return Promise.all(value.map(pack));
-        if (value && typeof value === 'object') {
-          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(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('缓存写入中止'));
-        const threads = tx.objectStore('threads'), metadata = tx.objectStore('images'), blobs = tx.objectStore('blobs');
-        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, pruned = false;
-        function prune() {
-          if (!records || !sizes || pruned) return;
-          pruned = true;
-          records.sort((a, b) => b.at - a.at);
-          const keep = new Set(), keptThreads = new Set(); let bytes = 0;
-          for (const [index, item] of records.entries()) {
-            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, 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;
-      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;
-    }
-    const key = find(record?.data); if (!key) return null;
-    const image = await read(db, 'blobs', key); if (!image) return null;
-    const bytes = new Uint8Array(await image.blob.arrayBuffer()); let binary = '';
-    for (let i = 0; i < bytes.length; i += 16384) binary += String.fromCharCode(...bytes.subarray(i, i + 16384));
-    return `data:${image.blob.type};base64,${btoa(binary)}`;
-  }
-  async function clear() {
-    await writes;
-    const db = await database();
-    await new Promise((resolve, reject) => {
-      const tx = db.transaction(['threads', 'images', 'blobs'], 'readwrite');
-      for (const store of ['threads', 'images', 'blobs']) tx.objectStore(store).clear();
-      tx.oncomplete = resolve; tx.onabort = tx.onerror = () => reject(tx.error);
-    });
-    release();
-  }
-  async function latest(scope) {
-    const db = await database();
-    const records = await new Promise((resolve, reject) => {
-      const request = db.transaction('threads').objectStore('threads').getAll();
-      request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error);
-    });
-    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, releaseUnused };
-})();

package/dist/web/history-controller.js

@@ -1,167 +0,0 @@
-(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;
-});