@obtoai/agent-bridge 0.1.0-beta.2 → 0.1.0-beta.20

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 };