@obtoai/agent-bridge 0.1.0-beta.1

package/cli/status.js

@@ -0,0 +1,48 @@
+'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?"
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const STATE_PATH = path.join(os.homedir(), '.agent-bridge-daemon', 'state.json');
+
+let state;
+try {
+  state = JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+} catch (_) {
+  console.log('No state file yet at ' + STATE_PATH);
+  console.log('(The daemon writes this after it drives its first thread session.)');
+  process.exit(0);
+}
+
+const bindings = state && state.bindings ? state.bindings : {};
+const threads = Object.keys(bindings).sort();
+
+if (threads.length === 0) {
+  console.log('No thread bindings yet.');
+  process.exit(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';
+};
+
+console.log('Thread                               Session ID                            Last drive');
+console.log('-'.repeat(95));
+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));
+});
+console.log('');
+console.log('JSONLs at: ' + (bindings[threads[0]] && bindings[threads[0]].projectDir
+  ? '~/.claude/projects/' + bindings[threads[0]].projectDir.replace(/\//g, '-') + '/'
+  : 'unknown'));

package/cli/whoami.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// `obto-bridge whoami` — hit GET /api/bridge/whoami with the configured
+// Bearer token and print the result. Verifies (1) config is valid,
+// (2) bridge is reachable, (3) token resolves to an active account.
+
+const { loadConfig } = require('../src/config');
+
+const main = async () => {
+  let cfg;
+  try {
+    cfg = loadConfig();
+  } catch (err) {
+    console.error('error: ' + (err && err.message ? err.message : err));
+    console.error('Run `obto-bridge init` first.');
+    process.exit(1);
+  }
+
+  const url = cfg.baseUrl.replace(/\/$/, '') + '/api/bridge/whoami';
+  let res;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        'OBTO-ORIGIN-HOST': cfg.originHost,
+        Authorization: 'Bearer ' + cfg.apiToken,
+      },
+      cache: 'no-store',
+    });
+  } catch (err) {
+    console.error('error: cannot reach ' + url);
+    console.error('  ' + (err && err.message ? err.message : err));
+    process.exit(2);
+  }
+
+  const body = await res.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (_) {
+    parsed = { _rawBody: body };
+  }
+
+  if (!res.ok) {
+    console.error('HTTP ' + res.status + ' — ' + (parsed && parsed.error ? parsed.error : 'request failed'));
+    if (res.status === 401) {
+      console.error('Your API token is invalid or the account is suspended. Email support@obto.co.');
+    }
+    process.exit(3);
+  }
+
+  const a = parsed.account || {};
+  console.log('✓ Connected to ' + cfg.baseUrl);
+  console.log('');
+  console.log('  Account:    ' + (a.accountId || '?'));
+  console.log('  Username:   @' + (a.basicAuthUser || '?'));
+  console.log('  Email:      ' + (a.email || '?'));
+  console.log('  Status:     ' + (a.status || '?'));
+  console.log('  Token:      ' + (a.apiTokenPrefix || '?') + '…');
+  console.log('  Agent name: ' + (cfg.agentId || '?'));
+  console.log('  Project:    ' + (cfg.projectDir || '?'));
+  console.log('');
+  console.log('Server time: ' + (parsed.server && parsed.server.time ? parsed.server.time : '?'));
+};
+
+main().catch((err) => {
+  console.error('whoami failed: ' + (err && err.message ? err.message : err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@obtoai/agent-bridge",
+  "version": "0.1.0-beta.1",
+  "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.",
+  "homepage": "https://github.com/obto-inc/agent-bridge",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/obto-inc/agent-bridge.git"
+  },
+  "bugs": "https://github.com/obto-inc/agent-bridge/issues",
+  "main": "src/daemon.js",
+  "bin": {
+    "obto-bridge": "bin/obto-bridge.js"
+  },
+  "scripts": {
+    "start": "node bin/obto-bridge.js start"
+  },
+  "files": [
+    "bin",
+    "src",
+    "cli",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
+    "@openai/codex-sdk": "^0.130.0"
+  }
+}

package/src/bridge-http.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// HTTP client for talking to the OBTO bridge from the daemon. Bearer auth
+// (per-account token), sets the OBTO-ORIGIN-HOST header so requests route
+// to the ob-agent-bridge app even when its DNS hasn't propagated.
+
+const { loadConfig } = require('./config');
+
+// No caching. loadConfig() always re-reads ~/.obto-bridge/config.json so a
+// token rotation (which rewrites the file) takes effect on the next request.
+// File reads are local and tiny — cost is negligible.
+const getCfg = () => loadConfig();
+
+const buildHeaders = (extra) => {
+  const c = getCfg();
+  return Object.assign(
+    {
+      'Content-Type': 'application/json',
+      'OBTO-ORIGIN-HOST': c.originHost,
+      Authorization: 'Bearer ' + c.apiToken,
+    },
+    extra || {},
+  );
+};
+
+const postJson = async (path, body) => {
+  const c = getCfg();
+  const url = c.baseUrl.replace(/\/$/, '') + path;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: buildHeaders(),
+    body: JSON.stringify(body),
+  });
+  let data;
+  const text = await res.text();
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch (_) {
+    data = { _rawBody: text };
+  }
+  return { status: res.status, ok: res.ok, data };
+};
+
+const getJson = async (path) => {
+  const c = getCfg();
+  const url = c.baseUrl.replace(/\/$/, '') + path;
+  const res = await fetch(url, {
+    method: 'GET',
+    headers: buildHeaders({ Accept: 'application/json' }),
+    cache: 'no-store',
+  });
+  let data;
+  const text = await res.text();
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch (_) {
+    data = { _rawBody: text };
+  }
+  return { status: res.status, ok: res.ok, data };
+};
+
+// Post a message via the agent-side /api/message route. Used both for normal
+// agent posts (status/result/etc.) and for permission-relay questions.
+const postMessage = (payload) => postJson('/api/message', payload);
+
+// Read recent messages on a thread, optionally since an ISO cursor.
+const getMessages = (threadId, sinceCursor) => {
+  const qs =
+    'threadId=' +
+    encodeURIComponent(String(threadId || '')) +
+    (sinceCursor ? '&since=' + encodeURIComponent(String(sinceCursor)) : '');
+  return getJson('/api/messages?' + qs);
+};
+
+// Transient "agent is working / idle" signal. Fire-and-forget from the daemon
+// around each Claude turn so the browser UI can show a thinking indicator.
+// Not persisted server-side — pure RMQ pub/sub via BridgeBroker.
+const postAgentActivity = (threadId, state) =>
+  postJson('/api/bridge/agent-activity', { threadId, state });
+
+module.exports = {
+  getCfg,
+  buildHeaders,
+  postMessage,
+  getMessages,
+  postAgentActivity,
+};

