@owloops/browserbird 1.0.0

package/src/provider/claude.ts

@@ -0,0 +1,196 @@
+/** @fileoverview Claude Code CLI provider: arg building and stream-json parsing. */
+
+import type { ProviderModule, SpawnOptions, ProviderCommand } from './types.ts';
+import type { StreamEvent, ToolImage } from './stream.ts';
+
+type CompletionSubtype =
+  | 'success'
+  | 'error_max_turns'
+  | 'error_during_execution'
+  | 'error_max_budget_usd'
+  | 'error_max_structured_output_retries';
+
+function buildCommand(options: SpawnOptions): ProviderCommand {
+  const { message, sessionId, agent, mcpConfigPath } = options;
+
+  const args: string[] = [
+    '-p',
+    message,
+    '--output-format',
+    'stream-json',
+    '--model',
+    agent.model,
+    '--verbose',
+    '--max-turns',
+    String(agent.maxTurns),
+  ];
+
+  if (sessionId) {
+    args.push('--resume', sessionId);
+  }
+
+  if (agent.systemPrompt) {
+    args.push('--append-system-prompt', agent.systemPrompt);
+  }
+
+  if (mcpConfigPath) {
+    args.push('--mcp-config', mcpConfigPath);
+  }
+
+  if (agent.fallbackModel) {
+    args.push('--fallback-model', agent.fallbackModel);
+  }
+
+  args.push('--dangerously-skip-permissions');
+
+  const oauthToken = process.env['CLAUDE_CODE_OAUTH_TOKEN'];
+  const apiKey = process.env['ANTHROPIC_API_KEY'];
+  const env: Record<string, string> = oauthToken
+    ? { CLAUDE_CODE_OAUTH_TOKEN: oauthToken }
+    : apiKey
+      ? { ANTHROPIC_API_KEY: apiKey }
+      : {};
+
+  return { binary: 'claude', args, env };
+}
+
+/**
+ * Parses a single line of stream-json output into zero or more StreamEvents.
+ * Only extracts text, images, completion, and error events. Tool use/result
+ * events are internal to the agent and not surfaced to the channel layer.
+ */
+function parseStreamLine(line: string): StreamEvent[] {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith('{')) return [];
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(trimmed) as Record<string, unknown>;
+  } catch {
+    return [];
+  }
+
+  const eventType = parsed['type'] as string | undefined;
+  if (!eventType) return [];
+
+  switch (eventType) {
+    case 'system':
+      if (typeof parsed['session_id'] === 'string') {
+        return [
+          {
+            type: 'init',
+            sessionId: parsed['session_id'],
+            model: (parsed['model'] as string) ?? '',
+          },
+        ];
+      }
+      return [];
+
+    case 'assistant':
+      return parseAssistantContent(parsed);
+
+    case 'user':
+      return extractImages(parsed);
+
+    case 'result': {
+      const usage = parsed['usage'] as Record<string, unknown> | undefined;
+      const subtype = (parsed['subtype'] as CompletionSubtype | undefined) ?? 'success';
+      return [
+        {
+          type: 'completion',
+          subtype,
+          result: typeof parsed['result'] === 'string' ? parsed['result'] : '',
+          sessionId: (parsed['session_id'] as string) ?? '',
+          isError: (parsed['is_error'] as boolean) ?? false,
+          tokensIn: (usage?.['input_tokens'] as number) ?? 0,
+          tokensOut: (usage?.['output_tokens'] as number) ?? 0,
+          cacheCreationTokens: (usage?.['cache_creation_input_tokens'] as number) ?? 0,
+          cacheReadTokens: (usage?.['cache_read_input_tokens'] as number) ?? 0,
+          costUsd: (parsed['total_cost_usd'] as number) ?? 0,
+          durationMs: (parsed['duration_ms'] as number) ?? 0,
+          numTurns: (parsed['num_turns'] as number) ?? 0,
+        },
+      ];
+    }
+
+    case 'rate_limit_event': {
+      const info = parsed['rate_limit_info'] as Record<string, unknown> | undefined;
+      return [
+        {
+          type: 'rate_limit',
+          status: (info?.['status'] as string) ?? 'unknown',
+          resetsAt: (info?.['resetsAt'] as number) ?? 0,
+        },
+      ];
+    }
+
+    case 'error':
+      return [
+        {
+          type: 'error',
+          error:
+            typeof parsed['error'] === 'string' ? parsed['error'] : JSON.stringify(parsed['error']),
+        },
+      ];
+
+    default:
+      return [];
+  }
+}
+
+function parseAssistantContent(parsed: Record<string, unknown>): StreamEvent[] {
+  const msg = parsed['message'];
+  if (typeof msg === 'string') {
+    return [{ type: 'text_delta', delta: msg }];
+  }
+  if (!msg || typeof msg !== 'object') return [];
+
+  const content = (msg as Record<string, unknown>)['content'];
+  if (!Array.isArray(content)) return [];
+
+  const events: StreamEvent[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+    if (b['type'] === 'text' && typeof b['text'] === 'string') {
+      events.push({ type: 'text_delta', delta: b['text'] });
+    }
+  }
+  return events;
+}
+
+function extractImages(parsed: Record<string, unknown>): StreamEvent[] {
+  const msg = parsed['message'];
+  if (!msg || typeof msg !== 'object') return [];
+  const content = (msg as Record<string, unknown>)['content'];
+  if (!Array.isArray(content)) return [];
+
+  const images: ToolImage[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+    if (b['type'] !== 'tool_result') continue;
+
+    const inner = b['content'];
+    if (!Array.isArray(inner)) continue;
+    for (const item of inner) {
+      if (!item || typeof item !== 'object') continue;
+      const i = item as Record<string, unknown>;
+      if (i['type'] !== 'image') continue;
+      const source = i['source'] as Record<string, unknown> | undefined;
+      if (!source || source['type'] !== 'base64') continue;
+      images.push({
+        mediaType: (source['media_type'] as string) ?? 'image/png',
+        data: (source['data'] as string) ?? '',
+      });
+    }
+  }
+
+  if (images.length > 0) {
+    return [{ type: 'tool_images', images }];
+  }
+
+  return [];
+}
+
+export const claude: ProviderModule = { buildCommand, parseStreamLine };

