@obtoai/agent-bridge 0.1.0-beta.17 → 0.1.0-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obtoai/agent-bridge",
-  "version": "0.1.0-beta.17",
+  "version": "0.1.0-beta.19",
   "description": "Local consumer for the OBTO Agent Bridge. Receives bridge events over SSE and drives a coding agent (Claude Code or OpenAI Codex) on your machine.",
   "license": "Apache-2.0",
   "author": "OBTO Inc.",

package/src/external-scanner.js

@@ -25,10 +25,23 @@ const os = require('os');
 
 const CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
 const CODEX_DIR = path.join(os.homedir(), '.codex', 'sessions');
+// Claude Desktop app's local-agent mode stores session JSONLs under
+// ~/Library/Application Support/Claude/local-agent-mode-sessions/<uuid>/<uuid>/local_<uuid>/.claude/projects/<encoded>/<sid>.jsonl
+// The file format is identical to Claude Code CLI's — same queue-operation
+// preamble, same user/assistant message shape. Just a different root.
+// Phase 6.2.5 — beta.19: surface these so the bridge sees every Claude
+// session on disk, not just the CLI/extension subset.
+const CLAUDE_DESKTOP_BASE = path.join(
+  os.homedir(),
+  'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions',
+);
 
 const PREVIEW_MAX_CHARS = 200;
 const TITLE_MAX_CHARS = 80;
-const TAIL_READ_BYTES = 16384; // last 16KB — covers the last message AND the late-appended ai-title record
+const TAIL_READ_BYTES = 16384;       // fixed-budget tail (cheap; used for ai-title + lastMessage)
+const TAIL_STREAM_MAX_BYTES = 524288;// streaming tail cap — 512KB max read for recents (Phase 6.2.4)
+const TAIL_STREAM_CHUNK = 65536;     // 64KB chunk size for the backward stream
+const TAIL_STREAM_MIN_MESSAGES = 10; // stop reading once we have this many text-bearing lines
 const TITLE_MAX_LINES = 40;    // scan up to this many lines for a real first message
 const TITLE_MAX_BYTES = 65536; // hard ceiling per file even if MAX_LINES never reached
 
@@ -53,6 +66,59 @@ const readTail = (filePath, maxBytes = TAIL_READ_BYTES) => {
   }
 };
 
+// Phase 6.2.4 — streaming tail. For sessions where individual JSONL records
+// exceed the fixed 16KB budget (long assistant messages with lots of inline
+// code), the fixed tail returns 0 parseable lines. This reads backward in
+// 64KB chunks until we either have ≥TAIL_STREAM_MIN_MESSAGES text-bearing
+// user/assistant lines OR hit TAIL_STREAM_MAX_BYTES (512KB) — whichever
+// comes first. The first partial line at the buffer boundary is dropped
+// because it won't JSON.parse cleanly; that's fine, the next chunk will
+// pick it up complete.
+const readTailUntilMessages = (filePath) => {
+  let fd = null;
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) return '';
+    fd = fs.openSync(filePath, 'r');
+    let buffer = '';
+    let pos = stat.size;
+    while (pos > 0 && buffer.length < TAIL_STREAM_MAX_BYTES) {
+      const readSize = Math.min(TAIL_STREAM_CHUNK, pos);
+      pos -= readSize;
+      const chunk = Buffer.alloc(readSize);
+      fs.readSync(fd, chunk, 0, readSize, pos);
+      buffer = chunk.toString('utf8') + buffer;
+      // Cheap completeness check: count parseable user/assistant lines with text.
+      const lines = buffer.split(/\r?\n/);
+      let count = 0;
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let obj;
+        try { obj = JSON.parse(line); } catch (_) { continue; }
+        const role = (obj && (obj.role || (obj.message && obj.message.role))) || null;
+        if (role !== 'user' && role !== 'assistant') continue;
+        const raw = (obj.message && obj.message.content) || obj.content;
+        if (!raw) continue;
+        if (typeof raw === 'string') {
+          if (raw.trim()) count++;
+        } else if (Array.isArray(raw)) {
+          for (const p of raw) {
+            if (p && (p.type === 'text' || typeof p.text === 'string') && String(p.text || '').trim()) {
+              count++; break;
+            }
+          }
+        }
+      }
+      if (count >= TAIL_STREAM_MIN_MESSAGES) break;
+    }
+    return buffer;
+  } catch (_) {
+    return '';
+  } finally {
+    if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} }
+  }
+};
+
 // Pull the last N user/assistant *logical turns* from the tail, oldest-first.
 // Phase 6.2.3 — beta.17 fix: Claude Code streams a single assistant reply as
 // MULTIPLE JSONL lines (text → tool_use → tool_result → text → …), each its
@@ -295,14 +361,45 @@ const decodeClaudeProjectDir = (encoded) => {
   return encoded.replace(/-/g, '/');
 };
 
