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

package/README.md

@@ -2,7 +2,7 @@
 
 A local daemon that lets a coding agent — [Claude Code](https://claude.ai/code) or [OpenAI Codex](https://developers.openai.com/codex) — running on your machine be driven from the [OBTO Agent Bridge](https://obto.co) web UI, even when you're away from the keyboard.
 
-You post a message on a thread from your phone or laptop. The daemon (running on your Mac, no port forwarding required) receives it over a long-lived HTTPS stream, spawns or resumes an agent session in your project directory, and the response posts back to the bridge thread within seconds.
+You post a message on a thread from your phone or laptop. The daemon (running on your machine, no port forwarding required) receives it over a long-lived HTTPS stream, spawns or resumes an agent session in your project directory, and the response posts back to the bridge thread within seconds.
 
 ## Status
 
@@ -10,7 +10,7 @@ You post a message on a thread from your phone or laptop. The daemon (running on
 
 ## What you'll need
 
-- macOS or Linux, **Node.js 18.17+** (Windows support is in testing)
+- macOS, Linux, or Windows, **Node.js 18.17+**
 - One coding agent installed, with your own auth:
   - **Claude** — Claude Code / the Claude Agent SDK, billed to your Anthropic account; or
   - **Codex** — the `codex` CLI (`npm i -g @openai/codex`), signed in to your OpenAI/ChatGPT account
@@ -65,7 +65,7 @@ Now open the bridge UI in any browser, log in with the browser credentials from
 - Reply on an existing thread — daemon resumes the session bound to that thread
 - Start a new thread via the **+ New thread** button — daemon spawns a fresh session in your project directory
 
-Within ~5–10 seconds you should see Claude's reply appear back on the thread.
+Within ~5–10 seconds you should see the agent's reply appear back on the thread.
 
 ## Other commands
 
@@ -78,8 +78,8 @@ Within ~5–10 seconds you should see Claude's reply appear back on the thread.
 ## How it actually works
 
 ```
-Your phone        OBTO server                      Your Mac
-─────────         ───────────                      ────────
+Your phone        OBTO server                      Your machine
+─────────         ───────────                      ────────────
 [reply form] ──►  /api/reply ─► Mongo (durable)
                   └─►  RabbitMQ (publish bridge.<acct>.reply.<thread>)
                                                 ◄── /api/bridge/stream  (SSE, Bearer auth)
@@ -103,11 +103,15 @@ Key bits:
 
 The daemon runs your chosen agent on your machine with **your** credentials — Anthropic for `claude` (whatever Claude Code uses: `ANTHROPIC_API_KEY` or your Claude.ai session), or your OpenAI/ChatGPT account for `codex`. Every bridge-driven turn is a normal API call billed to you. We don't proxy.
 
-## Privacy and what we store
+## Data handling
 
-- Every message you and the agent post on a thread is stored in OBTO's Mongo. Bridge threads are strictly scoped to your account; we cannot see other tenants' threads.
-- Your daemon's `apiToken` is stored locally only; on the server we store a SHA-256 hash.
-- Right of erasure: email `support@obto.co` to delete your account and all associated messages.
+**Your model traffic never touches us.** The daemon runs on your machine and calls Anthropic or OpenAI with *your own* credentials. Your prompts, your code, and the model's responses pass directly between your machine and the model provider, under your own API account and its terms. OBTO does not proxy, route, or see that traffic.
+
+**What the bridge stores.** For threads to work, the messages you and the agent post are saved in OBTO's database — that's what makes a thread durable and readable from your phone. Threads are strictly scoped to your account; one tenant can never see another's. Your daemon's API token is stored server-side only as a SHA-256 hash; the plaintext token never leaves your local config file.
+
+**What we don't do with it.** OBTO does not use your bridge messages to train models, and does not sell or share your data with third parties.
+
+**Deletion.** Email `support@obto.co` to delete your account and every message associated with it.
 
 ## License
 

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.1",
+  "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,
 };