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

package/src/daemon.js

@@ -2,9 +2,11 @@
 
 const { loadConfig } = require('./config');
 const { startStream } = require('./stream-client');
-const { loadState, saveState, getBinding, setBinding } = require('./state');
-const { drive, tryResolvePermission, activeAgent } = require('./driver');
-const { postAgentActivity } = require('./bridge-http');
+const { loadState, saveState, getAgentSession, setAgentSession } = require('./state');
+const { drive, tryResolvePermission, agentFor } = require('./driver');
+const { postAgentActivity, claimThread, postExternalSync } = require('./bridge-http');
+const { detect: detectCapabilities } = require('./capabilities');
+const { scanAll: scanExternalSessions } = require('./external-scanner');
 
 const log = (level, msg, data) => {
   const line = { ts: new Date().toISOString(), level, msg };
@@ -67,12 +69,82 @@ const handleEvent = async (sseEvent) => {
     return;
   }
 
-  const binding = getBinding(state, threadId);
+  // Phase 2b — multi-daemon race check. The thread's target machine is
+  // included on the event when known (postReply publishes it). If it's set
+  // and isn't us, skip. If null, attempt the atomic first-touch claim — only
+  // the winning daemon handles the event; the rest skip cleanly.
+  const targetAgentId = payload.agentId ? String(payload.agentId).trim() : null;
+  if (targetAgentId && targetAgentId !== cfg.agentId) {
+    log('event', 'skip — claimed by other daemon', {
+      threadId,
+      targetAgentId,
+      messageId: payload.messageId,
+    });
+    return;
+  }
+  if (!targetAgentId) {
+    try {
+      const r = await claimThread(threadId, cfg.agentId);
+      if (!r || !r.ok || !r.data || !r.data.won) {
+        log('info', 'claim lost or failed', {
+          threadId,
+          winner: r && r.data && r.data.winner,
+          status: r && r.status,
+        });
+        return;
+      }
+      log('info', 'claim won', { threadId, agentId: cfg.agentId });
+    } catch (e) {
+      log('error', 'claim threw', { threadId, error: e && e.message });
+      return; // conservative — skip on uncertainty rather than double-drive
+    }
+  }
+
+  // v1.1 — which agent this thread is bound to (server-set, on the event).
+  const agent = agentFor(payload);
+  let session = getAgentSession(state, threadId, agent);
+  let wasAdoption = false;
+
+  // Phase 6.2 — adopt external session on first turn. The bridge attaches
+  // `externalAdoption: {sessionId, projectDir, projectName, source}` to the
+  // reply payload for adopted threads. With no prior session for this
+  // (thread, agent), synthesize a binding pointing at the original engine
+  // session so the driver resumes it instead of first-touching fresh —
+  // context preserved end-to-end. After the first successful drive, the
+  // session is persisted to state.json and externalAdoption stops mattering.
+  if (!session && payload.externalAdoption && payload.externalAdoption.sessionId) {
+    const ea = payload.externalAdoption;
+    // Prefer projectName (already-decoded filesystem path) for cwd. Claude
+    // scanner emits both raw `-Users-foo` and decoded `/Users/foo`; the
+    // decoded form is what the SDK's cwd argument expects.
+    let resumeCwd = ea.projectName || ea.projectDir || cfg.projectDir;
+    if (typeof resumeCwd === 'string' && resumeCwd.startsWith('//')) {
+      resumeCwd = '/' + resumeCwd.replace(/^\/+/, '');
+    }
+    session = {
+      sessionId: ea.sessionId,
+      projectDir: resumeCwd,
+      jsonlPath: null,
+      lastJsonlMtimeMs: null,
+      createdAt: new Date().toISOString(),
+      lastDriveAt: null,
+    };
+    wasAdoption = true;
+    log('info', 'adopting external session on first touch', {
+      threadId,
+      agent,
+      sessionId: ea.sessionId,
+      cwd: resumeCwd,
+      source: ea.source,
+    });
+  }
+
   log('event', 'reply received', {
     threadId,
+    agent,
     author: payload.author,
     messageId: payload.messageId,
-    hasBinding: !!binding,
+    hasSession: !!session,
   });
 
   // Permission-relay replies: resolve the pending request inside the driver and
@@ -85,10 +157,13 @@ const handleEvent = async (sseEvent) => {
   // indicator drops whether the turn succeeds, skips, or throws.
   emitActivity(threadId, 'working');
   try {
+    // The driver receives a flat per-agent session as `binding` — the v1
+    // driver contract is unchanged. v1.1 just keeps one such session per
+    // agent on the thread, so a claude<->codex switch resumes each side.
     const result = await drive({
       threadId,
       projectDir: cfg.projectDir,
-      binding,
+      binding: session,
       payload,
       log,
     });
@@ -96,22 +171,27 @@ const handleEvent = async (sseEvent) => {
     if (
       result &&
       result.sessionId &&
-      (!binding || binding.sessionId !== result.sessionId)
+      (!session || session.sessionId !== result.sessionId || wasAdoption)
     ) {
-      setBinding(state, threadId, {
-        sessionId: result.sessionId,
-        projectDir: result.projectDir,
-        jsonlPath: result.jsonlPath,
-        lastJsonlMtimeMs: result.lastJsonlMtimeMs || null,
-        agentId: cfg.agentId,
-        createdAt: new Date().toISOString(),
-        lastDriveAt: new Date().toISOString(),
-      });
-      log('info', 'binding created', { threadId, sessionId: result.sessionId });
-    } else if (binding && !result.skipped) {
-      binding.lastDriveAt = new Date().toISOString();
+      setAgentSession(
+        state,
+        threadId,
+        agent,
+        {
+          sessionId: result.sessionId,
+          projectDir: result.projectDir,
+          jsonlPath: result.jsonlPath,
+          lastJsonlMtimeMs: result.lastJsonlMtimeMs || null,
+          createdAt: new Date().toISOString(),
+          lastDriveAt: new Date().toISOString(),
+        },
+        { agentId: cfg.agentId },
+      );
+      log('info', 'session bound', { threadId, agent, sessionId: result.sessionId });
+    } else if (session && !result.skipped) {
+      session.lastDriveAt = new Date().toISOString();
       if (result && result.lastJsonlMtimeMs) {
-        binding.lastJsonlMtimeMs = result.lastJsonlMtimeMs;
+        session.lastJsonlMtimeMs = result.lastJsonlMtimeMs;
       }
       saveState(state);
     }
@@ -126,16 +206,23 @@ const handleEvent = async (sseEvent) => {
 };
 
 const start = () => {
+  // Phase 2b — advertise capabilities to the bridge on connect so the UI
+  // picker can offer just the agents that are actually installable here.
+  const capabilities = detectCapabilities();
+
   log('info', 'starting daemon', {
     baseUrl: cfg.baseUrl,
     accountId: cfg.accountId,
     agentId: cfg.agentId,
-    agent: activeAgent(),
+    capabilities,
     projectDir: cfg.projectDir,
     boundThreads: Object.keys(state.bindings || {}),
   });
 
-  const url = cfg.baseUrl.replace(/\/$/, '') + '/api/bridge/stream';
+  const url = cfg.baseUrl.replace(/\/$/, '') +
+    '/api/bridge/stream' +
+    '?agentId=' + encodeURIComponent(cfg.agentId) +
+    '&capabilities=' + encodeURIComponent(capabilities.join(','));
   stream = startStream({
     url,
     // Re-read config on every (re)connect so a rotated token (via
@@ -155,6 +242,64 @@ const start = () => {
     },
     log,
   });
+
+  // Phase 6.1 — kick off the External Thread Discovery scanner. 10s startup
+  // delay (lets the SSE handshake settle first), then 30s ticks. Was defined
+  // but not invoked in beta.9 — fixed in beta.10.
+  startExternalSync();
+};
+
+// Phase 6.1 — External Thread Discovery. Every 30s, scan ~/.claude/projects
+// and ~/.codex/sessions for sessions that didn't originate from the bridge
+// and POST them to /api/bridge/external/sync. Fire-and-forget; failures log
+// and the next tick retries. The bridge dedups by (accountId, sessionId).
+const EXTERNAL_SCAN_INTERVAL_MS = 30000;
+let externalScanTimer = null;
+const ownedSessionIdsFromState = () => {
+  const ids = new Set();
+  const bindings = (state && state.bindings) || {};
+  for (const tid of Object.keys(bindings)) {
+    const b = bindings[tid] || {};
+    const sessions = b.sessions && typeof b.sessions === 'object'
+      ? b.sessions
+      : (b.sessionId ? { _flat: b } : {});
+    for (const k of Object.keys(sessions)) {
+      const s = sessions[k] || {};
+      if (s.sessionId) ids.add(String(s.sessionId));
+    }
+  }
+  return ids;
+};
+const externalScanTick = async () => {
+  try {
+    const all = scanExternalSessions();
+    const owned = ownedSessionIdsFromState();
+    const external = all.filter((s) => s && s.sessionId && !owned.has(String(s.sessionId)));
+    if (external.length === 0) return;
+    const r = await postExternalSync(cfg.agentId, external);
+    if (!r || !r.ok) {
+      log('warn', 'external sync rejected', {
+        status: r && r.status,
+        body: r && r.data,
+        count: external.length,
+      });
+    } else {
+      log('debug', 'external sync ok', {
+        sent: external.length,
+        upserted: (r.data && r.data.count) || 0,
+      });
+    }
+  } catch (e) {
+    log('warn', 'external scan failed', { error: e && e.message ? e.message : String(e) });
+  }
+};
+const startExternalSync = () => {
+  // Wait 10s after daemon start before the first scan so the SSE connection
+  // is established first. Reduces "cold start everything at once" noise.
+  setTimeout(() => {
+    externalScanTick();
+    externalScanTimer = setInterval(externalScanTick, EXTERNAL_SCAN_INTERVAL_MS);
+  }, 10000);
 };
 
 const shutdown = (signal) => {
@@ -162,6 +307,7 @@ const shutdown = (signal) => {
   stopped = true;
   log('info', 'shutting down', { signal });
   try { stream && stream.stop(); } catch (_) {}
+  if (externalScanTimer) { try { clearInterval(externalScanTimer); } catch (_) {} }
   setTimeout(() => process.exit(0), 200);
 };
 

package/src/driver.js

@@ -1,47 +1,72 @@
 'use strict';
 
-// Agent-agnostic driver selector. The daemon drives whichever coding agent the
-// operator configured — Claude (via the Claude Agent SDK) or Codex (via the
-// Codex SDK) — chosen by `agent` in config.json / the BRIDGE_AGENT env var.
-// Everything else in the daemon (SSE, state, the bridge HTTP client) is
-// agent-neutral; only the driver differs.
+// Dual-driver dispatch (v1.1).
 //
-// The codex driver is require()d lazily, so a Claude-only install never loads
-// @openai/codex-sdk (and vice versa).
+// v1 resolved ONE agent at startup and drove only that. v1.1 makes the daemon
+// agent-agnostic per event: it can drive BOTH Claude (Claude Agent SDK) and
+// Codex (Codex SDK), and routes each bridge event to the right driver by the
+// thread's `agent` field (`payload.agent`, set server-side from the thread's
+// routing record).
+//
+// Drivers are require()d lazily and cached — a machine that only ever runs
+// Claude threads never pays to load @openai/codex-sdk, and vice versa.
 
 const { loadConfig } = require('./config');
 
-let resolved = null;
+const KNOWN_AGENTS = ['claude', 'codex', 'opencode'];
+
+const cache = {};
 
-const pick = () => {
-  if (resolved) return resolved;
-  let agent = 'claude';
+const loadDriver = (name) => {
+  if (cache[name]) return cache[name];
+  let mod;
+  if (name === 'codex') mod = require('./codex-driver');
+  else if (name === 'opencode') mod = require('./opencode-driver');
+  else mod = require('./claude-driver');
+  cache[name] = mod;
+  return mod;
+};
+
+// Fallback agent for events that arrive without an explicit `agent` — an
+// older bridge, or a thread created before v1.1. Reads config.agent (the v1
+// init choice), else 'claude'.
+let fallbackAgent = null;
+const getFallbackAgent = () => {
+  if (fallbackAgent) return fallbackAgent;
+  let a = 'claude';
   try {
-    agent = (loadConfig().agent || 'claude').toLowerCase();
+    a = (loadConfig().agent || 'claude').toLowerCase();
   } catch (_) {
     // config unreadable — default to claude
   }
-  if (agent === 'codex') {
-    resolved = { name: 'codex', mod: require('./codex-driver') };
-  } else {
-    resolved = { name: 'claude', mod: require('./claude-driver') };
-  }
-  return resolved;
+  fallbackAgent = KNOWN_AGENTS.indexOf(a) !== -1 ? a : 'claude';
+  return fallbackAgent;
 };
 
-const drive = (params) => pick().mod.drive(params);
+// Resolve which agent a bridge event targets.
+const agentFor = (payload) => {
+  const a = payload && payload.agent ? String(payload.agent).toLowerCase() : '';
+  if (KNOWN_AGENTS.indexOf(a) !== -1) return a;
+  return getFallbackAgent();
+};
+
+// Drive one bridge event with the agent its thread is bound to.
+const drive = (params) => {
+  const name = agentFor(params && params.payload);
+  return loadDriver(name).drive(params);
+};
 
-// Permission relay is Claude-only — Codex exposes no per-tool callback. For a
-// Codex daemon this is always a no-op so the reply path goes straight to
-// drive(); for Claude it delegates to the real relay resolver.
+// Permission relay is Claude-only — the Codex SDK exposes no per-tool callback.
+// We delegate to the claude driver's resolver regardless of the thread's agent:
+// it keys on threadId against its own pending-request map, so a codex thread
+// (which never has a pending claude request) simply returns false and the
+// reply falls through to drive().
 const tryResolvePermission = (threadId, body, log) => {
-  const p = pick();
-  if (typeof p.mod.tryResolvePermission === 'function') {
-    return p.mod.tryResolvePermission(threadId, body, log);
+  const claude = loadDriver('claude');
+  if (typeof claude.tryResolvePermission === 'function') {
+    return claude.tryResolvePermission(threadId, body, log);
   }
   return false;
 };
 
-const activeAgent = () => pick().name;
-
-module.exports = { drive, tryResolvePermission, activeAgent };
+module.exports = { drive, tryResolvePermission, agentFor, KNOWN_AGENTS };

package/src/external-scanner.js

@@ -0,0 +1,244 @@
+'use strict';
+
+// Phase 6.1 — External Thread Discovery (scanner half).
+//
+// Scans the local filesystem for AI coding sessions started OUTSIDE the bridge
+// and returns a flat list of session records the daemon can POST to
+// /api/bridge/external/sync. The bridge UI then renders them alongside
+// bridge-owned threads — single pane of glass over all the user's AI work.
+//
+// Sources scanned:
+//   - Claude Code (CLI + VSCode Claude extension): both write JSONL session
+//     files at ~/.claude/projects/<encoded-projectdir>/<sessionId>.jsonl
+//   - Codex CLI: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<sessionId>.jsonl
+//   - opencode is NOT scanned — its SDK is server-bound, no shared JSONL store
+//   - Web tools (claude.ai chat, ChatGPT) are out of reach by design
+//
+// Privacy: we extract metadata + the LAST message preview only (1–2 lines,
+// capped at 200 chars). Full transcripts NEVER leave the user's machine.
+// The daemon POSTs the extracted records; the bridge stores them in the
+// agent_bridge_external_sessions Mongo collection.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+const CODEX_DIR = path.join(os.homedir(), '.codex', 'sessions');
+
+const PREVIEW_MAX_CHARS = 200;
+const TAIL_READ_BYTES = 8192; // read the last 8KB of each JSONL for the last message
+
+// 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.
+const readTail = (filePath, maxBytes = TAIL_READ_BYTES) => {
+  let fd = null;
+  try {
+    const stat = fs.statSync(filePath);
+    const size = stat.size;
+    const start = Math.max(0, size - maxBytes);
+    const len = size - start;
+    if (len <= 0) return '';
+    fd = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    return buf.toString('utf8');
+  } 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
+// drifted across SDK versions.
+const extractLastMessage = (jsonlTail) => {
+  if (!jsonlTail) return null;
+  const lines = jsonlTail.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let obj;
+    try {
+      obj = JSON.parse(lines[i]);
+    } catch (_) {
+      continue;
+    }
+
+    // ── Claude Code session JSONL shapes ─────────────────────────────────
+    // Common:
+    //   { type: 'user',      message: { role: 'user',      content: '...' } }
+    //   { type: 'assistant', message: { role: 'assistant', content: [{type:'text', text:'...'}, ...] } }
+    if (obj && obj.message && (obj.message.role || obj.type)) {
+      const role = obj.message.role || (obj.type === 'user' ? 'user' : 'assistant');
+      let raw = obj.message.content;
+      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.trim();
+      if (text) return { author: role === 'user' ? 'user' : 'assistant', preview: text.slice(0, PREVIEW_MAX_CHARS) };
+    }
+
+    // ── Codex SDK rollout shapes ────────────────────────────────────────
+    //   { record_type: 'message', role: 'assistant', content: [{type:'text', text:'...'}] }
+    //   { type: 'message', role: 'user', content: '...' }
+    //   { event: 'output_text', text: '...', role: 'assistant' }
+    if (obj && (obj.role || obj.event) && (obj.content || obj.text)) {
+      const role = obj.role || (obj.event === 'input_text' ? 'user' : 'assistant');
+      let raw = obj.content != null ? obj.content : obj.text;
+      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.trim();
+      if (text) return { author: role === 'user' ? 'user' : 'assistant', preview: text.slice(0, PREVIEW_MAX_CHARS) };
+    }
+  }
+  return null;
+};
+
+// Decode Claude's project-dir filename encoding back to a path-like string.
+// Claude turns `/Users/divyansh/foo` → `-Users-divyansh-foo`. We can't
+// perfectly reverse it (project names with literal `-` are ambiguous), but
+// for display purposes leading-dash → leading-slash + dashes → slashes is
+// usually close enough. The BridgeExternal stores both the raw encoded
+// projectDir AND a decoded label; the view route picks the friendlier one.
+const decodeClaudeProjectDir = (encoded) => {
+  if (!encoded) return '';
+  if (encoded.startsWith('-')) {
+    return '/' + encoded.slice(1).replace(/-/g, '/');
+  }
+  return encoded.replace(/-/g, '/');
+};
+
+// Scan ~/.claude/projects/<encoded-projectdir>/<sessionId>.jsonl
+const scanClaude = () => {
+  const out = [];
+  let topEntries;
+  try { topEntries = fs.readdirSync(CLAUDE_DIR); } catch (_) { return out; }
+
+  for (const entry of topEntries) {
+    const projectPath = path.join(CLAUDE_DIR, entry);
+    let projectStat;
+    try { projectStat = fs.statSync(projectPath); } catch (_) { continue; }
+    if (!projectStat.isDirectory()) continue;
+
+    let sessionFiles;
+    try { sessionFiles = fs.readdirSync(projectPath); } catch (_) { continue; }
+
+    for (const file of sessionFiles) {
+      if (!file.endsWith('.jsonl')) continue;
+      const sessionId = file.slice(0, -'.jsonl'.length);
+      const filePath = path.join(projectPath, file);
+      let stat;
+      try { stat = fs.statSync(filePath); } catch (_) { continue; }
+      const tail = readTail(filePath);
+      const lastMsg = extractLastMessage(tail);
+      out.push({
+        source: 'claude',
+        sessionId,
+        projectDir: entry,                         // raw encoded form
+        projectName: decodeClaudeProjectDir(entry), // best-effort decoded
+        lastActivityAt: stat.mtimeMs,
+        lastMessagePreview: lastMsg ? lastMsg.preview : '',
+        lastMessageAuthor: lastMsg ? lastMsg.author : null,
+      });
+    }
+  }
+  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.
+const scanCodex = () => {
+  const out = [];
+  let years;
+  try { years = fs.readdirSync(CODEX_DIR); } catch (_) { return out; }
+
+  for (const y of years) {
+    if (!/^\d{4}$/.test(y)) continue;
+    const yPath = path.join(CODEX_DIR, y);
+    let months;
+    try { months = fs.readdirSync(yPath); } catch (_) { continue; }
+    for (const m of months) {
+      if (!/^\d{2}$/.test(m)) continue;
+      const mPath = path.join(yPath, m);
+      let days;
+      try { days = fs.readdirSync(mPath); } catch (_) { continue; }
+      for (const d of days) {
+        if (!/^\d{2}$/.test(d)) continue;
+        const dPath = path.join(mPath, d);
+        let files;
+        try { files = fs.readdirSync(dPath); } catch (_) { continue; }
+        for (const f of files) {
+          if (!f.startsWith('rollout-') || !f.endsWith('.jsonl')) continue;
+          // session id is the last hex/uuid block before .jsonl
+          const sidMatch = f.match(/-([0-9a-f-]{8,})\.jsonl$/i);
+          if (!sidMatch) continue;
+          const sessionId = sidMatch[1];
+          const filePath = path.join(dPath, f);
+          let stat;
+          try { stat = fs.statSync(filePath); } catch (_) { continue; }
+
+          // Read the first KB to pull the session-meta's working directory.
+          let projectDir = '';
+          let fd = null;
+          try {
+            fd = fs.openSync(filePath, 'r');
+            const headBuf = Buffer.alloc(Math.min(2048, stat.size));
+            fs.readSync(fd, headBuf, 0, headBuf.length, 0);
+            const firstLine = headBuf.toString('utf8').split(/\r?\n/)[0] || '';
+            try {
+              const meta = JSON.parse(firstLine);
+              projectDir = String(
+                meta?.cwd ||
+                meta?.workingDirectory ||
+                meta?.working_directory ||
+                meta?.session_meta?.cwd ||
+                meta?.payload?.cwd ||
+                ''
+              );
+            } catch (_) { /* not a meta line — leave projectDir blank */ }
+          } catch (_) {} finally {
+            if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} }
+          }
+
+          const tail = readTail(filePath);
+          const lastMsg = extractLastMessage(tail);
+          out.push({
+            source: 'codex',
+            sessionId,
+            projectDir: projectDir || `${y}/${m}/${d}`,
+            projectName: projectDir || null,
+            lastActivityAt: stat.mtimeMs,
+            lastMessagePreview: lastMsg ? lastMsg.preview : '',
+            lastMessageAuthor: lastMsg ? lastMsg.author : null,
+          });
+        }
+      }
+    }
+  }
+  return out;
+};
+
+// Public entry: returns a flat list of every external session found.
+// Synchronous on purpose — the daemon calls this on a 30s timer and the
+// total IO is dominated by readdir + a single readSync per file. Async
+// would only complicate retry/cancel semantics with no real benefit.
+const scanAll = () => {
+  const claude = scanClaude();
+  const codex = scanCodex();
+  return claude.concat(codex);
+};
+
+module.exports = { scanAll, scanClaude, scanCodex, extractLastMessage, decodeClaudeProjectDir };