claude-simple 0.2.31 → 0.2.33

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.33.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.33.min.js"></script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-simple",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "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/chat.js

@@ -305,8 +305,9 @@ export function applyComposerAccess() {
       banner.classList.remove('hidden');
       banner.textContent = composerBlockReason();
     } else {
-      banner.classList.add('hidden');
-      banner.textContent = '';
+      const notice = ctx.nativeRunNotice?.sessionId === ctx.sessionId ? ctx.nativeRunNotice.message : '';
+      banner.classList.toggle('hidden', !notice);
+      banner.textContent = notice;
     }
   }
 }
@@ -393,6 +394,14 @@ export function connectWS(opts = {}) {
       return;
     }
     if (msg.type === 'run-status') {
+      if (msg.sessionId && msg.sessionId !== ctx.sessionId) return;
+      if (typeof msg.running !== 'boolean') {
+        ctx.nativeRunNotice = { sessionId: ctx.sessionId, message: msg.message || '终端会话未确认结束' };
+        applyComposerAccess();
+        return;
+      }
+      ctx.nativeRunNotice = null;
+      applyComposerAccess();
       // Only adopt "running" from server; never re-lock after we already finished a turn
       // unless the server still has a busy run (reconnect mid-stream).
       if (msg.running) {

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-27">
 </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-27"></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-v36';
 const PRECACHE = [
   '/',
   '/index.html',
   '/manifest.webmanifest',
-  '/style.css?v=ui-25',
+  '/style.css?v=ui-27',
   '/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-27',
   '/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;
 
@@ -398,6 +424,18 @@ export async function parseCodexMessages(filePath) {
   return entry.messages;
 }
 
+export async function readCodexRuntime(filePath, now = Date.now()) {
+  await parseCodexMessages(filePath);
+  const entry = codexTranscripts.get(filePath);
+  const runtime = entry?.runtime;
+  const pending = runtime?.state === 'pending';
+  const state = pending ? (now - entry.mtimeMs < 120_000 ? 'running' : 'unconfirmed') : runtime?.state || 'unknown';
+  return { ...runtime, state, running: state === 'running' ? true : ['completed','aborted'].includes(state) ? false : null,
+    updatedAt: entry?.mtimeMs || null, source: 'native-jsonl',
+    message: state === 'unconfirmed' || state === 'unknown' ? '终端会话未确认结束，请以原始记录核对' : state === 'running' ? '终端会话正在运行' : '终端会话已结束',
+  };
+}
+
 async function updateCodexTranscript(filePath, entry, stat) {
   const messages = entry.messages;
   // Codex writes the same assistant turn twice:
@@ -441,10 +479,19 @@ async function updateCodexTranscript(filePath, entry, stat) {
         // their multi-megabyte payloads when building the visible transcript.
         const head = line.slice(0, 400);
         if (!/"type"\s*:\s*"(?:response_item|event_msg)"/.test(head) ||
-            !/"type"\s*:\s*"(?:message|agent_message|function_call|command_execution|custom_tool_call)"/.test(head)) continue;
+            !/"type"\s*:\s*"(?:message|agent_message|function_call|command_execution|custom_tool_call|task_started|task_complete|turn_aborted)"/.test(head)) continue;
         let d;
         try { d = JSON.parse(line); } catch { continue; }
 
+        if (d.type === 'event_msg' && d.payload) {
+          const p = d.payload;
+          if (p.type === 'task_started') entry.runtime = { state: 'pending', turnId: p.turn_id || null, startedAt: d.timestamp };
+          if ((p.type === 'task_complete' || p.type === 'turn_aborted') &&
+              (!entry.runtime?.turnId || !p.turn_id || entry.runtime.turnId === p.turn_id)) {
+            entry.runtime = { ...entry.runtime, state: p.type === 'task_complete' ? 'completed' : 'aborted', endedAt: d.timestamp };
+          }
+        }
+
         if (d.type === 'response_item' && d.payload) {
           const p = d.payload;
           if (p.type === 'message' && p.role === 'user') {
@@ -1713,7 +1760,10 @@ export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs,
   if (a === 'codex') {
     const file = await findCodexSessionFile(sessionId, codexHome);
     if (!file) return null;
-    return { messages: await parseCodexMessages(file), context: null, agent: 'codex' };
+    const messages = await parseCodexMessages(file);
+    const runtime = await readCodexRuntime(file);
+    const entry = codexTranscripts.get(file);
+    return { messages, context: null, agent: 'codex', runtime, revision: `${entry?.ino}:${entry?.size}:${entry?.mtimeMs}` };
   }
   if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);

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);
@@ -1450,6 +1452,7 @@ export function createApp() {
         oldestIndex: page.oldestIndex,
         tail: page.tail,
         compact,
+        runtime: bundle.runtime || null,
       };
       res.setHeader('X-Session-Agent', payload.agent);
       // A session can be appended while a turn is streaming. Returning a
@@ -1601,7 +1604,9 @@ export function createApp() {
         tail: req.query.tail === '1', maxChars: req.query.maxChars });
       if (!result) return res.status(404).json({ error: 'Session JSONL not found' });
       res.setHeader('Cache-Control', 'no-store');
-      res.json({ ...result, sessionId, running: isSessionBusy(sessionId) });
+      const bundle = isSessionBusy(sessionId) ? null : await readSessionBundle(sessionId, agent);
+      const runtime = bundle?.runtime || { running: isSessionBusy(sessionId), source: 'ui' };
+      res.json({ ...result, sessionId, ...runtime });
     } catch (e) { res.status(500).json({ error: e.message }); }
   });
 
