claude-simple 0.2.31 → 0.2.32

package/dist/index.html

@@ -4,13 +4,13 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
   <title>Claude Code</title>
-  <link rel="stylesheet" href="/style.0.2.31.min.css">
+  <link rel="stylesheet" href="/style.0.2.32.min.css">
   <link rel="stylesheet" href="/highlight.min.css">
   <script src="/marked.min.js"></script>
   <script src="/highlight.min.js"></script>
 </head>
 <body class="h-dvh overflow-hidden flex flex-col bg-base-100 text-base-content">
   <div id="root" class="flex flex-col flex-1 overflow-hidden"></div>
-  <script type="module" src="/app.0.2.31.min.js"></script>
+  <script type="module" src="/app.0.2.32.min.js"></script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-simple",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "type": "module",
   "bin": {
     "claude-simple": "server.js",

package/public/cache.js

@@ -29,17 +29,53 @@ export async function getCachedTranscript(key) {
   catch { return null; }
 }
 
-export async function setCachedTranscript(key, transcript) {
-  try { await db.set(`transcript:${key}`, recentTranscript(transcript), { ttl: 24 * 60 * 60 * 1000 }); }
-  catch {}
+let transcriptWrites = Promise.resolve();
+export function setCachedTranscript(key, transcript) {
+  const recent = recentTranscript(transcript);
+  transcriptWrites = transcriptWrites.catch(() => {}).then(async () => {
+    await db.set(`transcript:${key}`, recent, { ttl: 24 * 60 * 60 * 1000 });
+    const currentKey = `transcript:${key}`;
+    const previous = await db.get('transcript-index-v2');
+    const index = [
+      { key: currentKey, at: Date.now() },
+      ...(previous || []).filter(entry => entry.key !== currentKey),
+    ].filter(entry => entry.at >= Date.now() - 24 * 60 * 60 * 1000).slice(0, 24);
+    const keep = new Set(index.map(entry => entry.key));
+    // Enumerate keys only: loading every legacy transcript here freezes the UI.
+    for (const storedKey of await db.keys()) {
+      if (String(storedKey).startsWith('transcript:') && !keep.has(storedKey)) await db.delete(storedKey);
+    }
+    await db.set('transcript-index-v2', index);
+  });
+  return transcriptWrites.catch(() => {});
 }
 
 // lastSessionContext lives in shell/session-context.js (avoid stale cache.js in browsers)
 
+// Conservative UTF-8 estimate avoids stringifying huge messages on the UI thread.
+export function cacheWeight(value, budget = 1024 * 1024) {
+  if (typeof value === 'string') return value.length * 3 + 2;
+  if (!value || typeof value !== 'object') return 16;
+  let size = 2;
+  for (const [key,item] of Object.entries(value)) {
+    size += key.length * 3 + cacheWeight(item, budget - size) + 4;
+    if (size > budget) break;
+  }
+  return size;
+}
 export function recentTranscript(snapshot) {
   if (!snapshot?.msgs) return snapshot ?? null;
-  const drop = Math.max(0, snapshot.msgs.length - 80);
-  return { ...snapshot, msgs: snapshot.msgs.slice(drop), meta: {
+  let drop = snapshot.msgs.length;
+  let bytes = cacheWeight(snapshot.context);
+  const context = bytes > 64 * 1024 ? null : snapshot.context;
+  bytes = cacheWeight(context);
+  while (drop > 0 && snapshot.msgs.length - drop < 80) {
+    const weight = cacheWeight(snapshot.msgs[drop - 1]);
+    if (bytes + weight > 1024 * 1024) break;
+    bytes += weight;
+    drop--;
+  }
+  return { ...snapshot, context, msgs: snapshot.msgs.slice(drop), meta: {
     ...snapshot.meta, oldestIndex: (snapshot.meta?.oldestIndex || 0) + drop,
     truncated: drop > 0 || !!snapshot.meta?.truncated,
   } };

package/public/files.js

@@ -394,12 +394,33 @@ async function downloadFile(proj, filePath) {
   const qs = new URLSearchParams({ root, path: filePath, download: 'true' });
   const url = `/api/projects/${id}/file?${qs}`;
   try {
+    const handle = typeof window.showSaveFilePicker === 'function'
+      ? await window.showSaveFilePicker({ suggestedName: name }) : null;
     const res = await fetch(url, { headers: authHeaders(), credentials: 'same-origin' });
     if (!res.ok) {
       const d = await res.json().catch(() => ({}));
       throw new Error(d.error || `HTTP ${res.status}`);
     }
-    const blob = await res.blob();
+    if (handle && res.body) {
+      await res.body.pipeTo(await handle.createWritable());
+      return;
+    }
+    // Browsers without a file sink hand large downloads to their download manager.
+    const maxBlob = 16 * 1024 * 1024;
+    if (Number(res.headers.get('content-length')) > maxBlob) {
+      await res.body?.cancel();
+      throw new Error('Use native download');
+    }
+    const reader = res.body.getReader();
+    const chunks = []; let bytes = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > maxBlob) { await reader.cancel(); throw new Error('Use native download'); }
+      chunks.push(value);
+    }
+    const blob = new Blob(chunks, { type: res.headers.get('content-type') || 'application/octet-stream' });
     const objectUrl = URL.createObjectURL(blob);
     const a = document.createElement('a');
     a.href = objectUrl;
@@ -412,6 +433,7 @@ async function downloadFile(proj, filePath) {
     // iOS may need the URL briefly; revoke after a beat.
     setTimeout(() => URL.revokeObjectURL(objectUrl), 60_000);
   } catch (e) {
+    if (e.name === 'AbortError') return;
     // Last resort: open with token query (works when fetch is blocked, e.g. some WebViews).
     try {
       const fallback = `/api/projects/${id}/file?${authQuery({ root, path: filePath, download: 'true' })}`;

package/public/index.html

@@ -85,7 +85,7 @@
   <script src="/vendor/mermaid.min.js"></script>
   <link rel="stylesheet" href="/vendor/katex.min.css">
   <script src="/vendor/katex.min.js"></script>
-  <link rel="stylesheet" href="style.css?v=ui-25">
+  <link rel="stylesheet" href="style.css?v=ui-26">
 </head>
 <body class="h-dvh overflow-hidden flex flex-col bg-base-100 text-base-content">
   <div id="root" class="flex flex-col flex-1 overflow-hidden"></div>
@@ -101,6 +101,6 @@
       }
     }, 10000);
   </script>
-  <script type="module" src="app.js?v=ui-25"></script>
+  <script type="module" src="app.js?v=ui-26"></script>
 </body>
 </html>

package/public/shell/session-nav.js

@@ -374,7 +374,9 @@ export async function resumeSession(sid, cwd, configDir, agent, machineId, opts
       historyWindow = { msgs, context, meta };
       if (msgs.length && !meta.stale) {
         const snapshot = { msgs, context, meta, at: Date.now() };
+        historyCache.delete(cacheKey);
         historyCache.set(cacheKey, recentTranscript(snapshot));
+        while (historyCache.size > 24) historyCache.delete(historyCache.keys().next().value);
         setCachedTranscript(cacheKey, snapshot).catch(() => {});
       }
       else historyCache.delete(cacheKey);

package/public/sw.js

@@ -1,12 +1,12 @@
 /* Agent UI service worker — cache shell assets only.
  * Never intercepts WebSocket or mutates API semantics beyond offline fallback.
  * Bump CACHE when shipping UI that must invalidate old shells. */
-const CACHE = 'agent-ui-shell-v34';
+const CACHE = 'agent-ui-shell-v35';
 const PRECACHE = [
   '/',
   '/index.html',
   '/manifest.webmanifest',
-  '/style.css?v=ui-25',
+  '/style.css?v=ui-26',
   '/style.css',
   '/ui.min.css',
   '/vendor/mini-react.min.js',
@@ -16,7 +16,7 @@ const PRECACHE = [
   '/vendor/mermaid.min.js',
   '/vendor/katex.min.js',
   '/vendor/katex.min.css',
-  '/app.js?v=ui-25',
+  '/app.js?v=ui-26',
   '/icons/icon-192.png',
   '/icons/icon-512.png',
   '/icons/icon-maskable-512.png',

package/src/agents/sessions.js

@@ -165,7 +165,33 @@ function isInternal(text) {
   return INTERNAL_PREFIXES.some(p => text.startsWith(p));
 }
 
+// Hot native projections avoid re-parsing settled Claude rollouts. In-flight
+// reads coalesce; stat validation keeps appended/truncated files authoritative.
+const claudeTranscripts = new Map();
 export async function parseClaudeMessages(filePath) {
+  const stat = await fs.stat(filePath);
+  const stamp = `${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+  const cached = claudeTranscripts.get(filePath);
+  if (cached?.stamp === stamp) {
+    claudeTranscripts.delete(filePath); claudeTranscripts.set(filePath, cached);
+    return cached.loading || cached.messages;
+  }
+  const entry = { stamp, weight: stat.size };
+  entry.loading = parseClaudeMessagesUncached(filePath);
+  claudeTranscripts.set(filePath, entry);
+  try { entry.messages = await entry.loading; return entry.messages; }
+  finally {
+    entry.loading = null;
+    let total = [...claudeTranscripts.values()].reduce((sum,e) => sum + e.weight, 0);
+    for (const [key,value] of claudeTranscripts) {
+      if (claudeTranscripts.size <= 8 && total <= 32 * 1024 * 1024) break;
+      if (value.loading) continue;
+      total -= value.weight; claudeTranscripts.delete(key);
+    }
+  }
+}
+
+async function parseClaudeMessagesUncached(filePath) {
   const messages = [];
   let pendingUsage = null;
 

package/src/app.js

@@ -1058,7 +1058,9 @@ export function createApp() {
         res.setHeader('Content-Disposition', `attachment; filename="${ascii || 'download'}"; filename*=UTF-8''${star}`);
         res.setHeader('Content-Type', 'application/octet-stream');
         res.setHeader('Cache-Control', 'no-store');
-        return fsSync.createReadStream(filePath).pipe(res);
+        return res.sendFile(filePath, { dotfiles: 'allow' }, err => {
+          if (err && !res.headersSent && !res.destroyed) res.status(err.status || 500).json({ error: err.message });
+        });
       }
       // Office / PDF / binary previews need more headroom than plain text
       const isOffice = /\.(docx|pptx|xlsx|pdf)$/i.test(rel);

package/src/runtime/http-transfer.js

@@ -0,0 +1,70 @@
+import { WebSocket } from 'ws';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+// Aggregate wire budget across downloads/previews, separate from chat traffic.
+export class TransferBudget {
+  constructor(bytesPerSecond = 256 * 1024) {
+    this.rate = bytesPerSecond;
+    this.next = 0;
+  }
+  async take(bytes, signal) {
+    const now = Date.now();
+    const start = Math.max(now, this.next);
+    this.next = start + bytes * 1000 / this.rate;
+    if (start > now) await sleep(start - now, undefined, { signal });
+  }
+}
+
+export async function readLimitedBody(response, maxBytes = 8 * 1024 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const value of response.body || []) {
+    size += value.byteLength;
+    if (size > maxBytes) throw new Error('Response too large; use paginated history or file download');
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks, size);
+}
+
+export function createHTTPTransfer({ gatewayURL, token, machineId, budget = new TransferBudget(), maxConcurrent = 2 }) {
+  let active = 0;
+  return async function transfer(msg, url, options, sanitizeHeaders) {
+    if (active >= maxConcurrent) throw Object.assign(new Error('Too many file transfers; retry after the current download finishes'), { status: 429 });
+    active++;
+    const controller = new AbortController();
+    let ws;
+    try {
+      ws = new WebSocket(gatewayURL, {
+        headers: { 'x-machine-token': token, 'x-http-request': msg.reqId, 'x-machine-id': machineId },
+        perMessageDeflate: false, handshakeTimeout: 10000,
+      });
+      ws.on('close', () => controller.abort());
+      ws.on('error', () => controller.abort());
+      await new Promise((resolve, reject) => { ws.once('open', resolve); ws.once('error', reject); });
+      const send = data => new Promise((resolve, reject) => {
+        if (ws.readyState !== WebSocket.OPEN) return reject(new Error('Transfer connection closed'));
+        ws.send(JSON.stringify({ ...data, reqId: msg.reqId }), err => err ? reject(err) : resolve());
+      });
+      try {
+        const res = await fetch(url, { ...options, signal: controller.signal });
+        await send({ type: 'http-res-start', status: res.status, headers: sanitizeHeaders(Object.fromEntries(res.headers.entries())) });
+        for await (const value of res.body || []) {
+          // Each frame is small; sends wait for socket backpressure and share a rate cap.
+          for (let offset = 0; offset < value.byteLength; offset += 24 * 1024) {
+            const chunk = Buffer.from(value.subarray(offset, offset + 24 * 1024));
+            await budget.take(Math.ceil(chunk.length * 4 / 3) + 128, controller.signal);
+            await send({ type: 'http-chunk', data: chunk.toString('base64'), encoding: 'base64' });
+          }
+        }
+        await send({ type: 'http-end' });
+      } catch (err) {
+        if (ws.readyState === WebSocket.OPEN) await send({ type: 'http-error', message: err.message }).catch(() => {});
+        throw err;
+      }
+    } finally {
+      controller.abort();
+      ws?.close();
+      active--;
+    }
+  };
+}