beehaven 0.8.16

package/dist/setup-service.js

@@ -0,0 +1,536 @@
+// ============================================================================
+// Beehaven Service Installer — launchd (macOS) / systemd (Linux)
+//
+// Registers the daemon as a user-level service with auto-restart on crash.
+// No root/sudo required — uses ~/Library/LaunchAgents or ~/.config/systemd/user.
+// ============================================================================
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, readFileSync, chmodSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LABEL = 'sh.clearly.beehaven';
+const LOG_DIR = join(homedir(), '.beehaven', 'logs');
+// macOS
+const LAUNCH_AGENTS_DIR = join(homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = join(LAUNCH_AGENTS_DIR, `${LABEL}.plist`);
+// Linux
+const SYSTEMD_USER_DIR = join(homedir(), '.config', 'systemd', 'user');
+const UNIT_PATH = join(SYSTEMD_USER_DIR, 'beehaven.service');
+// ── Resolve paths ──────────────────────────────────────────────────────────
+function resolveNodePath() {
+    return process.execPath;
+}
+function resolveCliPath() {
+    // Prefer the compiled dist/cli.js adjacent to this file
+    const distCli = join(__dirname, '..', 'dist', 'cli.js');
+    if (existsSync(distCli))
+        return distCli;
+    // Fallback: adjacent cli.js (we're already in dist/)
+    const adjacentCli = join(__dirname, 'cli.js');
+    if (existsSync(adjacentCli))
+        return adjacentCli;
+    // Last resort: resolve from npm global
+    try {
+        const bin = execSync('which beehaven', { encoding: 'utf8' }).trim();
+        // Read the shebang to find the actual script
+        const content = readFileSync(bin, 'utf8');
+        if (content.startsWith('#!/')) {
+            // npm bin wrapper — the real script is this file itself
+            return bin;
+        }
+        return bin;
+    }
+    catch {
+        throw new Error('Could not resolve beehaven CLI path. Is it installed globally?');
+    }
+}
+function getCurrentPath() {
+    return process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+/** Escape strings for safe inclusion in XML/plist files */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+// ── Templates ──────────────────────────────────────────────────────────────
+function generatePlist(nodePath, cliPath) {
+    const envPath = getCurrentPath();
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(cliPath)}</string>
+    <string>start</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(homedir())}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(LOG_DIR)}/stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(LOG_DIR)}/stderr.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(envPath)}</string>
+    <key>HOME</key>
+    <string>${escapeXml(homedir())}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+function generateUnit(nodePath, cliPath) {
+    const envPath = getCurrentPath();
+    return `[Unit]
+Description=Beehaven Daemon — Claude Code activity relay
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart="${nodePath}" "${cliPath}" start
+WorkingDirectory=${homedir()}
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${LOG_DIR}/stdout.log
+StandardError=append:${LOG_DIR}/stderr.log
+Environment=PATH=${envPath}
+Environment=HOME=${homedir()}
+
+[Install]
+WantedBy=default.target`;
+}
+// ── Install ────────────────────────────────────────────────────────────────
+export async function installService() {
+    const platform = process.platform;
+    console.log('');
+    console.log('  \uD83D\uDC1D Beehaven — Install Service');
+    console.log('  \u2501'.repeat(30));
+    console.log('');
+    // Resolve paths
+    const nodePath = resolveNodePath();
+    const cliPath = resolveCliPath();
+    console.log(`  Node:  ${nodePath}`);
+    console.log(`  CLI:   ${cliPath}`);
+    console.log('');
+    // Create log directory with restricted permissions
+    mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+    if (platform === 'darwin') {
+        await installLaunchd(nodePath, cliPath);
+    }
+    else if (platform === 'linux') {
+        await installSystemd(nodePath, cliPath);
+    }
+    else {
+        console.error(`  Unsupported platform: ${platform}`);
+        console.error('  Supported: macOS (launchd), Linux (systemd)');
+        process.exit(1);
+    }
+}
+async function installLaunchd(nodePath, cliPath) {
+    // Unload existing service if present
+    if (existsSync(PLIST_PATH)) {
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}"`, { stdio: 'ignore' });
+        }
+        catch {
+            /* may not be loaded */
+        }
+    }
+    // Write plist
+    mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+    const plist = generatePlist(nodePath, cliPath);
+    writeFileSync(PLIST_PATH, plist, { mode: 0o600 });
+    chmodSync(PLIST_PATH, 0o600);
+    console.log(`  \u2713 Created ${PLIST_PATH} (mode 0600)`);
+    // Load service
+    try {
+        execSync(`launchctl load -w "${PLIST_PATH}"`, { stdio: 'pipe' });
+        console.log('  \u2713 Service loaded (launchd)');
+    }
+    catch (err) {
+        console.error(`  \u2717 Failed to load service: ${err.message}`);
+        console.error('  Try: launchctl load -w ~/Library/LaunchAgents/sh.clearly.beehaven.plist');
+        return;
+    }
+    // Verify
+    await sleep(1000);
+    try {
+        const output = execSync(`launchctl list | grep ${LABEL}`, { encoding: 'utf8' });
+        const parts = output.trim().split(/\s+/);
+        const pid = parts[0];
+        if (pid && pid !== '-') {
+            console.log(`  \u2713 Running (PID ${pid})`);
+        }
+        else {
+            console.log('  \u26A0 Service loaded but not yet running (will start on next login)');
+        }
+    }
+    catch {
+        console.log('  \u26A0 Could not verify — check: launchctl list | grep beehaven');
+    }
+    printSuccess('launchd');
+}
+async function installSystemd(nodePath, cliPath) {
+    // Write unit file
+    mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+    const unit = generateUnit(nodePath, cliPath);
+    writeFileSync(UNIT_PATH, unit, { mode: 0o600 });
+    chmodSync(UNIT_PATH, 0o600);
+    console.log(`  \u2713 Created ${UNIT_PATH} (mode 0600)`);
+    // Reload + enable + start
+    try {
+        execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+        execSync('systemctl --user enable --now beehaven', { stdio: 'pipe' });
+        console.log('  \u2713 Service enabled and started (systemd)');
+    }
+    catch (err) {
+        console.error(`  \u2717 Failed to enable service: ${err.message}`);
+        console.error('  Try: systemctl --user enable --now beehaven');
+        return;
+    }
+    // Verify
+    await sleep(1000);
+    try {
+        const output = execSync('systemctl --user is-active beehaven', { encoding: 'utf8' }).trim();
+        if (output === 'active') {
+            console.log('  \u2713 Running');
+        }
+        else {
+            console.log(`  \u26A0 Status: ${output}`);
+        }
+    }
+    catch {
+        console.log('  \u26A0 Could not verify — check: systemctl --user status beehaven');
+    }
+    printSuccess('systemd');
+}
+function printSuccess(backend) {
+    console.log('');
+    console.log('  Service installed. Beehaven will:');
+    console.log('  • Start automatically on login');
+    console.log('  • Restart automatically on crash (10s delay)');
+    console.log('  • Stay stopped on clean shutdown');
+    console.log('');
+    console.log(`  Logs: ${LOG_DIR}/`);
+    console.log('');
+    if (backend === 'launchd') {
+        console.log('  Manage: use the Clearly Dev Mac app tray.');
+        console.log('    Daemon lifecycle (start/stop/uninstall) is tray-only.');
+        console.log('    Diagnostic: launchctl list | grep beehaven');
+    }
+    else {
+        console.log('  Manage:');
+        console.log('    systemctl --user stop beehaven            # Stop');
+        console.log('    systemctl --user start beehaven           # Start');
+        console.log('    systemctl --user status beehaven          # Status');
+    }
+    console.log('');
+}
+// ── Uninstall ──────────────────────────────────────────────────────────────
+export async function uninstallService() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        await uninstallLaunchd();
+    }
+    else if (platform === 'linux') {
+        await uninstallSystemd();
+    }
+    else {
+        console.log('  No service to uninstall (unsupported platform)');
+    }
+}
+async function uninstallLaunchd() {
+    if (!existsSync(PLIST_PATH)) {
+        console.log('  No launchd service installed');
+        return;
+    }
+    try {
+        execSync(`launchctl unload "${PLIST_PATH}"`, { stdio: 'ignore' });
+    }
+    catch {
+        /* may not be loaded */
+    }
+    unlinkSync(PLIST_PATH);
+    console.log('  \u2713 Removed launchd service');
+}
+async function uninstallSystemd() {
+    if (!existsSync(UNIT_PATH)) {
+        console.log('  No systemd service installed');
+        return;
+    }
+    try {
+        execSync('systemctl --user disable --now beehaven', { stdio: 'ignore' });
+    }
+    catch {
+        /* may not be enabled */
+    }
+    unlinkSync(UNIT_PATH);
+    try {
+        execSync('systemctl --user daemon-reload', { stdio: 'ignore' });
+    }
+    catch {
+        /* best effort */
+    }
+    console.log('  \u2713 Removed systemd service');
+}
+// ── Check if service is installed ──────────────────────────────────────────
+export function isServiceInstalled() {
+    if (process.platform === 'darwin')
+        return existsSync(PLIST_PATH);
+    if (process.platform === 'linux')
+        return existsSync(UNIT_PATH);
+    return false;
+}
+// ── Start / Stop (without install/uninstall) ──────────────────────────────
+/** Start the service if installed. Returns true if started via service manager. */
+export function startService() {
+    if (process.platform === 'darwin' && existsSync(PLIST_PATH)) {
+        try {
+            execSync(`launchctl load -w "${PLIST_PATH}"`, { stdio: 'pipe' });
+            console.log('  Service started (launchd).');
+            return true;
+        }
+        catch {
+            // May already be loaded — try kickstart
+            try {
+                execSync(`launchctl start ${LABEL}`, { stdio: 'pipe' });
+                console.log('  Service started (launchd).');
+                return true;
+            }
+            catch { }
+        }
+    }
+    if (process.platform === 'linux' && existsSync(UNIT_PATH)) {
+        try {
+            execSync('systemctl --user start beehaven', { stdio: 'pipe' });
+            console.log('  Service started (systemd).');
+            return true;
+        }
+        catch { }
+    }
+    return false;
+}
+/** Stop the service if installed. Returns true if stopped via service manager. */
+export function stopService() {
+    if (process.platform === 'darwin' && existsSync(PLIST_PATH)) {
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}"`, { stdio: 'pipe' });
+            console.log('  Service stopped (launchd unloaded — will not auto-restart).');
+            return true;
+        }
+        catch { }
+    }
+    if (process.platform === 'linux' && existsSync(UNIT_PATH)) {
+        try {
+            execSync('systemctl --user stop beehaven', { stdio: 'pipe' });
+            console.log('  Service stopped (systemd).');
+            return true;
+        }
+        catch { }
+    }
+    return false;
+}
+// ── Full uninstall (for Mac app uninstall hook) ───────────────────────────
+//
+// Single entry point the Clearly Dev Mac app invokes when the user removes
+// the app. Tears down the LaunchAgent, revokes the server session, purges
+// all local state, and removes the socket + event log. Safe to call
+// repeatedly — every step swallows its own errors.
+//
+// The CLI no longer exposes this as a `beehaven uninstall` command by
+// design; daemon lifecycle is owned by the tray. The Mac app imports this
+// function directly and calls it from its own teardown routine.
+export async function cleanupAll() {
+    const steps = [];
+    const errors = [];
+    // 1. LaunchAgent / systemd unit
+    try {
+        await uninstallService();
+        steps.push('service-unregistered');
+    }
+    catch (err) {
+        errors.push(`service-unregister: ${err?.message ?? err}`);
+    }
+    // 2. Revoke server session + clear keychain token
+    try {
+        const { Relay } = await import('./relay.js');
+        const r = new Relay();
+        await r.deleteSession();
+        steps.push('session-deleted');
+    }
+    catch (err) {
+        errors.push(`session-delete: ${err?.message ?? err}`);
+    }
+    try {
+        const { logout } = await import('./setup-relay.js');
+        logout();
+        steps.push('logged-out');
+    }
+    catch (err) {
+        errors.push(`logout: ${err?.message ?? err}`);
+    }
+    // 3. Socket + event log
+    const { existsSync, unlinkSync, readdirSync, rmSync, readFileSync, writeFileSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    for (const p of ['/tmp/beehaven.sock', '/tmp/beehaven-ipc.sock', '/tmp/beehaven-events.jsonl']) {
+        try {
+            if (existsSync(p)) {
+                unlinkSync(p);
+                steps.push(`removed:${p}`);
+            }
+        }
+        catch { }
+    }
+    try {
+        for (const f of readdirSync('/tmp')) {
+            if (f.startsWith('beehaven-events.jsonl.') && f.endsWith('.old')) {
+                try {
+                    unlinkSync(join('/tmp', f));
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    // 4. ~/.beehaven/ (config, sessions, cache, apps, logs)
+    const configDir = join(homedir(), '.beehaven');
+    try {
+        if (existsSync(configDir)) {
+            rmSync(configDir, { recursive: true, force: true });
+            steps.push('config-dir-removed');
+        }
+    }
+    catch (err) {
+        errors.push(`config-dir: ${err?.message ?? err}`);
+    }
+    /**
+     * 5–6. The `~/.local/bin` wrappers the Mac app writes.
+     *
+     * ⚠⚠ ONLY OURS. These two steps used to `unlinkSync` unconditionally, and that is not a
+     * theoretical hazard — it was observed deleting a developer's own `beehaven`: `cli-installer`'s
+     * `uninstallBeehavenCli` inspected the file, correctly reported *"wrapper is not managed by this
+     * app"*, declined — and then this ran and removed it anyway. Two uninstallers with opposite
+     * policies on the same path, and the destructive one went second.
+     *
+     * ⚠ THE HEADER IS THE OWNERSHIP TEST, and it is the same one the installer uses in the other
+     * direction: it refuses to overwrite a wrapper it did not write. An uninstall has to honour the
+     * same boundary or the pair is incoherent — you can be unable to install over a file you are
+     * nonetheless willing to delete.
+     */
+    const WRAPPER_MAGIC = '# managed-by: clearly-mac-app';
+    const removeOurWrapper = (name) => {
+        try {
+            const wrapper = join(homedir(), '.local', 'bin', name);
+            if (!existsSync(wrapper))
+                return;
+            if (!readFileSync(wrapper, 'utf8').includes(WRAPPER_MAGIC)) {
+                steps.push(`kept:~/.local/bin/${name} (not ours)`);
+                return;
+            }
+            unlinkSync(wrapper);
+            steps.push(`removed:~/.local/bin/${name}`);
+        }
+        catch { }
+    };
+    removeOurWrapper('beehaven');
+    // 6. mwah CLI wrappers — the Mac app installs these under CLEARLY_AVATARS
+    //    (cleanupAll only handled `beehaven` before, so they were orphaned).
+    //    ⚠ Same ownership test as above; see the note there.
+    for (const name of ['mwah', 'mwah-say'])
+        removeOurWrapper(name);
+    // 7. Claude Code integration — the avatar/mwah hooks, skills, commands, and
+    //    caches the Mac app installs (installClaudeAssets), plus the hook entries
+    //    in ~/.claude/settings.json. Leaves ~/.mwah/pets (the user's generated art).
+    const claudeDir = join(homedir(), '.claude');
+    for (const rel of [
+        'hooks/mwah-hook', 'hooks/mwah-narrate', 'hooks/mwah-stream-bubble', 'hooks/mwah-stream-watcher',
+        'skills/mwah-avatar', 'skills/mwah-pet', 'commands/mwah.md',
+    ]) {
+        try {
+            const full = join(claudeDir, rel);
+            if (existsSync(full)) {
+                rmSync(full, { recursive: true, force: true });
+                steps.push(`removed:~/.claude/${rel}`);
+            }
+        }
+        catch { }
+    }
+    for (const cache of ['mwah-scene', 'mwah-stream', 'mwah-narrate']) {
+        try {
+            const full = join(homedir(), '.cache', cache);
+            if (existsSync(full))
+                rmSync(full, { recursive: true, force: true });
+        }
+        catch { }
+    }
+    try {
+        const settingsPath = join(claudeDir, 'settings.json');
+        if (existsSync(settingsPath)) {
+            const cfg = JSON.parse(readFileSync(settingsPath, 'utf8'));
+            let removed = 0;
+            if (cfg && cfg.hooks && typeof cfg.hooks === 'object') {
+                for (const ev of Object.keys(cfg.hooks)) {
+                    const list = cfg.hooks[ev];
+                    if (!Array.isArray(list))
+                        continue;
+                    const kept = list.filter((entry) => !((entry.hooks || []).some((h) => typeof h.command === 'string' && /mwah|spawn-pet/i.test(h.command))));
+                    removed += list.length - kept.length;
+                    if (kept.length)
+                        cfg.hooks[ev] = kept;
+                    else
+                        delete cfg.hooks[ev];
+                }
+                if (removed) {
+                    writeFileSync(settingsPath, JSON.stringify(cfg, null, 2) + '\n');
+                    steps.push(`stripped ${removed} mwah hook(s) from settings.json`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        errors.push(`claude-hooks: ${err?.message ?? err}`);
+    }
+    // 8. On-device voice model caches OUTSIDE ~/.beehaven — the Parakeet-MLX weights
+    //    live in the HuggingFace hub cache, so removing ~/.beehaven alone leaves them
+    //    behind. (The venv + Kokoro model live inside ~/.beehaven, already removed.)
+    try {
+        const hubDir = join(homedir(), '.cache', 'huggingface', 'hub');
+        if (existsSync(hubDir)) {
+            for (const d of readdirSync(hubDir)) {
+                if (/^models--(mlx-community|nvidia)--parakeet/i.test(d)) {
+                    try {
+                        rmSync(join(hubDir, d), { recursive: true, force: true });
+                        steps.push(`removed:hf-cache/${d}`);
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    catch { }
+    return { steps, errors };
+}
+// ── Utilities ──────────────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/shared/bee-memory/index.js

@@ -0,0 +1,6 @@
+/**
+ * Bee Memory Module
+ *
+ * Exports all bee memory types and utilities.
+ */
+export * from './types.js';