@@ -2046,11 +2051,16 @@ export function createApp() {
       if (cmd.cmd === 'session.subscribe') {
         client.sessionId = cmd.sessionId || client.sessionId || null;
         client.agent = cmd.agent || client.agent || null;
-        wireSend({
-          type: 'run-status',
-          sessionId: client.sessionId,
-          running: isSessionBusy(client.sessionId),
-        });
+        const sid = client.sessionId;
+        const agent = client.agent;
+        if (isSessionBusy(sid)) {
+          wireSend({ type: 'run-status', sessionId: sid, agent, running: true, source: 'ui' });
+        } else {
+          const bundle = await readSessionBundle(sid, agent).catch(() => null);
+          if (client.sessionId !== sid || client.agent !== agent) return;
+          wireSend({ type: 'run-status', sessionId: sid, agent,
+            ...(bundle?.runtime || { running: false, source: 'ui' }) });
+        }
         // UI-managed active runs already stream their events directly. For
         // everything else, tail the native persisted transcript so an agent
         // launched in an ordinary terminal appears live in this UI.

package/src/runtime/external-session-sync.js

@@ -10,6 +10,7 @@
  */
 
 function transcriptFingerprint(bundle) {
+  if (bundle?.revision) return `${bundle.revision}:${JSON.stringify(bundle.runtime || null)}`;
   const messages = Array.isArray(bundle?.messages) ? bundle.messages : [];
   // Message parsing already normalizes the native formats. JSON preserves a
   // change to an in-progress/rewritten final message as well as append-only
@@ -49,6 +50,7 @@ export function createExternalSessionMirror({ readSession, emit, intervalMs = 75
       const changed = fingerprint !== entry.fingerprint;
       entry.fingerprint = fingerprint;
       if (changed || announce) {
+        if (bundle.runtime) emit(entry.sessionId, { type: 'run-status', sessionId: entry.sessionId, agent: bundle.agent || entry.agent, ...bundle.runtime });
         emit(entry.sessionId, {
           type: 'external-session-updated',
           sessionId: entry.sessionId,

package/src/runtime/http-transfer.js

@@ -0,0 +1,76 @@
+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 });
+        const headers = sanitizeHeaders(Object.fromEntries(res.headers.entries()));
+        // Identity bodies retain their exact length (ordinary proxy replies recompute it).
+        if (!res.headers.get('content-encoding') || res.headers.get('content-encoding') === 'identity') {
+          const length = res.headers.get('content-length');
+          if (length !== null) headers['content-length'] = length;
+        }
+        await send({ type: 'http-res-start', status: res.status, headers });
+        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--;
+    }
+  };
+}