beehaven 0.8.16

package/dist/commands/auth.js

@@ -0,0 +1,171 @@
+/**
+ * beehaven login/signup/logout — Beehaven account management.
+ *
+ * Credentials stored in ~/.beehaven/credentials.json
+ * All subsequent CLI commands use the stored API key.
+ */
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { resolveRelaySelection } from '../relay-presets.js';
+const BEEHAVEN_API = process.env.BEEHAVEN_API_URL ?? 'https://api.beehaven.dev';
+const CRED_DIR = join(homedir(), '.beehaven');
+const CRED_FILE = join(CRED_DIR, 'credentials.json');
+export function getCredentials() {
+    if (!existsSync(CRED_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CRED_FILE, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function getApiKey() {
+    return getCredentials()?.apiKey ?? null;
+}
+export function readDaemonIdentity() {
+    const cfgPath = join(CRED_DIR, 'config.json');
+    if (!existsSync(cfgPath))
+        return null;
+    try {
+        const c = JSON.parse(readFileSync(cfgPath, 'utf8'));
+        // A TOKEN is what "logged in" means — not the presence of display fields.
+        //
+        // This gated on `!c.userId && !c.email`, and the Mac app (installedBy:
+        // 'electron' — i.e. how every consumer signs in) writes a token, a
+        // refreshToken and tokenStorage but NEITHER identity field. So this returned
+        // null, whoami fell through to the legacy self-hosted credentials.json,
+        // found nothing, and reported "Not logged in. Run `beehaven login`" to a
+        // user holding a perfectly good credential. `beehaven status` read the same
+        // file and said "Account: Connected" — two commands, one config, opposite
+        // answers.
+        //
+        // It is worst for AGENTS: told they are logged out, the prescribed fix is
+        // `beehaven login`, which opens a BROWSER. An agent cannot complete that and
+        // cannot know the advice was wrong. The identity fields are for DISPLAY;
+        // authority lives in the token.
+        if (!c.userId && !c.email && !c.token)
+            return null;
+        // No email on disk? Read it off the token for display. The id token is a JWT
+        // whose payload carries email/user_id, and this is the only place that
+        // matters — we are labelling a line of output, never authorizing. Unverified
+        // on purpose (verification is the server's job) and fully guarded: a
+        // malformed token must degrade to "(unknown)", never throw whoami.
+        let email = c.email ?? null;
+        let userId = c.userId ?? null;
+        if ((!email || !userId) && typeof c.token === 'string') {
+            try {
+                const seg = c.token.split('.')[1];
+                if (seg) {
+                    const json = JSON.parse(Buffer.from(seg.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8'));
+                    email ??= json.email ?? null;
+                    userId ??= json.user_id ?? json.sub ?? null;
+                }
+            }
+            catch { /* not a JWT / not decodable → keep what we had */ }
+        }
+        // Surface the CANONICAL relay/env (derived from `endpoint`), not the raw
+        // envName/relayUrl aliases — those can lag the real dial target after a
+        // fresh login / Mac-app install that writes only `endpoint`.
+        const relay = resolveRelaySelection(c);
+        return {
+            email,
+            userId,
+            displayName: c.displayName ?? null,
+            envName: relay.envName,
+            relayUrl: relay.url,
+            hasIdToken: !!c.token,
+            hasRefreshToken: !!c.refreshToken,
+            tokenStorage: c.tokenStorage ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function saveCredentials(creds) {
+    if (!existsSync(CRED_DIR))
+        mkdirSync(CRED_DIR, { recursive: true });
+    writeFileSync(CRED_FILE, JSON.stringify(creds, null, 2));
+}
+export async function signup(email, password) {
+    console.log('\n  Creating Beehaven account...\n');
+    const res = await fetch(`${BEEHAVEN_API}/auth/signup`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+    });
+    const data = (await res.json());
+    if (!res.ok) {
+        console.error(`  Error: ${data.error ?? 'Signup failed'}`);
+        process.exit(1);
+    }
+    saveCredentials({
+        apiKey: data.apiKey,
+        userId: data.userId,
+        email,
+        plan: data.plan,
+    });
+    console.log(`  Account created!`);
+    console.log(`  Email: ${email}`);
+    console.log(`  Plan: ${data.plan}`);
+    console.log(`  API key saved to ~/.beehaven/credentials.json\n`);
+}
+export async function login(email, password) {
+    console.log('\n  Logging in...\n');
+    const res = await fetch(`${BEEHAVEN_API}/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+    });
+    const data = (await res.json());
+    if (!res.ok) {
+        console.error(`  Error: ${data.error ?? 'Login failed'}`);
+        process.exit(1);
+    }
+    saveCredentials({
+        apiKey: data.apiKey,
+        userId: data.userId,
+        email,
+        plan: data.plan,
+    });
+    console.log(`  Logged in as ${email} (${data.plan} plan)\n`);
+}
+export function logout() {
+    if (existsSync(CRED_FILE)) {
+        unlinkSync(CRED_FILE);
+        console.log('\n  Logged out. Credentials removed.\n');
+    }
+    else {
+        console.log('\n  Not logged in.\n');
+    }
+}
+export function whoami() {
+    // Prefer the Firebase loopback identity (config.json) — that's what
+    // `beehaven login` writes today. Fall back to the legacy email/password
+    // credentials.json for self-hosted deploys still using that flow.
+    const daemon = readDaemonIdentity();
+    if (daemon) {
+        console.log('');
+        console.log(`  Email:    ${daemon.email ?? '(unknown)'}`);
+        console.log(`  User ID:  ${daemon.userId ?? '(unknown)'}`);
+        if (daemon.displayName)
+            console.log(`  Name:     ${daemon.displayName}`);
+        if (daemon.envName)
+            console.log(`  Env:      ${daemon.envName}`);
+        if (daemon.relayUrl)
+            console.log(`  Relay:    ${daemon.relayUrl}`);
+        console.log(`  Tokens:   ${daemon.hasIdToken ? 'idToken ✓' : '✗'}  ${daemon.hasRefreshToken ? 'refreshToken ✓' : '✗'}  (${daemon.tokenStorage ?? 'file'})`);
+        console.log('');
+        return;
+    }
+    const creds = getCredentials();
+    if (!creds) {
+        console.log('\n  Not logged in. Run `beehaven login` or `beehaven signup`.\n');
+        return;
+    }
+    console.log(`\n  Email: ${creds.email}`);
+    console.log(`  Plan:  ${creds.plan}`);
+    console.log(`  API key: ${creds.apiKey.slice(0, 8)}****\n`);
+}

package/dist/commands/building-shell.js

@@ -0,0 +1,392 @@
+/**
+ * beehaven <building> — Building shell.
+ *
+ * Three modes:
+ *   1. `beehaven ableton`              → print context overview (orientation)
+ *   2. `beehaven ableton getSession`   → one-shot RPC, return JSON
+ *   3. `beehaven ableton --shell`      → interactive REPL (readline + tab complete)
+ *
+ * Piped stdin is also supported — Claude or scripts can pipe multiple
+ * commands and the shell executes them sequentially over a single
+ * persistent IPC connection:
+ *
+ *   printf 'getSession\ncreateTrack {"type":"midi"}\n' | beehaven ableton --shell
+ */
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { appRpcOnce, connectClient } from '../ipc-client.js';
+const APPS_DIR = join(homedir(), '.beehaven', 'apps');
+// ── Helpers ──────────────────────────────────────────────────────────────
+/** Collect all registered building names from installed app manifests. */
+export function getInstalledBuildings() {
+    if (!existsSync(APPS_DIR))
+        return [];
+    const buildings = [];
+    for (const entry of readdirSync(APPS_DIR)) {
+        if (entry.startsWith('.'))
+            continue;
+        const manifestPath = join(APPS_DIR, entry, 'app.json');
+        if (!existsSync(manifestPath))
+            continue;
+        try {
+            const m = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            if (m?.buildings) {
+                for (const name of Object.keys(m.buildings)) {
+                    if (!buildings.includes(name))
+                        buildings.push(name);
+                }
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    return buildings;
+}
+/** Find recipes that depend on or target a specific building. */
+function getRecipesForBuilding(building) {
+    if (!existsSync(APPS_DIR))
+        return [];
+    const recipes = [];
+    for (const entry of readdirSync(APPS_DIR)) {
+        if (entry.startsWith('.'))
+            continue;
+        const manifestPath = join(APPS_DIR, entry, 'app.json');
+        if (!existsSync(manifestPath))
+            continue;
+        let m;
+        try {
+            m = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (!m?.recipes)
+            continue;
+        // Check if this app's recipes reference the building
+        for (const [rName, rPath] of Object.entries(m.recipes)) {
+            let title = rName;
+            let targets = false;
+            const rFile = typeof rPath === 'string' ? join(APPS_DIR, entry, rPath) : null;
+            if (rFile && existsSync(rFile)) {
+                try {
+                    const recipe = JSON.parse(readFileSync(rFile, 'utf8'));
+                    title = recipe.title ?? rName;
+                    // Check if any step targets this building
+                    if (Array.isArray(recipe.steps)) {
+                        targets = recipe.steps.some((s) => s.building === building || (!s.building && m.buildings?.[building]));
+                    }
+                }
+                catch { }
+            }
+            // Include if the app owns the building or recipe targets it
+            if (m.buildings?.[building] || targets) {
+                recipes.push({ app: m.name, recipe: rName, title });
+            }
+        }
+    }
+    return recipes;
+}
+/** Format a compact track list. */
+function formatTrackList(names) {
+    const lines = [];
+    const cols = 3;
+    for (let i = 0; i < names.length; i += cols) {
+        const row = names.slice(i, i + cols).map((name, j) => {
+            const idx = String(i + j).padStart(2);
+            const truncated = name.length > 22 ? name.slice(0, 20) + '..' : name;
+            return `  ${idx}  ${truncated}`;
+        });
+        lines.push(row.map((s) => s.padEnd(30)).join(''));
+    }
+    return lines.join('\n');
+}
+/** Format category → action names compactly. */
+function formatActionSummary(categories) {
+    const lines = [];
+    for (const [cat, actions] of Object.entries(categories)) {
+        const names = actions.map((a) => a.name);
+        // Show first few, then "..."
+        const shown = names.length > 6 ? [...names.slice(0, 5), `+${names.length - 5} more`] : names;
+        lines.push(`  ${cat.padEnd(14)} ${shown.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+// ── Mode 1: Context Overview ─────────────────────────────────────────────
+export async function buildingContext(building, instanceId) {
+    let manifest;
+    let context;
+    try {
+        [manifest, context] = await Promise.all([
+            appRpcOnce('manifest', {}, { building, instanceId, timeout: 8_000 }),
+            appRpcOnce('context', {}, { building, instanceId, timeout: 8_000 }).catch(() => null),
+        ]);
+    }
+    catch (err) {
+        console.error(`  ✗ Cannot connect to ${building}/${instanceId}: ${err.message}`);
+        console.error('  Is the daemon running? Run `beehaven start --headless` (or open the Clearly Dev Mac app).');
+        process.exit(1);
+    }
+    const categories = manifest.categories ?? {};
+    const actionCount = manifest.actionCount ?? manifest.totalActions ?? 0;
+    const desc = manifest.description ?? '';
+    // Session state (building-specific — Ableton has session, others may not)
+    const session = context?.session;
+    const recentCommands = context?.recentCommands ?? [];
+    console.log('');
+    console.log(`  ${building} — ${desc}`);
+    console.log('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    // Live state
+    if (session) {
+        const parts = [
+            `${session.tempo} BPM`,
+            `${session.signatureNumerator}/${session.signatureDenominator}`,
+            `${session.numTracks} tracks`,
+            `${session.numScenes} scenes`,
+            session.isPlaying ? 'playing' : 'stopped',
+            session.loop ? `loop ${session.loopStart}..${session.loopStart + session.loopLength}` : '',
+        ].filter(Boolean);
+        console.log(`  ${parts.join(', ')}`);
+        console.log('');
+        if (session.trackNames?.length) {
+            console.log('  Tracks:');
+            console.log(formatTrackList(session.trackNames));
+            console.log('');
+        }
+    }
+    // Actions by category
+    console.log(`  Actions (${actionCount}):`);
+    console.log(formatActionSummary(categories));
+    console.log('');
+    // Recipes
+    const recipes = getRecipesForBuilding(building);
+    if (recipes.length > 0) {
+        console.log('  Recipes:');
+        for (const r of recipes) {
+            console.log(`    beehaven app run ${r.app}/${r.recipe}`.padEnd(48) + r.title);
+        }
+        console.log('');
+    }
+    // Recent activity
+    if (recentCommands.length > 0) {
+        const recent = recentCommands.slice(0, 5);
+        console.log('  Recent:');
+        for (const cmd of recent) {
+            const time = cmd.created_at?.split(' ')[1] ?? '';
+            console.log(`    ${time}  ${cmd.action}`);
+        }
+        console.log('');
+    }
+    // Usage
+    console.log('  Usage:');
+    console.log(`    beehaven ${building} <action> [json]     Run an action`);
+    console.log(`    beehaven ${building} --shell             Interactive REPL`);
+    console.log(`    beehaven ${building} --actions           Full action reference`);
+    console.log('');
+    // Examples (building-specific)
+    if (building === 'ableton') {
+        console.log('  Examples:');
+        console.log(`    beehaven ableton getSession`);
+        console.log(`    beehaven ableton createTrack '{"type":"midi","name":"Strings"}'`);
+        console.log(`    beehaven ableton composeToClip '{"trackIndex":0,"clipIndex":0,"generator":"generateMelody","generatorParams":{"root":"C","scale":"minor","length":16}}'`);
+        console.log(`    beehaven ableton play`);
+        console.log('');
+    }
+}
+// ── Mode 2: One-Shot RPC ─────────────────────────────────────────────────
+export async function buildingOneShot(building, action, rawInput, instanceId, timeout) {
+    let input = {};
+    if (rawInput) {
+        try {
+            input = JSON.parse(rawInput);
+        }
+        catch {
+            console.error(`  ✗ Invalid JSON: ${rawInput}`);
+            process.exit(1);
+        }
+    }
+    try {
+        const result = await appRpcOnce(action, input, { building, instanceId, timeout });
+        if (result && typeof result === 'object') {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result);
+        }
+    }
+    catch (err) {
+        console.error(JSON.stringify({ error: err.message }, null, 2));
+        process.exit(1);
+    }
+}
+// ── Mode 3: Interactive Shell / Piped Shell ──────────────────────────────
+export async function buildingShell(building, instanceId) {
+    const client = await connectClient({ timeout: 10_000 });
+    // Fetch manifest for tab completion
+    let actionNames = [];
+    let categories = {};
+    try {
+        const manifest = await client.appCall('manifest', {}, { building, instanceId });
+        categories = manifest.categories ?? {};
+        actionNames = Object.values(categories)
+            .flat()
+            .map((a) => a.name);
+    }
+    catch {
+        /* proceed without completion */
+    }
+    const isTTY = process.stdin.isTTY;
+    if (isTTY) {
+        // Interactive mode — readline with tab completion and prompt
+        const { createInterface } = await import('readline');
+        // Print compact welcome
+        try {
+            const ctx = await client.appCall('context', {}, { building, instanceId, timeout: 5_000 });
+            const session = ctx?.session;
+            if (session) {
+                const parts = [
+                    `${session.tempo} BPM`,
+                    `${session.numTracks} tracks`,
+                    session.isPlaying ? 'playing' : 'stopped',
+                ].filter(Boolean);
+                console.log(`  ${building} — ${parts.join(', ')}`);
+            }
+            else {
+                console.log(`  ${building} — connected`);
+            }
+        }
+        catch {
+            console.log(`  ${building} — connected`);
+        }
+        console.log(`  ${actionNames.length} actions available. Tab to complete. "help" for categories. Ctrl+C to exit.`);
+        console.log('');
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: `${building}> `,
+            completer: (line) => {
+                const hits = actionNames.filter((a) => a.startsWith(line));
+                return [hits.length ? hits : actionNames, line];
+            },
+        });
+        rl.prompt();
+        rl.on('line', async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                rl.prompt();
+                return;
+            }
+            if (trimmed === 'exit' || trimmed === 'quit') {
+                client.disconnect();
+                process.exit(0);
+            }
+            if (trimmed === 'help') {
+                for (const [cat, actions] of Object.entries(categories)) {
+                    const names = actions.map((a) => a.name);
+                    console.log(`  ${cat}: ${names.join(', ')}`);
+                }
+                console.log('');
+                rl.prompt();
+                return;
+            }
+            // Parse: action [json]
+            const spaceIdx = trimmed.indexOf(' ');
+            const action = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+            const jsonStr = spaceIdx === -1 ? undefined : trimmed.slice(spaceIdx + 1).trim();
+            let input = {};
+            if (jsonStr) {
+                try {
+                    input = JSON.parse(jsonStr);
+                }
+                catch {
+                    console.error(`  ✗ Invalid JSON: ${jsonStr}`);
+                    rl.prompt();
+                    return;
+                }
+            }
+            try {
+                const result = await client.appCall(action, input, { building, instanceId });
+                if (result && typeof result === 'object') {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.log(result);
+                }
+            }
+            catch (err) {
+                console.error(`  ✗ ${err.message}`);
+            }
+            rl.prompt();
+        });
+        rl.on('close', () => {
+            client.disconnect();
+            process.exit(0);
+        });
+    }
+    else {
+        // Piped mode — read lines from stdin, execute sequentially, print JSON, exit on EOF.
+        // Claude and scripts use this path.
+        const { createInterface } = await import('readline');
+        const rl = createInterface({ input: process.stdin, terminal: false });
+        // Collect all lines first, then execute sequentially.
+        // This avoids race conditions where lines fire before the connection is ready.
+        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 trimmed of lines) {
+            const spaceIdx = trimmed.indexOf(' ');
+            const action = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+            const jsonStr = spaceIdx === -1 ? undefined : trimmed.slice(spaceIdx + 1).trim();
+            let input = {};
+            if (jsonStr) {
+                try {
+                    input = JSON.parse(jsonStr);
+                }
+                catch {
+                    console.log(JSON.stringify({ error: `Invalid JSON: ${jsonStr}` }));
+                    continue;
+                }
+            }
+            try {
+                const result = await client.appCall(action, input, { building, instanceId });
+                console.log(JSON.stringify(result));
+            }
+            catch (err) {
+                console.log(JSON.stringify({ error: err.message }));
+            }
+        }
+        client.disconnect();
+    }
+}
+// ── Entry Point (called from cli.ts) ─────────────────────────────────────
+export async function cmdBuildingShell(building, args, opts) {
+    const instanceId = opts.instance ?? 'live';
+    const timeout = opts.timeout ? parseInt(opts.timeout, 10) : 30_000;
+    // --actions → delegate to existing app actions command
+    if (opts.actions) {
+        const { cmdAppActions } = await import('./app.js');
+        await cmdAppActions([building], opts);
+        return;
+    }
+    // --shell → interactive/piped REPL
+    if (opts.shell) {
+        await buildingShell(building, instanceId);
+        return;
+    }
+    // No action arg → context overview
+    if (args.length === 0) {
+        await buildingContext(building, instanceId);
+        return;
+    }
+    // action [json] → one-shot RPC
+    const action = args[0];
+    const rawInput = args.slice(1).join(' ') || undefined;
+    await buildingOneShot(building, action, rawInput, instanceId, timeout);
+}