claude-simple 0.2.38 → 0.2.39

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.38.min.css">
+  <link rel="stylesheet" href="/style.0.2.39.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.38.min.js"></script>
+  <script type="module" src="/app.0.2.39.min.js"></script>
 </body>
 </html>

package/package.json

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

package/src/agents/sessions.js

@@ -5,6 +5,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import { pathsEqual } from '../platform.js';
+import { JSONL_LINE_PARSE_MAX, scanJsonlFile } from '../jsonl-scan.js';
 
 // ─── Claude ───────────────────────────────────────────────────────────────────
 
@@ -318,6 +319,7 @@ const CODEX_CATALOG_HEAD_BYTES = 256 * 1024;
 // session_meta includes git + base_instructions and is often 20–40KB.
 // Multi-MB tool outputs still exceed this and are skipped.
 const CODEX_LINE_PARSE_MAX = 256 * 1024;
+const CODEX_TRANSCRIPT_CACHE_MAX = 64;
 
 const codexMetadata = new Map();
 async function readCodexMeta(filePath) {
@@ -445,7 +447,9 @@ export async function parseCodexMessages(filePath) {
   }
   codexTranscripts.delete(filePath);
   codexTranscripts.set(filePath, entry);
-  while (codexTranscripts.size > 8) codexTranscripts.delete(codexTranscripts.keys().next().value);
+  while (codexTranscripts.size > CODEX_TRANSCRIPT_CACHE_MAX) {
+    codexTranscripts.delete(codexTranscripts.keys().next().value);
+  }
   if (entry.size === stat.size && entry.mtimeMs === stat.mtimeMs) return entry.messages;
   const loading = updateCodexTranscript(filePath, entry, stat);
   entry.loading = loading;
@@ -494,25 +498,16 @@ async function updateCodexTranscript(filePath, entry, stat) {
 
   try {
     if (stat.size <= entry.offset) return;
-    const stream = fsSync.createReadStream(filePath, { start: entry.offset, end: stat.size - 1 });
-    let pending = Buffer.alloc(0);
-    for await (const chunk of stream) {
-      pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
-      let start = 0;
-      let end;
-      while ((end = pending.indexOf(10, start)) !== -1) {
-        const lineBytes = end - start;
-        entry.offset += lineBytes + 1;
-        start = end + 1;
-        // Tool outputs are multi-MB JSONL lines. AgentUI does not render them
-        // and Hub must not receive them — skip without materializing the body.
-        if (lineBytes > 64 * 1024) continue;
-        const line = pending.subarray(start - lineBytes - 1, end).toString('utf8');
+    const scanned = await scanJsonlFile(filePath, {
+      start: entry.offset,
+      end: stat.size,
+      maxLineBytes: JSONL_LINE_PARSE_MAX,
+      onLine: (line) => {
         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|task_started|task_complete|turn_aborted)"/.test(head)) continue;
+            !/"type"\s*:\s*"(?:message|agent_message|function_call|command_execution|custom_tool_call|task_started|task_complete|turn_aborted)"/.test(head)) return;
         let d;
-        try { d = JSON.parse(line); } catch { continue; }
+        try { d = JSON.parse(line); } catch { return; }
 
         if (d.type === 'event_msg' && d.payload) {
           const p = d.payload;
@@ -544,13 +539,13 @@ async function updateCodexTranscript(filePath, entry, stat) {
               .filter(Boolean);
             pushAssistant(texts.join('\n'), d.timestamp);
           } else if (p.type === 'function_call') {
-            if (p.call_id && entry.seenCalls.has(p.call_id)) continue;
+            if (p.call_id && entry.seenCalls.has(p.call_id)) return;
             if (p.call_id) entry.seenCalls.add(p.call_id);
             let input = p.arguments;
             try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch {}
             messages.push({ role: 'tool', type: 'tool_use', name: p.name || 'function', id: p.call_id, input: input ?? {}, ts: d.timestamp });
           } else if (p.type === 'command_execution' || p.type === 'custom_tool_call') {
-            if (p.call_id && entry.seenCalls.has(p.call_id)) continue;
+            if (p.call_id && entry.seenCalls.has(p.call_id)) return;
             if (p.call_id) entry.seenCalls.add(p.call_id);
             let input = p.input;
             try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch {}
@@ -570,9 +565,9 @@ async function updateCodexTranscript(filePath, entry, stat) {
           const text = d.payload.message || d.payload.text;
           pushAssistant(text, d.timestamp);
         }
-      }
-      pending = pending.subarray(start);
-    }
+      },
+    });
+    entry.offset = scanned.offset;
     entry.size = stat.size;
     entry.mtimeMs = stat.mtimeMs;
   } catch (error) {
@@ -1922,15 +1917,11 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   const budget = Math.min(Math.max(1000, Number(maxChars) || 24000), 64000);
   const lines = [];
   let n = 0, chars = 0, hasMore = false, clipped = false;
-  const stream = fsSync.createReadStream(file, { encoding: 'utf8' });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
+  await scanJsonlFile(file, {
+    onLine: (line) => {
       const index = n++;
-      if (!tail && index < start) continue;
-      if (!tail && (lines.length >= limit || chars >= budget)) { hasMore = true; break; }
-      // Bound huge tool output rows as well as total response size. Clipping
-      // is explicit: a clipped line must not be mistaken for complete JSON.
+      if (!tail && index < start) return;
+      if (!tail && (lines.length >= limit || chars >= budget)) { hasMore = true; return; }
       const cap = tail ? budget : budget - chars;
       const text = line.slice(0, cap);
       if (text.length < line.length) clipped = true;
@@ -1938,8 +1929,8 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
       if (tail) while (lines.length > limit || (chars > budget && lines.length > 1)) {
         chars -= lines.shift().length;
       }
-    }
-  } finally { rl.close(); stream.destroy(); }
+    },
+  });
   const stat = await fs.stat(file).catch(() => null);
   const actualOffset = tail ? Math.max(0, n - lines.length) : start;
   return { agent: a, fileName: path.basename(file), offset: actualOffset, lines,

package/src/jsonl-scan.js

@@ -0,0 +1,71 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+
+export const JSONL_LINE_PARSE_MAX = 64 * 1024;
+
+/**
+ * Sequential JSONL reader. Oversize records are skipped by searching for the
+ * next newline without keeping the body in a JS string.
+ */
+export async function scanJsonlFile(filePath, {
+  start = 0,
+  end = null,
+  maxLineBytes = JSONL_LINE_PARSE_MAX,
+  onLine,
+} = {}) {
+  const stat = await fs.stat(filePath);
+  const stop = end == null ? stat.size : Math.min(end, stat.size);
+  let offset = Math.max(0, start);
+  let skippedLines = 0;
+  if (offset >= stop) return { offset, skippedLines, size: stat.size };
+
+  const stream = fsSync.createReadStream(filePath, {
+    start: offset,
+    end: stop - 1,
+    highWaterMark: 64 * 1024,
+  });
+  let pending = Buffer.alloc(0);
+  let skip = false;
+  try {
+    for await (const chunk of stream) {
+      let buf = skip ? chunk : (pending.length ? Buffer.concat([pending, chunk]) : chunk);
+      pending = Buffer.alloc(0);
+      let pos = 0;
+      if (skip) {
+        const nl = buf.indexOf(10);
+        if (nl === -1) {
+          offset += buf.length;
+          continue;
+        }
+        offset += nl + 1;
+        skippedLines += 1;
+        skip = false;
+        pos = nl + 1;
+      }
+      while (pos < buf.length) {
+        const nl = buf.indexOf(10, pos);
+        if (nl === -1) break;
+        const len = nl - pos;
+        offset += len + 1;
+        if (len > maxLineBytes) {
+          skippedLines += 1;
+        } else if (typeof onLine === 'function') {
+          onLine(buf.subarray(pos, nl).toString('utf8'), { pendingBytes: buf.length, offset });
+        }
+        pos = nl + 1;
+      }
+      if (pos < buf.length) {
+        const leftover = buf.subarray(pos);
+        if (leftover.length > maxLineBytes) {
+          skip = true;
+          offset += leftover.length;
+        } else {
+          pending = leftover;
+        }
+      }
+    }
+  } finally {
+    stream.destroy();
+  }
+  return { offset, skippedLines, size: stat.size };
+}