beehaven 0.8.16

package/dist/commands/swarm.js

@@ -0,0 +1,341 @@
+/**
+ * swarm / hive — the distributed "hive mesh" from the terminal.
+ *
+ * A **beehive** is a node running the daemon + hives (this Mac, a headless
+ * server, or a Cloudflare container). A **queen hive** orchestrates; **worker
+ * hives** execute. This machine registers itself automatically when the daemon
+ * connects (see daemon.ts `registerBeehive`) — these verbs let you SEE the
+ * swarm, designate roles, and route work.
+ *
+ *   beehaven swarm list                       # every beehive: role, kind, hives, online
+ *   beehaven swarm queen                       # who's orchestrating
+ *   beehaven swarm role <queen|worker>         # make THIS machine the queen (or a worker)
+ *   beehaven swarm whoami                       # this machine's beehive identity
+ *   beehaven swarm dispatch <cap> <action> [json]  # route work to the best worker
+ *   beehaven swarm forget <deviceId>           # drop a stale offline node
+ *
+ * All cloud state lives in the always-on Home DO (rpc/swarm-rpcs.ts); these
+ * verbs reach it through the daemon over IPC via `rpcOnce`. (One namespace on
+ * purpose — `hive`/`hives` already name the local-apps concept.)
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir, hostname, platform } from 'node:os';
+import { join } from 'node:path';
+import { rpcOnce } from '../ipc-client.js';
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const CONFIG_DIR = join(homedir(), '.beehaven');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+/** This machine's stable beehive id — MUST match relay.ts `deviceId`. */
+function thisDeviceId() {
+    return `${hostname()}-${platform()}`;
+}
+function loadConfig() {
+    try {
+        return existsSync(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, 'utf8')) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(update) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify({ ...loadConfig(), ...update }, null, 2));
+}
+/** Unwrap the daemon's { result } envelope (rpcOnce sometimes returns it raw). */
+function unwrap(r) {
+    return r?.result ?? r ?? {};
+}
+// ══════════════════════════════ swarm ══════════════════════════════
+export async function cmdSwarm(positionals, values) {
+    const sub = positionals[1] ?? 'list';
+    const rest = positionals.slice(2);
+    switch (sub) {
+        case 'list':
+        case 'ls':
+            return swarmList();
+        case 'queen':
+            return swarmQueen();
+        case 'role':
+            return swarmRole(rest);
+        case 'whoami':
+        case 'status':
+        case 'me':
+            return swarmWhoami();
+        case 'dispatch':
+        case 'run':
+            return swarmDispatch(rest, values);
+        case 'forget':
+        case 'rm':
+            return swarmForget(rest);
+        // The bees — 👑 Queen (samples all the honey) + 🐝 Omni (the owner's twin).
+        case 'bees':
+            return swarmBees();
+        case 'sample-honey':
+        case 'sample':
+            return swarmSampleHoney();
+        case 'forge-omni':
+        case 'forge':
+            return swarmForgeOmni(values);
+        default:
+            console.log(`  Unknown swarm subcommand '${sub}'.`);
+            console.log(dim('  Try: beehaven swarm list | queen | role | whoami | dispatch | forget | bees | sample-honey | forge-omni'));
+    }
+}
+async function swarmList() {
+    let res;
+    try {
+        res = unwrap(await rpcOnce('swarm-list', {}, 8_000));
+    }
+    catch {
+        console.log(red('  Cannot reach the swarm.') + dim('  Is the daemon running?  beehaven status'));
+        return;
+    }
+    const beehives = res?.beehives ?? [];
+    if (!beehives.length) {
+        console.log('');
+        console.log('  🐝 No beehives registered yet.');
+        console.log(dim('  This machine registers automatically when the daemon connects.'));
+        console.log(dim('  Bring more online: `beehaven start --headless` on a server, or a cloud container.'));
+        console.log('');
+        return;
+    }
+    const me = thisDeviceId();
+    console.log('');
+    console.log(`  🐝 ${bold('Swarm')} ${dim(`— ${res.online}/${res.count} online`)}`);
+    console.log(dim('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    for (const b of beehives) {
+        const dot = b.online ? green('●') : dim('○');
+        const crown = b.role === 'queen' ? '👑' : '🐝';
+        const mine = b.deviceId === me ? cyan('  ← this machine') : '';
+        const caps = (b.capabilities ?? []).slice(0, 8).join(', ') || dim('no hives');
+        console.log(`  ${dot} ${crown} ${cyan(String(b.hostname).padEnd(22))} ${dim(String(b.kind).padEnd(15))} ${(b.role === 'queen' ? yellow('queen') : 'worker').padEnd(7)}${mine}`);
+        console.log(`        ${dim(b.deviceId)}`);
+        console.log(`        ${dim('hives:')} ${caps}${b.load ? dim(`   load:${b.load}`) : ''}`);
+    }
+    console.log('');
+    console.log(dim(`  queen: ${res.queen ? green(res.queen) : 'none — promote one with `beehaven swarm role queen`'}`));
+    console.log('');
+}
+async function swarmQueen() {
+    let res;
+    try {
+        res = unwrap(await rpcOnce('swarm-queen', {}, 8_000));
+    }
+    catch {
+        console.log(red('  Cannot reach the swarm.'));
+        return;
+    }
+    const q = res?.queen;
+    console.log('');
+    if (!q) {
+        console.log('  👑 No queen designated.');
+        console.log(dim('  Make this machine the queen:  beehaven swarm role queen'));
+    }
+    else {
+        console.log(`  👑 ${bold('Queen')} — ${cyan(q.hostname)} ${q.online ? green('(online)') : dim('(offline)')}`);
+        console.log(`     ${dim(q.deviceId)}  ·  ${dim(q.kind)}`);
+        console.log(`     ${dim('hives:')} ${(q.capabilities ?? []).join(', ') || dim('none')}`);
+    }
+    console.log('');
+}
+async function swarmDispatch(rest, values) {
+    const capability = rest[0];
+    const action = rest[1];
+    if (!capability || !action) {
+        console.log('  Usage: beehaven swarm dispatch <capability> <action> [json]');
+        console.log(dim('    capability = the hive to run (e.g. motion-studio, voice)'));
+        console.log(dim('    e.g. beehaven swarm dispatch voice synthesize \'{"text":"hi"}\''));
+        return;
+    }
+    let input = {};
+    if (rest[2]) {
+        try {
+            input = JSON.parse(rest[2]);
+        }
+        catch {
+            console.log(red('  Invalid JSON payload.'));
+            return;
+        }
+    }
+    const targetDeviceId = typeof values?.target === 'string' ? values.target : undefined;
+    console.log(dim(`  → dispatching ${capability}:${action}${targetDeviceId ? ` @${targetDeviceId}` : ' to the best worker'}…`));
+    let res;
+    try {
+        res = unwrap(await rpcOnce('swarm-dispatch', { capability, action, input, targetDeviceId }, 300_000));
+    }
+    catch (e) {
+        console.log(red(`  Dispatch failed: ${e?.message ?? e}`));
+        return;
+    }
+    if (res?.error || res?.ok === false) {
+        console.log(red(`  ✗ ${res.error ?? 'dispatch failed'}`) + (res.code ? dim(`  [${res.code}]`) : ''));
+        return;
+    }
+    console.log(green(`  ✓ ${capability}:${action}`) + dim(`  on ${res.targetDeviceId} · ${res.durationMs}ms`));
+    console.log(JSON.stringify(res.result, null, 2));
+}
+async function swarmForget(rest) {
+    const deviceId = rest[0];
+    if (!deviceId) {
+        console.log('  Usage: beehaven swarm forget <deviceId>');
+        return;
+    }
+    let res;
+    try {
+        res = unwrap(await rpcOnce('swarm-forget', { deviceId }, 8_000));
+    }
+    catch (e) {
+        console.log(red(`  ${e?.message ?? e}`));
+        return;
+    }
+    if (res?.error) {
+        console.log(red(`  ✗ ${res.error}`));
+        return;
+    }
+    console.log(green(`  ✓ forgot beehive ${deviceId}`));
+}
+// ══════════════════════════════ the bees ══════════════════════════════
+// 👑 Queen samples ALL the honey (the full corpus, gets fat); 🐝 Omni is the
+// owner's AI twin, forged BY the Queen from a lean distillation of the honey.
+async function swarmBees() {
+    let res;
+    try {
+        res = unwrap(await rpcOnce('bees-status', {}, 8_000));
+    }
+    catch {
+        console.log(red('  Cannot reach the hive.') + dim('  Is the daemon running?'));
+        return;
+    }
+    const q = res?.queen ?? {};
+    const o = res?.omni ?? {};
+    console.log('');
+    console.log(`  🐝 ${bold('The bees')}`);
+    console.log(dim('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(`  👑 ${cyan('Queen')}   ${q.exists ? green('ready') : dim('not yet')}  ·  honey ${q.honeySampled ? green('sampled') : yellow('not sampled')}`);
+    console.log(dim(`        samples all the honey → gets fat → forges Omni`));
+    console.log(`  🐝 ${cyan('Omni')}    ${o.exists ? green('ready') : dim('not yet')}  ·  twin ${o.forged ? green('forged') : yellow('not forged')}${o.twinMemories ? dim(`  (${o.twinMemories} memories)`) : ''}`);
+    console.log(dim(`        ${o.description || 'your AI twin — a copy of you'}`));
+    console.log('');
+    if (!q.honeySampled)
+        console.log(dim('  Next:  beehaven swarm sample-honey'));
+    else if (!o.forged)
+        console.log(dim('  Next:  beehaven swarm forge-omni'));
+    else
+        console.log(dim('  Log in as your twin:  beehaven agent login omni-bee'));
+    console.log('');
+}
+async function swarmSampleHoney() {
+    console.log(dim('  👑 Queen is sampling all the honey…'));
+    let res;
+    try {
+        res = unwrap(await rpcOnce('queen-sample-honey', {}, 120_000));
+    }
+    catch (e) {
+        console.log(red(`  Sampling failed: ${e?.message ?? e}`));
+        return;
+    }
+    if (res?.error) {
+        console.log(red(`  ✗ ${res.error}`));
+        return;
+    }
+    const counts = res.counts ?? {};
+    console.log('');
+    console.log(green(`  ✓ Queen sampled the honey`) + dim(`  · fatness ${res.fatness}`));
+    console.log(dim(`    ${Object.entries(counts)
+        .map(([k, n]) => `${n} ${k}`)
+        .join('  ·  ')}`));
+    if (res.ownerName)
+        console.log(dim(`    owner: ${res.ownerName}`));
+    console.log('');
+    console.log(dim('    Now forge the twin:  beehaven swarm forge-omni'));
+    console.log('');
+}
+async function swarmForgeOmni(values) {
+    console.log(dim('  👑 Queen is forging Omni — distilling a lean copy of you…'));
+    let res;
+    try {
+        res = unwrap(await rpcOnce('queen-forge-omni', { resample: !!values?.force }, 180_000));
+    }
+    catch (e) {
+        console.log(red(`  Forge failed: ${e?.message ?? e}`));
+        return;
+    }
+    if (res?.error) {
+        console.log(red(`  ✗ ${res.error}`));
+        return;
+    }
+    const t = res.twin ?? {};
+    console.log('');
+    console.log(green(`  ✓ Omni forged`) +
+        dim(`  · twin of ${res.owner} · ${res.usedLLM ? 'LLM-distilled' : 'structured'} · ${res.factsSeeded} facts seeded`));
+    if (t.persona)
+        console.log(`\n  ${bold('Who Omni is:')}\n  ${dim(String(t.persona).slice(0, 300))}`);
+    if (t.voice)
+        console.log(`\n  ${bold('Voice:')} ${dim(String(t.voice).slice(0, 200))}`);
+    if (Array.isArray(t.priorities) && t.priorities.length)
+        console.log(`\n  ${bold('Priorities:')} ${dim(t.priorities.slice(0, 5).join(' · '))}`);
+    console.log('');
+    console.log(dim(`  Log in as your twin:  ${res.loginCommand || 'beehaven agent login omni-bee'}`));
+    console.log('');
+}
+// ─────────────────────── this machine's role/identity ───────────────────────
+async function swarmRole(rest) {
+    const role = (rest[0] ?? '').toLowerCase();
+    if (role !== 'queen' && role !== 'worker') {
+        const current = loadConfig().role ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'worker' : 'queen');
+        console.log('  Usage: beehaven swarm role <queen|worker>');
+        console.log(dim(`  This machine is currently: ${current === 'queen' ? yellow('👑 queen') : 'worker'}`));
+        return;
+    }
+    // 1) Persist locally so it survives restarts + the daemon re-registers with it.
+    saveConfig({ role });
+    // 2) Update the cloud row immediately so the swarm reflects it now (the daemon
+    //    catches up its own role on its next register, ~2 min, or `beehaven restart`).
+    const deviceId = thisDeviceId();
+    let synced = false;
+    try {
+        const r = unwrap(await rpcOnce('hive-set-role', { deviceId, role }, 8_000));
+        synced = !!r?.ok;
+    }
+    catch {
+        /* daemon offline — local config still saved; applies on next connect */
+    }
+    console.log('');
+    console.log(`  ${green('✓')} This machine is now the ${role === 'queen' ? yellow('👑 queen hive') : 'worker hive'}.`);
+    console.log(dim(synced
+        ? '  Synced to the swarm. It orchestrates from here.'
+        : '  Saved locally — applies when the daemon next connects (beehaven restart to apply now).'));
+    console.log('');
+}
+async function swarmWhoami() {
+    const cfg = loadConfig();
+    const deviceId = thisDeviceId();
+    const role = cfg.role ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'worker' : 'queen');
+    const kind = process.env.BEEHAVEN_KIND ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'headless' : 'local-mac');
+    console.log('');
+    console.log(`  🐝 ${bold('This beehive')}`);
+    console.log(`     deviceId:  ${cyan(deviceId)}`);
+    console.log(`     role:      ${role === 'queen' ? yellow('👑 queen') : 'worker'}  ${dim('(beehaven swarm role <queen|worker>)')}`);
+    console.log(`     kind:      ${kind}`);
+    // Best-effort live view from the swarm registry.
+    try {
+        const res = unwrap(await rpcOnce('swarm-list', {}, 5_000));
+        const me = (res?.beehives ?? []).find((b) => b.deviceId === deviceId);
+        if (me) {
+            console.log(`     online:    ${me.online ? green('yes') : dim('no')}`);
+            console.log(`     hives:     ${(me.capabilities ?? []).join(', ') || dim('none')}`);
+        }
+        else {
+            console.log(dim('     not yet registered in the swarm — the daemon registers on connect.'));
+        }
+    }
+    catch {
+        /* daemon offline */
+    }
+    console.log('');
+}