package/src/provider/opencode.test.ts

@@ -0,0 +1,169 @@
+/** @fileoverview Tests for the OpenCode CLI stream parser. */
+
+import { describe, it } from 'node:test';
+import { deepStrictEqual, strictEqual } from 'node:assert';
+import { opencode } from './opencode.ts';
+
+describe('opencode parseStreamLine', () => {
+  it('parses step_start into init', () => {
+    const events = opencode.parseStreamLine(
+      '{"type":"step_start","timestamp":1000000,"sessionID":"ses_abc","part":{"sessionID":"ses_abc","type":"step-start"}}',
+    );
+    strictEqual(events.length, 1);
+    deepStrictEqual(events[0], { type: 'init', sessionId: 'ses_abc', model: '' });
+  });
+
+  it('parses text event', () => {
+    const events = opencode.parseStreamLine(
+      '{"type":"text","timestamp":1001000,"sessionID":"ses_abc","part":{"sessionID":"ses_abc","type":"text","text":"hello"}}',
+    );
+    strictEqual(events.length, 1);
+    deepStrictEqual(events[0], { type: 'text_delta', delta: 'hello' });
+  });
+
+  it('ignores intermediate step_finish (tool-calls)', () => {
+    opencode.parseStreamLine(
+      '{"type":"step_start","timestamp":1000000,"sessionID":"ses_x","part":{"sessionID":"ses_x","type":"step-start"}}',
+    );
+    const events = opencode.parseStreamLine(
+      '{"type":"step_finish","timestamp":1002000,"sessionID":"ses_x","part":{"sessionID":"ses_x","type":"step-finish","reason":"tool-calls","cost":0.01,"tokens":{"total":500,"input":400,"output":100,"reasoning":0,"cache":{"read":50,"write":200}}}}',
+    );
+    strictEqual(events.length, 0);
+  });
+
+  it('accumulates metrics across multi-step sessions', () => {
+    // Step 1: start
+    opencode.parseStreamLine(
+      '{"type":"step_start","timestamp":1000000,"sessionID":"ses_multi","part":{"sessionID":"ses_multi","type":"step-start"}}',
+    );
+    // Step 1: finish (tool-calls, not final)
+    opencode.parseStreamLine(
+      JSON.stringify({
+        type: 'step_finish',
+        timestamp: 1002000,
+        sessionID: 'ses_multi',
+        part: {
+          sessionID: 'ses_multi',
+          type: 'step-finish',
+          reason: 'tool-calls',
+          cost: 0.003,
+          tokens: {
+            total: 500,
+            input: 400,
+            output: 100,
+            reasoning: 0,
+            cache: { read: 50, write: 200 },
+          },
+        },
+      }),
+    );
+    // Step 2: start
+    opencode.parseStreamLine(
+      '{"type":"step_start","timestamp":1003000,"sessionID":"ses_multi","part":{"sessionID":"ses_multi","type":"step-start"}}',
+    );
+    // Step 2: finish (stop, final)
+    const events = opencode.parseStreamLine(
+      JSON.stringify({
+        type: 'step_finish',
+        timestamp: 1005000,
+        sessionID: 'ses_multi',
+        part: {
+          sessionID: 'ses_multi',
+          type: 'step-finish',
+          reason: 'stop',
+          cost: 0.001,
+          tokens: {
+            total: 200,
+            input: 150,
+            output: 50,
+            reasoning: 0,
+            cache: { read: 30, write: 100 },
+          },
+        },
+      }),
+    );
+
+    strictEqual(events.length, 1);
+    const c = events[0]!;
+    strictEqual(c.type, 'completion');
+    if (c.type === 'completion') {
+      strictEqual(c.tokensIn, 550);
+      strictEqual(c.tokensOut, 150);
+      strictEqual(c.cacheCreationTokens, 300);
+      strictEqual(c.cacheReadTokens, 80);
+      strictEqual(c.costUsd, 0.004);
+      strictEqual(c.durationMs, 5000);
+      strictEqual(c.numTurns, 2);
+      strictEqual(c.sessionId, 'ses_multi');
+    }
+  });
+
+  it('handles single-step sessions', () => {
+    opencode.parseStreamLine(
+      '{"type":"step_start","timestamp":2000000,"sessionID":"ses_single","part":{"sessionID":"ses_single","type":"step-start"}}',
+    );
+    const events = opencode.parseStreamLine(
+      JSON.stringify({
+        type: 'step_finish',
+        timestamp: 2001000,
+        sessionID: 'ses_single',
+        part: {
+          sessionID: 'ses_single',
+          type: 'step-finish',
+          reason: 'stop',
+          cost: 0.002,
+          tokens: {
+            total: 100,
+            input: 80,
+            output: 20,
+            reasoning: 0,
+            cache: { read: 0, write: 50 },
+          },
+        },
+      }),
+    );
+
+    strictEqual(events.length, 1);
+    const c = events[0]!;
+    strictEqual(c.type, 'completion');
+    if (c.type === 'completion') {
+      strictEqual(c.durationMs, 1000);
+      strictEqual(c.numTurns, 1);
+      strictEqual(c.tokensIn, 80);
+      strictEqual(c.tokensOut, 20);
+    }
+  });
+
+  it('parses simple error event', () => {
+    const events = opencode.parseStreamLine('{"type":"error","message":"auth failed"}');
+    strictEqual(events.length, 1);
+    deepStrictEqual(events[0], { type: 'error', error: 'auth failed' });
+  });
+
+  it('extracts message from nested API error', () => {
+    const events = opencode.parseStreamLine(
+      JSON.stringify({
+        type: 'error',
+        error: {
+          name: 'APIError',
+          data: { message: 'Your credit balance is too low', statusCode: 400 },
+        },
+      }),
+    );
+    strictEqual(events.length, 1);
+    deepStrictEqual(events[0], { type: 'error', error: 'Your credit balance is too low' });
+  });
+
+  it('falls back to error name when no message', () => {
+    const events = opencode.parseStreamLine(
+      JSON.stringify({ type: 'error', error: { name: 'UnknownError', data: {} } }),
+    );
+    strictEqual(events.length, 1);
+    deepStrictEqual(events[0], { type: 'error', error: 'UnknownError' });
+  });
+
+  it('returns empty for blank lines and non-json', () => {
+    strictEqual(opencode.parseStreamLine('').length, 0);
+    strictEqual(opencode.parseStreamLine('garbage').length, 0);
+  });
+});

