@clearlysh/beehaven 0.8.16

package/dist/commands/connect-session.js

@@ -0,0 +1,409 @@
+/**
+ * connect-session — Chatroom-style persistent session.
+ *
+ * `beehaven connect <app>` joins you into a room where all the app's
+ * buildings are present. Events stream in like chat messages, commands
+ * are addressed as `building.action` or just `action`, and other
+ * participants (Claude, browser, other terminals) are visible.
+ *
+ * Architecture:
+ *   CLI readline → persistent IpcClient → daemon → buildings (local/cloud)
+ *   buildings → daemon broadcasts → IpcClient → rendered as chat feed
+ */
+import { connectClient } from '../ipc-client.js';
+import { color } from '../spinner.js';
+// ── Event rendering ──────────────────────────────────────────────────────
+/** Format a broadcast event as a chat-style line */
+function renderEvent(msg, rl) {
+    // Determine source label
+    const source = msg.building ?? msg.source ?? msg.type?.split(':')[0] ?? '?';
+    // Skip noisy internal events
+    const type = msg.type ?? '';
+    if (type === 'pong' || type === 'status')
+        return;
+    // Clear the current prompt line, print the event, redraw prompt
+    const prefix = color.dim(`  [${source}]`);
+    switch (type) {
+        case 'pipeline:start':
+            write(rl, `${prefix} ${color.cyan('pipeline')} ${msg.title ?? ''} (${msg.stepCount} steps)`);
+            break;
+        case 'pipeline:step':
+            if (msg.phase === 'start') {
+                write(rl, `${prefix} ${color.dim('step')} ${msg.label}...`);
+            }
+            else if (msg.phase === 'ok') {
+                write(rl, `${prefix} ${color.green('ok')} ${msg.label}`);
+            }
+            else if (msg.phase === 'error') {
+                write(rl, `${prefix} ${color.red('error')} ${msg.label}: ${msg.error}`);
+            }
+            break;
+        case 'pipeline:end':
+            write(rl, `${prefix} pipeline ${msg.ok ? color.green('done') : color.red('failed')}`);
+            break;
+        case 'building:connected':
+            write(rl, `${prefix} ${color.green('connected')} ${msg.buildingType}/${msg.buildingId}`);
+            break;
+        case 'building:disconnected':
+            write(rl, `${prefix} ${color.dim('disconnected')}`);
+            break;
+        case 'session:join':
+            write(rl, `  ${color.dim('-->')} ${color.bold(msg.label ?? msg.clientId)} joined`);
+            break;
+        case 'session:leave':
+            write(rl, `  ${color.dim('<--')} ${color.bold(msg.label ?? msg.clientId)} left`);
+            break;
+        case 'agent:text':
+        case 'agent:chunk':
+            write(rl, `  ${color.cyan('[claude]')} ${msg.text ?? msg.chunk ?? ''}`);
+            break;
+        case 'agent:tool-call':
+            write(rl, `  ${color.cyan('[claude]')} ${color.dim('calling')} ${msg.toolName}(${JSON.stringify(msg.args ?? {}).slice(0, 80)})`);
+            break;
+        case 'stream:chunk':
+            // AI streaming — print without newline prefix for continuation
+            process.stdout.write(msg.chunk ?? msg.text ?? '');
+            break;
+        case 'stream:complete':
+            write(rl, ''); // newline after stream
+            break;
+        case 'cloud-app-rpc:forward':
+            write(rl, `${prefix} ${color.dim('->')} cloud ${msg.action}`);
+            break;
+        case 'cloud-app-rpc:result':
+            write(rl, `${prefix} ${color.dim('<-')} cloud ${msg.action} ${msg.ok ? color.green('ok') : color.red('failed')}`);
+            break;
+        default: {
+            // Generic event — show type and a compact summary
+            const summary = msg.text ?? msg.message ?? msg.error ?? '';
+            if (type.includes(':')) {
+                write(rl, `${prefix} ${type.split(':').pop()} ${summary}`);
+            }
+            else if (summary) {
+                write(rl, `${prefix} ${summary}`);
+            }
+            // Truly internal/noisy events with no summary are silently dropped
+            break;
+        }
+    }
+}
+/** Write a line without clobbering the readline prompt */
+function write(rl, text) {
+    // Move to column 0, clear line, print, then redraw prompt
+    process.stdout.write(`\r\x1b[K${text}\n`);
+    if (rl?.prompt)
+        rl.prompt(true);
+}
+/**
+ * Parse a chat-room command line. Supports:
+ *   ableton.play              → building=ableton, action=play
+ *   ableton play              → building=ableton, action=play
+ *   play                      → auto-resolve building from actionMap
+ *   play {"speed": 1.5}       → with JSON input
+ */
+function parseCommand(line, ctx) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    // Split: first token is [building.]action, rest is optional JSON
+    let firstToken;
+    let rest;
+    const spaceIdx = trimmed.indexOf(' ');
+    if (spaceIdx === -1) {
+        firstToken = trimmed;
+        rest = '';
+    }
+    else {
+        firstToken = trimmed.slice(0, spaceIdx);
+        rest = trimmed.slice(spaceIdx + 1).trim();
+    }
+    // Parse JSON input if present
+    let input = {};
+    if (rest) {
+        try {
+            input = JSON.parse(rest);
+        }
+        catch {
+            // Treat as a string arg for convenience: `ask "how are you"` → { text: rest }
+            input = { text: rest };
+        }
+    }
+    // Resolve building.action or just action
+    let building;
+    let action;
+    if (firstToken.includes('.')) {
+        const dotIdx = firstToken.indexOf('.');
+        building = firstToken.slice(0, dotIdx);
+        action = firstToken.slice(dotIdx + 1);
+    }
+    else {
+        action = firstToken;
+        // Try to auto-resolve from action map
+        const resolved = ctx.actionMap.get(action);
+        if (resolved) {
+            building = resolved;
+        }
+        else if (resolved === null) {
+            // Ambiguous — action exists on multiple buildings
+            const owners = ctx.buildings.filter((b) => b.actions.includes(action)).map((b) => b.name);
+            console.error(`  ${color.yellow('?')} "${action}" exists on multiple buildings: ${owners.join(', ')}`);
+            console.error(`    Use: ${owners[0]}.${action}`);
+            return null;
+        }
+        else if (ctx.buildings.length === 1) {
+            // Only one building — always route there
+            building = ctx.buildings[0].name;
+        }
+        else {
+            console.error(`  ${color.yellow('?')} Unknown action "${action}". Try "help" to see available actions.`);
+            return null;
+        }
+    }
+    return { building, action, input };
+}
+// ── Session lifecycle ────────────────────────────────────────────────────
+/**
+ * Fetch manifests for all buildings in an app and build the session context.
+ */
+async function buildSessionContext(client, appName, buildingNames) {
+    const buildings = [];
+    const actionMap = new Map();
+    for (const name of buildingNames) {
+        try {
+            const manifest = await client.appCall('manifest', {}, {
+                building: name,
+                instanceId: 'live',
+                timeout: 5_000,
+            });
+            const categories = manifest?.categories ?? {};
+            const actions = Object.values(categories)
+                .flat()
+                .map((a) => a.name);
+            buildings.push({
+                name,
+                actions,
+                description: manifest?.description,
+            });
+            // Build action → building map (null = ambiguous)
+            for (const a of actions) {
+                if (actionMap.has(a)) {
+                    actionMap.set(a, null); // ambiguous
+                }
+                else {
+                    actionMap.set(a, name);
+                }
+            }
+        }
+        catch {
+            // Building not responding — still add it with no actions
+            buildings.push({ name, actions: [] });
+        }
+    }
+    return { appName, buildings, client, actionMap };
+}
+/**
+ * Enter a persistent chatroom session connected to an app's buildings.
+ * This is the heart of `beehaven connect <app>`.
+ */
+export async function connectSession(opts) {
+    const { appName, buildingNames, json, ensureLocalApps = true } = opts;
+    // 1. Persistent connection to daemon
+    const client = await connectClient({ timeout: 10_000 });
+    // 2. Ensure local apps are loaded + running on the daemon
+    if (ensureLocalApps) {
+        try {
+            const appStatus = await client.call('daemon:app-ensure', {});
+            if (!appStatus?.running) {
+                console.error(`  ${color.yellow('!')} Local app server did not start — local buildings may not respond`);
+            }
+        }
+        catch {
+            // Daemon may not support this RPC (older version) — continue anyway
+        }
+    }
+    // 3. Subscribe to all building events + global events
+    const patterns = [
+        ...buildingNames.map((b) => `${b}:*`),
+        'pipeline:*',
+        'agent:*',
+        'stream:*',
+        'session:*',
+        'building:*',
+        'cloud-app-rpc:*',
+    ];
+    client.subscribe(patterns);
+    // 4. Build session context (fetch manifests, build action map)
+    const ctx = await buildSessionContext(client, appName, buildingNames);
+    // 5. Announce ourselves to the daemon
+    client.send({ type: 'session:announce', label: 'terminal', app: appName });
+    // ── Piped / JSON mode (for Claude and scripts) ─────────────────────
+    if (json || !process.stdin.isTTY) {
+        return pipedSession(client, ctx);
+    }
+    // ── Interactive mode ───────────────────────────────────────────────
+    return interactiveSession(client, ctx);
+}
+// ── Interactive TTY session ──────────────────────────────────────────────
+async function interactiveSession(client, ctx) {
+    const { createInterface } = await import('readline');
+    // Print welcome
+    console.log('');
+    console.log(`  ${color.bold(ctx.appName)} ${color.dim('—')} ${ctx.buildings.length} building${ctx.buildings.length === 1 ? '' : 's'} online`);
+    for (const b of ctx.buildings) {
+        const actionCount = b.actions.length;
+        const desc = b.description ? ` ${color.dim(b.description)}` : '';
+        console.log(`  ${color.cyan(b.name.padEnd(16))} ${actionCount} actions${desc}`);
+    }
+    console.log('');
+    console.log(`  ${color.dim('Type building.action or just action. Tab to complete. "help" for actions. Ctrl+C to leave.')}`);
+    console.log('');
+    // Collect all action names for tab completion (building.action and bare action)
+    const completions = [];
+    for (const b of ctx.buildings) {
+        for (const a of b.actions) {
+            completions.push(`${b.name}.${a}`);
+            if (ctx.actionMap.get(a) !== null) {
+                completions.push(a); // unambiguous shorthand
+            }
+        }
+    }
+    completions.push('help', 'status', 'exit', 'quit');
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `${ctx.appName}> `,
+        completer: (line) => {
+            const hits = completions.filter((c) => c.startsWith(line));
+            return [hits.length ? hits : completions, line];
+        },
+    });
+    // Wire up broadcast events → chat feed
+    client.on('broadcast', (msg) => {
+        renderEvent(msg, rl);
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        // Built-in commands
+        if (trimmed === 'exit' || trimmed === 'quit') {
+            client.disconnect();
+            process.exit(0);
+        }
+        if (trimmed === 'help') {
+            for (const b of ctx.buildings) {
+                console.log(`  ${color.bold(b.name)}:`);
+                const cols = b.actions.length > 12 ? formatColumns(b.actions, 3) : b.actions.map((a) => `    ${a}`);
+                for (const line of cols)
+                    console.log(line);
+                console.log('');
+            }
+            rl.prompt();
+            return;
+        }
+        if (trimmed === 'status') {
+            for (const b of ctx.buildings) {
+                try {
+                    const ctxResult = await client.appCall('context', {}, {
+                        building: b.name,
+                        instanceId: 'live',
+                        timeout: 5_000,
+                    });
+                    console.log(`  ${color.cyan(b.name)}: ${JSON.stringify(ctxResult, null, 2)}`);
+                }
+                catch {
+                    console.log(`  ${color.cyan(b.name)}: ${color.dim('no context')}`);
+                }
+            }
+            rl.prompt();
+            return;
+        }
+        // Parse and execute command
+        const cmd = parseCommand(trimmed, ctx);
+        if (!cmd) {
+            rl.prompt();
+            return;
+        }
+        try {
+            const result = await client.appCall(cmd.action, cmd.input, {
+                building: cmd.building,
+                instanceId: 'live',
+            });
+            if (result && typeof result === 'object') {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result !== undefined && result !== null) {
+                console.log(result);
+            }
+        }
+        catch (err) {
+            console.error(`  ${color.red('x')} ${err.message}`);
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        client.disconnect();
+        process.exit(0);
+    });
+}
+// ── Piped / JSON session (for Claude and scripts) ────────────────────────
+async function pipedSession(client, ctx) {
+    const { createInterface } = await import('readline');
+    // In piped mode, also print broadcast events as JSON lines
+    client.on('broadcast', (msg) => {
+        const type = msg?.type ?? '';
+        if (type === 'pong' || type === 'status')
+            return;
+        console.log(JSON.stringify({ event: type, ...msg }));
+    });
+    // Print session info first
+    console.log(JSON.stringify({
+        session: ctx.appName,
+        buildings: ctx.buildings.map((b) => ({
+            name: b.name,
+            actions: b.actions,
+            description: b.description,
+        })),
+    }));
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    const lines = [];
+    await new Promise((resolve) => {
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed)
+                lines.push(trimmed);
+        });
+        rl.on('close', resolve);
+    });
+    for (const line of lines) {
+        const cmd = parseCommand(line, ctx);
+        if (!cmd) {
+            console.log(JSON.stringify({ error: `Could not parse: ${line}` }));
+            continue;
+        }
+        try {
+            const result = await client.appCall(cmd.action, cmd.input, {
+                building: cmd.building,
+                instanceId: 'live',
+            });
+            console.log(JSON.stringify({ action: cmd.action, building: cmd.building, result }));
+        }
+        catch (err) {
+            console.log(JSON.stringify({ action: cmd.action, building: cmd.building, error: err.message }));
+        }
+    }
+    client.disconnect();
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+function formatColumns(items, cols) {
+    const maxLen = Math.max(...items.map((s) => s.length));
+    const lines = [];
+    for (let i = 0; i < items.length; i += cols) {
+        const row = items.slice(i, i + cols).map((s) => s.padEnd(maxLen + 2));
+        lines.push('    ' + row.join(''));
+    }
+    return lines;
+}