-// Scan ~/.claude/projects/<encoded-projectdir>/<sessionId>.jsonl
-const scanClaude = () => {
+// Discover all Claude Desktop "local-agent-mode" project roots.
+// Structure is 3 levels deep before we hit `.claude/projects/`:
+//   <BASE>/<accountUuid>/<workspaceUuid>/local_<sessionUuid>/.claude/projects/
+// We collect every leaf `.claude/projects` dir, then walk each like we walk
+// the CLI's ~/.claude/projects.
+const findClaudeDesktopProjectRoots = () => {
+  const out = [];
+  let l1;
+  try { l1 = fs.readdirSync(CLAUDE_DESKTOP_BASE); } catch (_) { return out; }
+  for (const a of l1) {
+    const aPath = path.join(CLAUDE_DESKTOP_BASE, a);
+    let aStat; try { aStat = fs.statSync(aPath); } catch (_) { continue; }
+    if (!aStat.isDirectory()) continue;
+    let l2; try { l2 = fs.readdirSync(aPath); } catch (_) { continue; }
+    for (const b of l2) {
+      const bPath = path.join(aPath, b);
+      let bStat; try { bStat = fs.statSync(bPath); } catch (_) { continue; }
+      if (!bStat.isDirectory()) continue;
+      let l3; try { l3 = fs.readdirSync(bPath); } catch (_) { continue; }
+      for (const c of l3) {
+        if (!c.startsWith('local_')) continue;
+        const projects = path.join(bPath, c, '.claude', 'projects');
+        try { if (fs.statSync(projects).isDirectory()) out.push(projects); } catch (_) {}
+      }
+    }
+  }
+  return out;
+};
+
+// Walk a single Claude projects root (works for both ~/.claude/projects and
+// each of the Desktop app's local-agent-mode project roots — file format is
+// identical, only the path differs).
+const walkClaudeProjectsRoot = (root) => {
   const out = [];
   let topEntries;
-  try { topEntries = fs.readdirSync(CLAUDE_DIR); } catch (_) { return out; }
+  try { topEntries = fs.readdirSync(root); } catch (_) { return out; }
 
   for (const entry of topEntries) {
-    const projectPath = path.join(CLAUDE_DIR, entry);
+    const projectPath = path.join(root, entry);
     let projectStat;
     try { projectStat = fs.statSync(projectPath); } catch (_) { continue; }
     if (!projectStat.isDirectory()) continue;
@@ -318,19 +415,16 @@ const scanClaude = () => {
       try { stat = fs.statSync(filePath); } catch (_) { continue; }
       const tail = readTail(filePath);
       const lastMsg = extractLastMessage(tail);
-      // Prefer Claude Code's own LLM-summarized title (matches VSCode's list);
-      // fall back to first-user-message scanning if a session is too new to
-      // have an ai-title record yet.
       let title = extractAiTitleFromTail(tail);
       if (!title) title = extractTitleFromFile(filePath);
-      const recentMessages = extractRecentMessages(tail);
+      const recentMessages = extractRecentMessages(readTailUntilMessages(filePath));
       out.push({
         source: 'claude',
         sessionId,
-        projectDir: entry,                         // raw encoded form
-        projectName: decodeClaudeProjectDir(entry), // best-effort decoded
-        title: title,                              // ai-title (Claude) or first-user-message fallback
-        recentMessages: recentMessages,            // last ≤5 user/assistant turns for adopt-time history
+        projectDir: entry,
+        projectName: decodeClaudeProjectDir(entry),
+        title: title,
+        recentMessages: recentMessages,
         lastActivityAt: stat.mtimeMs,
         lastMessagePreview: lastMsg ? lastMsg.preview : '',
         lastMessageAuthor: lastMsg ? lastMsg.author : null,
@@ -340,6 +434,18 @@ const scanClaude = () => {
   return out;
 };
 
+// Scan all Claude session storage on this machine — CLI + VSCode extension
+// (~/.claude/projects) AND every Claude Desktop local-agent-mode subdir
+// (~/Library/Application Support/Claude/local-agent-mode-sessions/.../).
+const scanClaude = () => {
+  const roots = [CLAUDE_DIR].concat(findClaudeDesktopProjectRoots());
+  const out = [];
+  for (const root of roots) {
+    out.push(...walkClaudeProjectsRoot(root));
+  }
+  return out;
+};
+
 // Scan ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<sessionId>.jsonl
 // The first JSONL line for a Codex rollout is a session-meta record that
 // contains the working directory; we read it once for projectDir.
@@ -399,7 +505,9 @@ const scanCodex = () => {
           const tail = readTail(filePath);
           const lastMsg = extractLastMessage(tail);
           const title = extractTitleFromFile(filePath);
-          const recentMessages = extractRecentMessages(tail);
+          // Recent messages get the streaming tail (handles huge per-message
+      // assistant turns that overflow the 16KB fixed budget).
+      const recentMessages = extractRecentMessages(readTailUntilMessages(filePath));
           out.push({
             source: 'codex',
             sessionId,