@obtoai/agent-bridge 0.1.0-beta.11 → 0.1.0-beta.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obtoai/agent-bridge",
-  "version": "0.1.0-beta.11",
+  "version": "0.1.0-beta.13",
   "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

@@ -27,7 +27,10 @@ const CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
 const CODEX_DIR = path.join(os.homedir(), '.codex', 'sessions');
 
 const PREVIEW_MAX_CHARS = 200;
+const TITLE_MAX_CHARS = 80;
 const TAIL_READ_BYTES = 8192; // read the last 8KB of each JSONL for the last message
+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
 
 // Read the tail of a (potentially large) JSONL file without slurping the
 // whole thing into memory. Returns a string (UTF-8) or '' on any failure.
@@ -50,6 +53,83 @@ const readTail = (filePath, maxBytes = TAIL_READ_BYTES) => {
   }
 };
 
+// Claude Code (and to a lesser extent Codex) prepend a parade of injected
+// "user" messages BEFORE the human's first real prompt — system reminders,
+// IDE state, untrusted-metadata wrappers, command blocks, etc. These are
+// noise from a label perspective. Filter them so the first PLAIN user
+// prompt is what we use as the thread title.
+const isInjectionMessage = (text) => {
+  const s = String(text || '').trim();
+  if (!s) return true;
+  if (/^<[a-zA-Z!]/.test(s)) return true;                         // <system-reminder>, <ide_opened_file>, etc.
+  if (/^Sender \(untrusted metadata\)/i.test(s)) return true;
+  if (/^Conversation info \(untrusted metadata\)/i.test(s)) return true;
+  if (/^untrusted metadata/i.test(s)) return true;
+  if (/^Caveat:/i.test(s)) return true;
+  if (/^Claude was launched/i.test(s)) return true;
+  if (/^```json/i.test(s)) return true;
+  if (/^`<command-name>/.test(s)) return true;
+  if (/^This session is being continued/i.test(s)) return true;   // /resume preamble
+  return false;
+};
+
+// Walk a JSONL file line-by-line until we find a plain user message (skipping
+// metadata injections) or we've checked TITLE_MAX_LINES / TITLE_MAX_BYTES.
+// Streaming so big files don't get fully slurped. Returns a clean ≤80-char
+// title or '' if nothing meaningful was found in the bound.
+const extractTitleFromFile = (filePath) => {
+  let fd = null;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const CHUNK = 16 * 1024;
+    const buf = Buffer.alloc(CHUNK);
+    let carry = '';
+    let bytesRead = 0;
+    let linesChecked = 0;
+    while (bytesRead < TITLE_MAX_BYTES && linesChecked < TITLE_MAX_LINES) {
+      const n = fs.readSync(fd, buf, 0, CHUNK, bytesRead);
+      if (n === 0) break;
+      bytesRead += n;
+      carry += buf.toString('utf8', 0, n);
+      const lines = carry.split(/\r?\n/);
+      carry = lines.pop() || '';
+      for (const line of lines) {
+        if (linesChecked >= TITLE_MAX_LINES) break;
+        if (!line.trim()) continue;
+        linesChecked++;
+        let obj;
+        try { obj = JSON.parse(line); } catch (_) { continue; }
+        let role = null, raw = null;
+        if (obj && obj.message && (obj.message.role || obj.type)) {
+          role = obj.message.role || (obj.type === 'user' ? 'user' : 'assistant');
+          raw = obj.message.content;
+        } else if (obj && obj.role && (obj.content || obj.text)) {
+          role = obj.role;
+          raw = obj.content != null ? obj.content : obj.text;
+        }
+        if (role !== 'user' || raw == null) continue;
+        let text = '';
+        if (typeof raw === 'string') text = raw;
+        else if (Array.isArray(raw)) {
+          text = raw
+            .filter((p) => p && (p.type === 'text' || typeof p.text === 'string'))
+            .map((p) => String(p.text || ''))
+            .join(' ');
+        }
+        text = text.replace(/\s+/g, ' ').trim();
+        if (!text) continue;
+        if (isInjectionMessage(text)) continue;
+        return text.length > TITLE_MAX_CHARS ? text.slice(0, TITLE_MAX_CHARS) : text;
+      }
+    }
+    return '';
+  } catch (_) {
+    return '';
+  } finally {
+    if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} }
+  }
+};
+
 // Walk a JSONL tail backwards, parse each non-empty line as JSON, return the
 // first one we can extract a message from. Tolerant of multiple shapes —
 // Claude and Codex write slightly different envelopes and the formats have
@@ -143,11 +223,13 @@ const scanClaude = () => {
       try { stat = fs.statSync(filePath); } catch (_) { continue; }
       const tail = readTail(filePath);
       const lastMsg = extractLastMessage(tail);
+      const title = extractTitleFromFile(filePath);
       out.push({
         source: 'claude',
         sessionId,
         projectDir: entry,                         // raw encoded form
         projectName: decodeClaudeProjectDir(entry), // best-effort decoded
+        title: title,                              // first-user-message slice
         lastActivityAt: stat.mtimeMs,
         lastMessagePreview: lastMsg ? lastMsg.preview : '',
         lastMessageAuthor: lastMsg ? lastMsg.author : null,
@@ -214,12 +296,15 @@ const scanCodex = () => {
           }
 
           const tail = readTail(filePath);
+          const head = readHead(filePath);
           const lastMsg = extractLastMessage(tail);
+          const title = extractTitle(head);
           out.push({
             source: 'codex',
             sessionId,
             projectDir: projectDir || `${y}/${m}/${d}`,
             projectName: projectDir || null,
+            title: title,
             lastActivityAt: stat.mtimeMs,
             lastMessagePreview: lastMsg ? lastMsg.preview : '',
             lastMessageAuthor: lastMsg ? lastMsg.author : null,