package/dist/commands/conversations.js

@@ -0,0 +1,160 @@
+/**
+ * `beehaven conversations` (#109) — list / resume / export Clearly
+ * FAB conversations from the CLI.
+ *
+ * Wraps three workspace RPCs:
+ *   - `conversation-list`   — recent sessions with librarian titles
+ *   - `conversation-export` — render a session as markdown
+ *   - (resume is client-side: pick the top row + print the sessionId)
+ *
+ * Usage:
+ *
+ *     beehaven conversations                     # list 20 most recent
+ *     beehaven conversations --limit 50
+ *     beehaven conversations --composition <id>  # filter to one comp
+ *     beehaven conversations resume              # print most recent sessionId
+ *     beehaven conversations export <sessionId>  # write conversation .md to cwd
+ *     beehaven conversations export <sessionId> --out path.md
+ *     beehaven conversations export <sessionId> --stdout
+ *
+ * Output: pretty table by default, `--json` for machine-readable.
+ */
+import { rpcOnce } from '../ipc-client.js';
+import { writeFileSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+export async function cmdConversations(sub, positionals, values) {
+    switch (sub) {
+        case 'list':
+        case undefined:
+        case '':
+            return cmdConversationsList(values);
+        case 'resume':
+            return cmdConversationsResume(values);
+        case 'export':
+            return cmdConversationsExport(positionals, values);
+        case 'help':
+            return printHelp();
+        default:
+            // Treat unknown sub as a sessionId for export — common shorthand.
+            if (sub.startsWith('appr-') || sub.length > 8) {
+                return cmdConversationsExport([sub, ...positionals], values);
+            }
+            printHelp();
+            return;
+    }
+}
+function printHelp() {
+    console.log(`Usage:
+  beehaven conversations                          # list 20 most recent
+  beehaven conversations --limit 50
+  beehaven conversations --composition <id>      # filter to a canvas
+  beehaven conversations resume                   # print most recent sessionId
+  beehaven conversations export <sessionId>       # write .md to cwd
+  beehaven conversations export <sessionId> --out path.md
+  beehaven conversations export <sessionId> --stdout
+
+Flags:
+  --limit <N>          max rows to fetch (default 20, max 100)
+  --composition <id>   filter to one composition
+  --json               output raw JSON
+  --out <path>         export destination (default: derived from title)
+  --stdout             write export to stdout instead of a file`);
+}
+/** List rows in a tight tabular layout. Title is the librarian's
+ *  curated label — the most useful field to scan. Time-since-last
+ *  is what tells you "yesterday's bug-fix thread" vs "this morning". */
+async function cmdConversationsList(values) {
+    const limit = Math.max(1, Math.min(Number(values.limit) || 20, 100));
+    const compositionId = values.composition;
+    const input = { limit };
+    if (compositionId)
+        input.compositionId = compositionId;
+    const res = await rpcOnce('conversation-list', input);
+    if (!res?.ok) {
+        console.error(`  conversation-list failed: ${res?.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const rows = res.conversations ?? [];
+    if (values.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+    }
+    if (rows.length === 0) {
+        console.log('  No conversations yet.');
+        return;
+    }
+    // Render — fixed-width columns so resume / scroll feels readable.
+    console.log(`  ${rows.length} conversation${rows.length === 1 ? '' : 's'}:\n`);
+    for (const r of rows) {
+        const when = formatRelative(r.lastTs);
+        const title = (r.title || '(untitled)').slice(0, 60);
+        const turns = `${r.turnCount} turn${r.turnCount === 1 ? '' : 's'}`;
+        console.log(`  • ${title}`);
+        console.log(`    ${r.sessionId}  ·  ${when}  ·  ${turns}  ·  ${r.lastModel || '—'}`);
+        if (r.summary)
+            console.log(`    ${r.summary.slice(0, 80)}`);
+        console.log('');
+    }
+}
+/** Print the most-recent sessionId. Designed for shell pipelines —
+ *  `beehaven conversations export "$(beehaven conversations resume)"`. */
+async function cmdConversationsResume(values) {
+    const res = await rpcOnce('conversation-list', { limit: 1 });
+    if (!res?.ok) {
+        console.error(`  conversation-list failed: ${res?.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const top = res.conversations?.[0];
+    if (!top) {
+        console.error('  No conversations to resume.');
+        process.exit(1);
+    }
+    if (values.json) {
+        console.log(JSON.stringify(top, null, 2));
+        return;
+    }
+    // Print JUST the sessionId so it composes well with $(...) substitution.
+    console.log(top.sessionId);
+}
+async function cmdConversationsExport(positionals, values) {
+    const sessionId = positionals[0];
+    if (!sessionId) {
+        console.error('  Usage: beehaven conversations export <sessionId> [--out path.md] [--stdout]');
+        process.exit(1);
+    }
+    const res = await rpcOnce('conversation-export', { sessionId, format: 'markdown' });
+    if (!res?.ok) {
+        console.error(`  conversation-export failed: ${res?.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    if (values.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+    }
+    if (values.stdout) {
+        process.stdout.write(res.markdown);
+        return;
+    }
+    const outPath = values.out
+        ? resolvePath(String(values.out))
+        : resolvePath(String(res.filename || `conversation-${sessionId}.md`));
+    writeFileSync(outPath, res.markdown, 'utf8');
+    console.log(`  Exported ${res.turnCount} turn${res.turnCount === 1 ? '' : 's'} → ${outPath}`);
+}
+function formatRelative(ts) {
+    if (!ts)
+        return '';
+    const delta = Date.now() - ts;
+    const m = Math.floor(delta / 60_000);
+    if (m < 1)
+        return 'just now';
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    const d = Math.floor(h / 24);
+    if (d < 7)
+        return `${d}d ago`;
+    return new Date(ts).toLocaleDateString();
+}