@clearlysh/beehaven 0.8.16

package/dist/claude-bridge.js

@@ -0,0 +1,310 @@
+/**
+ * Claude Code Bridge — makes Claude Code a first-class beehaven citizen.
+ *
+ * When Claude Code runs in a beehaven project, this bridge:
+ *   1. Connects to the daemon via IPC
+ *   2. Discovers installed apps and their actions
+ *   3. Sends session events (so the avatar, dashboard, cloud all know)
+ *   4. Provides app context for Claude's system prompt
+ *
+ * Usage from Claude Code hooks or the beehaven skill:
+ *   import { ClaudeBridge } from './claude-bridge.js';
+ *   const bridge = new ClaudeBridge(process.cwd());
+ *   await bridge.connect();
+ *   const context = await bridge.getAppContext();
+ *   await bridge.callApp('recorder', 'record', { source: 'mic' });
+ */
+import { createConnection } from 'net';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { EventEmitter } from 'events';
+import { activeAgentWrap } from './agent-attribution.js';
+const IPC_SOCKET_PATH = '/tmp/beehaven-ipc.sock';
+const CONFIG_DIR = join(homedir(), '.beehaven');
+export class ClaudeBridge extends EventEmitter {
+    socket = null;
+    buffer = '';
+    connected = false;
+    ridCounter = 0;
+    pending = new Map();
+    cwd;
+    sessionId;
+    constructor(cwd) {
+        super();
+        this.cwd = cwd;
+        this.sessionId = `claude-${Date.now()}`;
+    }
+    // ── Connection ─────────────────────────────────────────────────────
+    async connect() {
+        if (this.connected)
+            return true;
+        if (!existsSync(IPC_SOCKET_PATH))
+            return false;
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(false), 5_000);
+            const socket = createConnection({ path: IPC_SOCKET_PATH });
+            this.socket = socket;
+            socket.on('connect', () => {
+                this.connected = true;
+                clearTimeout(timeout);
+                // Subscribe to app events
+                this.send({ type: 'subscribe', patterns: ['app:*', 'recorder:*', 'ableton:*', 'avatar:*', 'session:*'] });
+                // Announce ourselves
+                this.send({ type: 'session:announce', label: 'claude-code', app: 'bridge' });
+                resolve(true);
+            });
+            socket.on('data', (data) => {
+                this.buffer += data.toString();
+                const lines = this.buffer.split('\n');
+                this.buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        this.handleMessage(JSON.parse(line));
+                    }
+                    catch { }
+                }
+            });
+            socket.on('close', () => { this.connected = false; this.socket = null; });
+            socket.on('error', () => { clearTimeout(timeout); this.connected = false; resolve(false); });
+        });
+    }
+    disconnect() {
+        this.socket?.destroy();
+        this.socket = null;
+        this.connected = false;
+    }
+    get isConnected() { return this.connected; }
+    // ── App Discovery ──────────────────────────────────────────────────
+    /** Get all installed apps with their actions — for Claude's context. */
+    async getInstalledApps() {
+        if (!this.connected)
+            return this.getInstalledAppsLocal();
+        try {
+            const result = await this.rpc('daemon:app-list', {});
+            const apps = [];
+            for (const app of result.installed ?? []) {
+                // Fetch manifest for each app's buildings
+                const actions = await this.getAppActions(app.buildings?.[0] ?? app.name);
+                apps.push({
+                    name: app.name,
+                    version: app.version,
+                    description: app.description,
+                    buildings: app.buildings ?? [],
+                    actions,
+                });
+            }
+            return apps;
+        }
+        catch {
+            return this.getInstalledAppsLocal();
+        }
+    }
+    /** Get actions for a specific building. */
+    async getAppActions(building) {
+        try {
+            const manifest = await this.appCall(building, 'manifest', {});
+            const actions = [];
+            for (const [, categoryActions] of Object.entries(manifest?.categories ?? {})) {
+                for (const a of categoryActions) {
+                    actions.push({ name: a.name, description: a.description, params: a.params });
+                }
+            }
+            return actions;
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Fallback — read manifests from disk without daemon. */
+    getInstalledAppsLocal() {
+        const apps = [];
+        for (const root of [join(CONFIG_DIR, 'apps'), join(CONFIG_DIR, 'hives')]) {
+            if (!existsSync(root))
+                continue;
+            for (const entry of readdirSync(root)) {
+                if (entry.startsWith('.'))
+                    continue;
+                const dir = join(root, entry);
+                const am = join(dir, 'app.json');
+                const hm = join(dir, 'hive.json');
+                const mp = existsSync(am) ? am : existsSync(hm) ? hm : null;
+                if (!mp)
+                    continue;
+                try {
+                    const m = JSON.parse(readFileSync(mp, 'utf8'));
+                    if (apps.some(a => a.name === m.name))
+                        continue;
+                    apps.push({
+                        name: m.name, version: m.version ?? '0.0.0',
+                        description: m.description ?? '',
+                        buildings: m.buildings ? Object.keys(m.buildings) : [],
+                        actions: [],
+                    });
+                }
+                catch { }
+            }
+        }
+        return apps;
+    }
+    // ── App Calls ──────────────────────────────────────────────────────
+    /** Call an action on a building — same as `beehaven app call <building> <action>`. */
+    async callApp(building, action, input = {}) {
+        return this.appCall(building, action, input);
+    }
+    /** Get context string for Claude's system prompt — describes all available apps. */
+    async getAppContext() {
+        const apps = await this.getInstalledApps();
+        if (apps.length === 0)
+            return '';
+        const lines = ['## Beehaven Apps', ''];
+        lines.push('You have access to the following installed apps via `beehaven app call <building> <action> \'{"key":"value"}\'`:');
+        lines.push('');
+        for (const app of apps) {
+            lines.push(`### ${app.name} (v${app.version})`);
+            lines.push(app.description);
+            if (app.actions.length > 0) {
+                lines.push('Actions:');
+                for (const a of app.actions) {
+                    const params = a.params ? ` — ${Object.entries(a.params).map(([k, v]) => `${k}: ${v}`).join(', ')}` : '';
+                    lines.push(`  - ${a.name}: ${a.description}${params}`);
+                }
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    // ── Session Events ─────────────────────────────────────────────────
+    /** Notify the daemon that Claude Code started a session. */
+    sendSessionStart() {
+        this.sendEvent('SessionStart');
+    }
+    /** Notify the daemon that Claude Code ended a session. */
+    sendSessionEnd() {
+        this.sendEvent('SessionEnd');
+    }
+    /** Notify the daemon of a tool use. */
+    sendToolUse(tool, input, status = 'done') {
+        this.sendEvent(status === 'running' ? 'PreToolUse' : status === 'error' ? 'PostToolUseFailure' : 'PostToolUse', {
+            tool_name: tool,
+            tool_input: typeof input === 'string' ? input : JSON.stringify(input),
+        });
+    }
+    /** Notify the daemon of a user prompt. */
+    sendPrompt(prompt) {
+        this.sendEvent('UserPromptSubmit', { prompt });
+    }
+    // ── Internal ───────────────────────────────────────────────────────
+    sendEvent(hookEvent, extra = {}) {
+        // Send via the watcher socket (HTTP POST to /tmp/beehaven.sock)
+        // This is the same protocol mwah uses.
+        if (!existsSync('/tmp/beehaven.sock'))
+            return;
+        const http = require('http');
+        const body = JSON.stringify({
+            hook_event_name: hookEvent,
+            session_id: this.sessionId,
+            cwd: this.cwd,
+            timestamp: new Date().toISOString(),
+            source: 'claude-code',
+            ...extra,
+        });
+        const req = http.request({
+            socketPath: '/tmp/beehaven.sock',
+            path: '/event',
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        });
+        req.on('error', () => { });
+        req.write(body);
+        req.end();
+    }
+    appCall(building, action, input) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.connected)
+                return reject(new Error('Not connected'));
+            const rid = `claude_${++this.ridCounter}_${Date.now().toString(36)}`;
+            const timer = setTimeout(() => { this.pending.delete(rid); reject(new Error('Timeout')); }, 30_000);
+            this.pending.set(rid, { resolve, reject, timer });
+            this.send({ type: 'app-rpc', action, input, building, instanceId: 'live', rid });
+        });
+    }
+    /**
+     * ⚠ A THIRD RPC-FRAME BUILDER — attributed for the same reason as the other two.
+     *
+     * Its one caller today asks for `daemon:app-list`, which the daemon answers itself and which
+     * `DAEMON_LOCAL_ACTIONS` exempts, so in practice this changes nothing. It is wrapped anyway
+     * because the method is GENERAL: the day someone adds `this.rpc('ticket-create', …)` it becomes
+     * a workspace call that writes no `agent_activity` row, which is exactly the defect CBH2-65 was
+     * about and exactly the kind nothing reports. Wrapping costs one line; an exemption would cost a
+     * list somebody has to keep true.
+     */
+    rpc(action, input) {
+        const wrapped = activeAgentWrap(action, input, {});
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.connected)
+                return reject(new Error('Not connected'));
+            const rid = `claude_${++this.ridCounter}_${Date.now().toString(36)}`;
+            const timer = setTimeout(() => { this.pending.delete(rid); reject(new Error('Timeout')); }, 30_000);
+            this.pending.set(rid, { resolve, reject, timer });
+            this.send({ type: 'rpc', action: wrapped.action, input: wrapped.input, rid });
+        });
+    }
+    send(msg) {
+        if (this.socket?.writable)
+            this.socket.write(JSON.stringify(msg) + '\n');
+    }
+    handleMessage(msg) {
+        if (msg.type === 'rpc-result' && msg.rid && this.pending.has(msg.rid)) {
+            const p = this.pending.get(msg.rid);
+            clearTimeout(p.timer);
+            this.pending.delete(msg.rid);
+            p.resolve(msg.result);
+            return;
+        }
+        if (msg.type === 'rpc-error' && msg.rid && this.pending.has(msg.rid)) {
+            const p = this.pending.get(msg.rid);
+            clearTimeout(p.timer);
+            this.pending.delete(msg.rid);
+            p.reject(new Error(msg.error));
+            return;
+        }
+        if (msg.type === 'broadcast') {
+            this.emit('broadcast', msg.msg);
+        }
+    }
+}
+/**
+ * One-shot: connect, get app context, disconnect.
+ * Use this to inject beehaven context into Claude Code's system prompt.
+ */
+export async function getBeehavenContext(cwd) {
+    const bridge = new ClaudeBridge(cwd);
+    const ok = await bridge.connect();
+    if (!ok)
+        return '';
+    try {
+        return await bridge.getAppContext();
+    }
+    finally {
+        bridge.disconnect();
+    }
+}
+/**
+ * One-shot: connect, call an app action, disconnect.
+ * Use this from Claude Code tool calls.
+ */
+export async function callBeehavenApp(building, action, input = {}) {
+    const bridge = new ClaudeBridge(process.cwd());
+    const ok = await bridge.connect();
+    if (!ok)
+        throw new Error('Daemon not running');
+    try {
+        return await bridge.callApp(building, action, input);
+    }
+    finally {
+        bridge.disconnect();
+    }
+}