package/src/bridge-mcp-server.js

@@ -0,0 +1,125 @@
+'use strict';
+
+// In-process MCP server exposed to daemon-spawned Claude sessions. Each tool
+// wraps the daemon's authenticated HTTP client (basic auth → /api/...). Avoids
+// requiring the spawned session to OAuth into OBTO's external MCP server.
+
+const { z } = require('zod/v4');
+const bridgeHttp = require('./bridge-http');
+
+let cached = null;
+
+const buildBridgeMcpServer = async ({ log }) => {
+  if (cached) return cached;
+
+  const sdk = await import('@anthropic-ai/claude-agent-sdk');
+  const { createSdkMcpServer, tool } = sdk;
+
+  const bridgePost = tool(
+    'bridge_post',
+    'Post a message to a thread on the OBTO Agent Bridge. THIS IS THE ONLY WAY for ' +
+      'this session to communicate with the human who triggered the work. Plain text ' +
+      'replies in the conversation are invisible to them. Use kind="result" for the ' +
+      'finished answer, "status" for a progress update, "question" if you need ' +
+      'clarification before continuing, "error" if something failed.',
+    {
+      threadId: z.string().min(1).describe(
+        'Thread to post to. Use the same threadId that was given to you in the ' +
+          'envelope of the message you are responding to.',
+      ),
+      body: z.string().min(1).describe('Message content. Plain text or markdown.'),
+      kind: z.enum(['status', 'question', 'result', 'error']).optional().describe(
+        'Message kind. Defaults to "result".',
+      ),
+      author: z.string().optional().describe(
+        'Optional author override; defaults to "claude-bridge".',
+      ),
+    },
+    async ({ threadId, body, kind, author }) => {
+      try {
+        const r = await bridgeHttp.postMessage({
+          threadId,
+          body,
+          kind: kind || 'result',
+          author: author || 'claude-bridge',
+          role: 'agent',
+        });
+        if (!r.ok) {
+          if (log) log('error', 'bridge_post HTTP failed', { status: r.status });
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'bridge_post failed: HTTP ' + r.status + ' ' + JSON.stringify(r.data),
+              },
+            ],
+            isError: true,
+          };
+        }
+        return {
+          content: [
+            {
+              type: 'text',
+              text: 'Posted to bridge thread "' + threadId + '" (kind=' + (kind || 'result') + '). messageId=' +
+                ((r.data && r.data.message && r.data.message._id) || '?'),
+            },
+          ],
+        };
+      } catch (e) {
+        if (log) log('error', 'bridge_post threw', { error: e && e.message });
+        return {
+          content: [
+            { type: 'text', text: 'bridge_post threw: ' + (e && e.message ? e.message : String(e)) },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  const bridgeThreadRead = tool(
+    'bridge_thread_read',
+    'Read recent messages on a bridge thread. Use to load context when resuming a ' +
+      'session, or to check for human replies after asking a question.',
+    {
+      threadId: z.string().min(1).describe('Thread to read.'),
+      sinceCursor: z.string().optional().describe(
+        'ISO 8601 timestamp; only return messages newer than this. Useful for ' +
+          'incremental polling so you do not re-process old messages.',
+      ),
+    },
+    async ({ threadId, sinceCursor }) => {
+      try {
+        const r = await bridgeHttp.getMessages(threadId, sinceCursor);
+        if (!r.ok) {
+          return {
+            content: [{ type: 'text', text: 'bridge_thread_read failed: HTTP ' + r.status }],
+            isError: true,
+          };
+        }
+        return {
+          content: [{ type: 'text', text: JSON.stringify(r.data, null, 2) }],
+        };
+      } catch (e) {
+        return {
+          content: [
+            { type: 'text', text: 'bridge_thread_read threw: ' + (e && e.message ? e.message : String(e)) },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  cached = createSdkMcpServer({
+    name: 'bridge',
+    version: '0.1.0',
+    tools: [bridgePost, bridgeThreadRead],
+    alwaysLoad: true,
+  });
+
+  if (log) log('info', 'in-process bridge MCP server ready', { tools: ['bridge_post', 'bridge_thread_read'] });
+  return cached;
+};
+
+module.exports = { buildBridgeMcpServer };