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

package/cli/status.js

@@ -1,7 +1,7 @@
 'use strict';
 
-// `obto-bridge status` — read local state.json and print thread→session bindings.
-// Read-only; useful for "did the daemon ever drive this thread?"
+// `obto-bridge status` — read local state.json and print thread→session
+// bindings. Read-only. v1.1: a thread keeps one session per agent.
 
 const fs = require('fs');
 const path = require('path');
@@ -29,20 +29,33 @@ if (threads.length === 0) {
 const fmtAge = (iso) => {
   if (!iso) return '?';
   const ms = Date.now() - new Date(iso).getTime();
-  if (ms < 60_000) return Math.floor(ms / 1000) + 's ago';
-  if (ms < 3_600_000) return Math.floor(ms / 60_000) + 'm ago';
-  if (ms < 86_400_000) return Math.floor(ms / 3_600_000) + 'h ago';
-  return Math.floor(ms / 86_400_000) + 'd ago';
+  if (ms < 60000) return Math.floor(ms / 1000) + 's ago';
+  if (ms < 3600000) return Math.floor(ms / 60000) + 'm ago';
+  if (ms < 86400000) return Math.floor(ms / 3600000) + 'h ago';
+  return Math.floor(ms / 86400000) + 'd ago';
 };
 
-console.log('Thread                               Session ID                            Last drive');
-console.log('-'.repeat(95));
+console.log('Thread                               Agent   Session ID                            Last drive');
+console.log('-'.repeat(100));
 threads.forEach((t) => {
-  const b = bindings[t];
-  const sid = (b.sessionId || '').slice(0, 36);
-  console.log(t.padEnd(36) + ' ' + sid.padEnd(38) + ' ' + fmtAge(b.lastDriveAt));
+  const b = bindings[t] || {};
+  // v1.1 per-agent sessions; tolerate a stray un-migrated v1 flat binding.
+  const sessions = b.sessions && typeof b.sessions === 'object'
+    ? b.sessions
+    : (b.sessionId ? { claude: b } : {});
+  const agents = Object.keys(sessions);
+  if (agents.length === 0) {
+    console.log(t.padEnd(36) + ' (no session yet)');
+    return;
+  }
+  agents.forEach((agent, i) => {
+    const s = sessions[agent] || {};
+    const sid = String(s.sessionId || '').slice(0, 36);
+    console.log(
+      (i === 0 ? t : '').padEnd(36) + ' ' +
+      agent.padEnd(7) + ' ' +
+      sid.padEnd(38) + ' ' +
+      fmtAge(s.lastDriveAt),
+    );
+  });
 });
-console.log('');
-console.log('JSONLs at: ' + (bindings[threads[0]] && bindings[threads[0]].projectDir
-  ? '~/.claude/projects/' + bindings[threads[0]].projectDir.replace(/\//g, '-') + '/'
-  : 'unknown'));

package/package.json

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

@@ -2,8 +2,8 @@
 
 const { loadConfig } = require('./config');
 const { startStream } = require('./stream-client');
-const { loadState, saveState, getBinding, setBinding } = require('./state');
-const { drive, tryResolvePermission, activeAgent } = require('./driver');
+const { loadState, saveState, getAgentSession, setAgentSession } = require('./state');
+const { drive, tryResolvePermission, agentFor } = require('./driver');
 const { postAgentActivity } = require('./bridge-http');
 
 const log = (level, msg, data) => {
@@ -67,12 +67,15 @@ const handleEvent = async (sseEvent) => {
     return;
   }
 
-  const binding = getBinding(state, threadId);
+  // v1.1 — which agent this thread is bound to (server-set, on the event).
+  const agent = agentFor(payload);
+  const session = getAgentSession(state, threadId, agent);
   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 +88,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 +102,27 @@ const handleEvent = async (sseEvent) => {
     if (
       result &&
       result.sessionId &&
-      (!binding || binding.sessionId !== result.sessionId)
+      (!session || session.sessionId !== result.sessionId)
     ) {
-      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);
     }
@@ -130,7 +141,7 @@ const start = () => {
     baseUrl: cfg.baseUrl,
     accountId: cfg.accountId,
     agentId: cfg.agentId,
-    agent: activeAgent(),
+    agents: ['claude', 'codex'],
     projectDir: cfg.projectDir,
     boundThreads: Object.keys(state.bindings || {}),
   });

package/src/driver.js

@@ -1,47 +1,71 @@
 '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'];
+
+const cache = {};
 
-const pick = () => {
-  if (resolved) return resolved;
-  let agent = 'claude';
+const loadDriver = (name) => {
+  if (cache[name]) return cache[name];
+  const mod = name === 'codex'
+    ? require('./codex-driver')
+    : 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 = a === 'codex' ? 'codex' : '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/state.js

@@ -13,18 +13,48 @@ const ensureDir = () => {
   } catch (_) {}
 };
 
-// Schema:
+// Schema (v1.1 — per-agent sessions):
 // {
 //   "bindings": {
 //     "<threadId>": {
-//       "sessionId": "<uuid>",
-//       "projectDir": "/abs/path",
-//       "jsonlPath": "/.../<sid>.jsonl",
 //       "createdAt": "iso-ts",
-//       "lastDriveAt": "iso-ts"
+//       "agentId": "<machine id>",
+//       "sessions": {
+//         "claude": { "sessionId", "projectDir", "jsonlPath", "lastJsonlMtimeMs", "lastDriveAt" },
+//         "codex":  { "sessionId", "projectDir", "lastDriveAt" }
+//       }
 //     }, ...
 //   }
 // }
+// A thread keeps one session PER agent, so switching claude<->codex and back
+// resumes each engine's own context. v1 flat bindings are migrated on load.
+
+// Migrate a v1 flat binding ({ sessionId, projectDir, ... }) into the v1.1
+// per-agent shape. The flat session is filed under 'claude' — the v1 default
+// agent. A v1 codex daemon's threads simply first-touch codex fresh after the
+// upgrade, which is acceptable (a switch is a fresh first-touch anyway).
+const migrateBinding = (b) => {
+  if (!b || typeof b !== 'object') {
+    return { createdAt: null, agentId: null, sessions: {} };
+  }
+  if (b.sessions && typeof b.sessions === 'object') return b; // already v1.1
+  const out = {
+    createdAt: b.createdAt || null,
+    agentId: b.agentId || null,
+    sessions: {},
+  };
+  if (b.sessionId) {
+    out.sessions.claude = {
+      sessionId: b.sessionId,
+      projectDir: b.projectDir,
+      jsonlPath: b.jsonlPath,
+      lastJsonlMtimeMs: b.lastJsonlMtimeMs || null,
+      lastDriveAt: b.lastDriveAt || null,
+    };
+  }
+  return out;
+};
+
 const loadState = () => {
   let raw;
   try {
@@ -35,6 +65,10 @@ const loadState = () => {
   if (!raw.bindings || typeof raw.bindings !== 'object') {
     raw.bindings = {};
   }
+  // Migrate any v1 flat bindings to the per-agent shape.
+  for (const tid of Object.keys(raw.bindings)) {
+    raw.bindings[tid] = migrateBinding(raw.bindings[tid]);
+  }
   return raw;
 };
 
@@ -43,12 +77,33 @@ const saveState = (state) => {
   fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), 'utf8');
 };
 
+// The full per-thread binding ({ createdAt, agentId, sessions }), or null.
 const getBinding = (state, threadId) =>
   state.bindings && state.bindings[threadId] ? state.bindings[threadId] : null;
 
-const setBinding = (state, threadId, info) => {
-  state.bindings[threadId] = info;
+// One agent's session record on a thread, or null. The driver consumes this
+// flat shape directly — same contract as the v1 binding.
+const getAgentSession = (state, threadId, agent) => {
+  const b = getBinding(state, threadId);
+  if (!b || !b.sessions) return null;
+  return b.sessions[agent] || null;
+};
+
+// Store/replace one agent's session on a thread. Creates the binding if absent.
+const setAgentSession = (state, threadId, agent, session, meta) => {
+  let b = state.bindings[threadId];
+  if (!b || !b.sessions) {
+    b = {
+      createdAt: new Date().toISOString(),
+      agentId: (meta && meta.agentId) || null,
+      sessions: {},
+    };
+    state.bindings[threadId] = b;
+  }
+  if (meta && meta.agentId) b.agentId = meta.agentId;
+  b.sessions[agent] = session;
   saveState(state);
+  return b;
 };
 
 module.exports = {
@@ -57,5 +112,6 @@ module.exports = {
   loadState,
   saveState,
   getBinding,
-  setBinding,
+  getAgentSession,
+  setAgentSession,
 };