package/src/provider/opencode.ts

@@ -0,0 +1,248 @@
+/** @fileoverview OpenCode CLI provider: arg building, workspace setup, and JSON stream parsing. */
+
+import { mkdirSync, writeFileSync, readFileSync, copyFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { ProviderModule, SpawnOptions, ProviderCommand } from './types.ts';
+import type { StreamEvent } from './stream.ts';
+import { logger } from '../core/logger.ts';
+
+const WORKSPACE_DIR = resolve('.browserbird', 'opencode');
+
+/**
+ * Translates a Claude-format MCP config into an opencode-format config.
+ *
+ * Claude format:  { mcpServers: { name: { type: "sse", url: "..." } } }
+ * OpenCode format: { mcp: { name: { type: "remote", url: "..." } } }
+ */
+function translateMcpConfig(
+  claudeConfig: Record<string, unknown>,
+): Record<string, Record<string, unknown>> {
+  const servers = (claudeConfig['mcpServers'] ?? {}) as Record<string, Record<string, unknown>>;
+  const result: Record<string, Record<string, unknown>> = {};
+
+  for (const [name, server] of Object.entries(servers)) {
+    const serverType = server['type'] as string | undefined;
+    const url = server['url'] as string | undefined;
+    const command = server['command'] as string | undefined;
+    const args = server['args'] as string[] | undefined;
+
+    if (serverType === 'sse' || serverType === 'streamable-http') {
+      if (url) {
+        result[name] = { type: 'remote', url };
+      }
+    } else if (serverType === 'stdio') {
+      if (command) {
+        const cmd = args ? [command, ...args] : [command];
+        const entry: Record<string, unknown> = { type: 'local', command: cmd };
+        const env = server['env'] as Record<string, string> | undefined;
+        if (env) entry['environment'] = env;
+        result[name] = entry;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Ensures the opencode workspace directory exists with the right config files.
+ * Writes opencode.json (MCP servers) and .opencode/agent/browserbird.md (system prompt).
+ */
+function ensureWorkspace(mcpConfigPath?: string, systemPrompt?: string): void {
+  mkdirSync(resolve(WORKSPACE_DIR, '.opencode', 'agent'), { recursive: true });
+
+  const config: Record<string, unknown> = {};
+
+  if (mcpConfigPath) {
+    try {
+      const raw = readFileSync(resolve(mcpConfigPath), 'utf-8');
+      const claudeConfig = JSON.parse(raw) as Record<string, unknown>;
+      const mcp = translateMcpConfig(claudeConfig);
+      if (Object.keys(mcp).length > 0) {
+        config['mcp'] = mcp;
+      }
+    } catch (err) {
+      logger.warn(
+        `opencode: failed to read MCP config at ${mcpConfigPath}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  writeFileSync(resolve(WORKSPACE_DIR, 'opencode.json'), JSON.stringify(config, null, 2) + '\n');
+
+  if (systemPrompt) {
+    const agentMd = `---\nmode: primary\n---\n\n${systemPrompt}\n`;
+    writeFileSync(resolve(WORKSPACE_DIR, '.opencode', 'agent', 'browserbird.md'), agentMd);
+  }
+
+  const agentsMd = resolve('AGENTS.md');
+  if (existsSync(agentsMd)) {
+    copyFileSync(agentsMd, resolve(WORKSPACE_DIR, 'AGENTS.md'));
+  }
+}
+
+/**
+ * Builds the `opencode run` command for a given agent config.
+ *
+ * @remarks `fallbackModel` is not yet supported by opencode.
+ * @see https://github.com/anomalyco/opencode/issues/7602
+ */
+function buildCommand(options: SpawnOptions): ProviderCommand {
+  const { message, sessionId, agent, mcpConfigPath } = options;
+
+  ensureWorkspace(mcpConfigPath, agent.systemPrompt);
+
+  const args: string[] = ['run', '--format', 'json', '-m', agent.model];
+
+  if (agent.systemPrompt) {
+    args.push('--agent', 'browserbird');
+  }
+
+  if (sessionId) {
+    args.push('--session', sessionId);
+  }
+
+  args.push(message);
+
+  const env: Record<string, string> = {};
+  const apiKey = process.env['ANTHROPIC_API_KEY'];
+  if (apiKey) env['ANTHROPIC_API_KEY'] = apiKey;
+  const openRouterKey = process.env['OPENROUTER_API_KEY'];
+  if (openRouterKey) env['OPENROUTER_API_KEY'] = openRouterKey;
+  const openAiKey = process.env['OPENAI_API_KEY'];
+  if (openAiKey) env['OPENAI_API_KEY'] = openAiKey;
+  const geminiKey = process.env['GEMINI_API_KEY'];
+  if (geminiKey) env['GEMINI_API_KEY'] = geminiKey;
+
+  return { binary: 'opencode', args, cwd: WORKSPACE_DIR, env };
+}
+
+interface MetricAccumulator {
+  startTimestamp: number;
+  stepCount: number;
+  tokensIn: number;
+  tokensOut: number;
+  cacheWrite: number;
+  cacheRead: number;
+  cost: number;
+}
+
+/** Per-session metric accumulators. Concurrent sessions each get their own entry. */
+const accumulators = new Map<string, MetricAccumulator>();
+
+function accumulateStep(sessionId: string, part: Record<string, unknown>): void {
+  const acc = accumulators.get(sessionId)!;
+  acc.stepCount++;
+  const tokens = part['tokens'] as Record<string, unknown> | undefined;
+  const cache = tokens?.['cache'] as Record<string, unknown> | undefined;
+  acc.tokensIn += (tokens?.['input'] as number) ?? 0;
+  acc.tokensOut += (tokens?.['output'] as number) ?? 0;
+  acc.cacheWrite += (cache?.['write'] as number) ?? 0;
+  acc.cacheRead += (cache?.['read'] as number) ?? 0;
+  acc.cost += (part['cost'] as number) ?? 0;
+}
+
+/**
+ * Parses a single line of opencode JSON output into zero or more StreamEvents.
+ *
+ * OpenCode emits these event types:
+ *   step_start  -> init (first one carries sessionID)
+ *   text        -> text_delta
+ *   tool_use    -> ignored (internal to the agent)
+ *   step_finish -> accumulates tokens/cost; final one (reason "stop") emits completion
+ *   error       -> error (connection/auth failures)
+ */
+function parseStreamLine(line: string): StreamEvent[] {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith('{')) return [];
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(trimmed) as Record<string, unknown>;
+  } catch {
+    return [];
+  }
+
+  const eventType = parsed['type'] as string | undefined;
+  if (!eventType) return [];
+  const part = parsed['part'] as Record<string, unknown> | undefined;
+  const timestamp = (parsed['timestamp'] as number) ?? 0;
+
+  switch (eventType) {
+    case 'step_start':
+      if (part && typeof part['sessionID'] === 'string') {
+        const sid = part['sessionID'];
+        if (!accumulators.has(sid)) {
+          accumulators.set(sid, {
+            startTimestamp: timestamp,
+            stepCount: 0,
+            tokensIn: 0,
+            tokensOut: 0,
+            cacheWrite: 0,
+            cacheRead: 0,
+            cost: 0,
+          });
+        }
+        return [
+          {
+            type: 'init',
+            sessionId: sid,
+            model: '',
+          },
+        ];
+      }
+      return [];
+
+    case 'text':
+      if (part && typeof part['text'] === 'string') {
+        return [{ type: 'text_delta', delta: part['text'] }];
+      }
+      return [];
+
+    case 'step_finish': {
+      if (!part) return [];
+      const sid = (part['sessionID'] as string) ?? '';
+      accumulateStep(sid, part);
+
+      const reason = part['reason'] as string | undefined;
+      if (reason !== 'stop') return [];
+
+      const acc = accumulators.get(sid)!;
+
+      const durationMs = timestamp > acc.startTimestamp ? timestamp - acc.startTimestamp : 0;
+      const completion: StreamEvent = {
+        type: 'completion',
+        subtype: 'success',
+        result: '',
+        sessionId: sid,
+        isError: false,
+        tokensIn: acc.tokensIn,
+        tokensOut: acc.tokensOut,
+        cacheCreationTokens: acc.cacheWrite,
+        cacheReadTokens: acc.cacheRead,
+        costUsd: acc.cost,
+        durationMs,
+        numTurns: acc.stepCount,
+      };
+
+      accumulators.delete(sid);
+      return [completion];
+    }
+
+    case 'error': {
+      const err = parsed['error'] as Record<string, unknown> | undefined;
+      const data = err?.['data'] as Record<string, unknown> | undefined;
+      const msg =
+        (typeof data?.['message'] === 'string' && data['message']) ||
+        (typeof parsed['message'] === 'string' && parsed['message']) ||
+        (typeof err?.['name'] === 'string' && err['name']) ||
+        JSON.stringify(parsed);
+      return [{ type: 'error', error: msg }];
+    }
+
+    default:
+      return [];
+  }
+}
+
+export const opencode: ProviderModule = { buildCommand, parseStreamLine };

package/src/provider/session.ts

@@ -0,0 +1,65 @@
+/** @fileoverview Session router: maps Slack threads to CLI sessions. */
+
+import type { AgentConfig, Config } from '../core/types.ts';
+import type { SessionRow } from '../db/index.ts';
+import { logger } from '../core/logger.ts';
+import * as db from '../db/index.ts';
+
+/**
+ * Matches an incoming message to the correct agent based on channel config.
+ * Agents are checked in order; first match wins.
+ * A wildcard `"*"` in the agent's channels array matches everything.
+ */
+export function matchAgent(channelId: string, agents: AgentConfig[]): AgentConfig | undefined {
+  for (const agent of agents) {
+    for (const pattern of agent.channels) {
+      if (pattern === '*' || pattern === channelId) {
+        return agent;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Looks up or creates a session for the given Slack thread.
+ * Returns the session row and whether it was newly created.
+ */
+export function resolveSession(
+  channelId: string,
+  threadTs: string | null,
+  config: Config,
+): { session: SessionRow; agent: AgentConfig; isNew: boolean } | null {
+  const agent = matchAgent(channelId, config.agents);
+  if (!agent) {
+    logger.warn(`no agent matched for channel ${channelId}`);
+    return null;
+  }
+
+  const existing = db.findSession(channelId, threadTs);
+  if (existing) {
+    const ageHours =
+      (Date.now() - new Date(existing.last_active + 'Z').getTime()) / (1000 * 60 * 60);
+
+    if (ageHours > config.sessions.ttlHours) {
+      logger.info(`session ${existing.uid} expired (${ageHours.toFixed(1)}h old), starting fresh`);
+      return { session: existing, agent, isNew: true };
+    }
+
+    return { session: existing, agent, isNew: false };
+  }
+
+  const session = db.createSession(channelId, threadTs, agent.id, '');
+  logger.info(
+    `created session ${session.uid} for channel=${channelId} thread=${threadTs ?? 'none'} agent=${agent.id}`,
+  );
+  return { session, agent, isNew: true };
+}
+
+export function expireStaleSessions(ttlHours: number): number {
+  const deleted = db.deleteStaleSessions(ttlHours);
+  if (deleted > 0) {
+    logger.info(`expired ${deleted} stale session(s)`);
+  }
+  return deleted;
+}