beehaven 0.8.16

package/dist/commands/library.js

@@ -0,0 +1,229 @@
+/**
+ * `beehaven library` — browse + search the user's cloud library.
+ *
+ * The library is the DO-side index of everything the agent can reference:
+ * voice recordings, TTS outputs, transcripts, code snippets, clipboard
+ * grabs, typed notes. Each row is backed by a body preview (for FTS) and
+ * an optional R2 blob (for audio).
+ *
+ * Commands:
+ *   beehaven library [list]          — recent entries (default)
+ *   beehaven library list --kind audio-in
+ *   beehaven library search "query"  — FTS across title/body/tags
+ *   beehaven library get <id>         — print a row (with signed url if audio)
+ *   beehaven library add "text"       — save a new text row
+ *   beehaven library rm <id>          — delete a row + its R2 blob
+ *
+ * All subcommands route through the daemon → relay → DO library-* actions,
+ * so any surface that can talk to the daemon (Mac app, other CLIs, agents)
+ * sees the same library.
+ */
+import { rpcOnce } from '../ipc-client.js';
+function tsToAge(ts) {
+    if (!ts)
+        return '?';
+    const ms = Date.now() - ts;
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s ago`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m ago`;
+    if (ms < 86_400_000)
+        return `${Math.round(ms / 3_600_000)}h ago`;
+    return `${Math.round(ms / 86_400_000)}d ago`;
+}
+function fmtBytes(n) {
+    if (!n)
+        return '';
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}K`;
+    return `${(n / 1024 / 1024).toFixed(1)}M`;
+}
+function fmtRow(r) {
+    const id = (r.id ?? '').slice(0, 8);
+    const kind = (r.kind ?? 'text').padEnd(10);
+    const age = tsToAge(r.updated_at ?? r.created_at).padStart(8);
+    const size = r.size_bytes ? fmtBytes(r.size_bytes).padStart(6) : '      ';
+    const dur = r.duration_ms > 0 ? `${Math.round(r.duration_ms / 1000)}s` : '';
+    const title = (r.title ?? '').slice(0, 50);
+    const preview = (r.body_preview ?? '').replace(/\s+/g, ' ').slice(0, 40);
+    return `  ${id}  ${kind} ${age} ${size} ${dur.padEnd(4)}  ${title}${preview ? '  — ' + preview : ''}`;
+}
+/**
+ * ⚠⚠ PRINT THE HINT AND THE CANDIDATES, NOT JUST THE ERROR LINE (CBH2-30).
+ *
+ * The server resolves an abbreviated id now, and when it cannot it says WHY — "ids are shown
+ * abbreviated and accepted as a 6+ char prefix", or a list of the entries a prefix matched. This
+ * printed `result.error` alone and dropped both, which is how the whole class of defect survives:
+ * the fix lands on the server and the surface a person reads still shows a dead end.
+ *
+ * ⚠ THE CANDIDATES ARE THE ANSWER TO AN AMBIGUOUS PREFIX. Without them "matches 3 entries" tells
+ * you to type more characters without telling you which ones.
+ */
+function printLibraryError(result) {
+    console.error(`  ${result?.error ?? 'library call failed'}`);
+    if (Array.isArray(result?.matches)) {
+        for (const m of result.matches.slice(0, 10)) {
+            console.error(`    ${String(m.id ?? '')}  ${String(m.kind ?? '')}  ${String(m.title ?? '')}`.trimEnd());
+        }
+    }
+    if (result?.hint)
+        console.error(`  ${result.hint}`);
+}
+export async function cmdLibrary(args, values) {
+    const sub = args[0] || 'list';
+    const timeout = Math.max(Number(values.timeout) || 30_000, 30_000);
+    try {
+        switch (sub) {
+            case 'list':
+            case 'ls': {
+                const result = await rpcOnce('library-list', {
+                    limit: Number(values.limit) || 20,
+                    kind: values.kind,
+                    projectId: values.project,
+                }, timeout);
+                const rows = result?.rows ?? [];
+                if (values.json) {
+                    console.log(JSON.stringify(rows, null, 2));
+                    return;
+                }
+                if (rows.length === 0) {
+                    console.log('  (library is empty)');
+                    return;
+                }
+                console.log(`  ${rows.length} entries (most recent first):`);
+                console.log('');
+                for (const r of rows)
+                    console.log(fmtRow(r));
+                console.log('');
+                return;
+            }
+            case 'search': {
+                const query = args.slice(1).join(' ');
+                if (!query) {
+                    console.error('  Usage: beehaven library search "<query>"');
+                    process.exit(1);
+                }
+                const result = await rpcOnce('library-search', {
+                    query,
+                    limit: Number(values.limit) || 20,
+                }, timeout);
+                const rows = result?.rows ?? [];
+                if (values.json) {
+                    console.log(JSON.stringify(rows, null, 2));
+                    return;
+                }
+                if (rows.length === 0) {
+                    console.log(`  No results for "${query}"`);
+                    return;
+                }
+                console.log(`  ${rows.length} matches for "${query}":`);
+                console.log('');
+                for (const r of rows)
+                    console.log(fmtRow(r));
+                console.log('');
+                return;
+            }
+            case 'get':
+            case 'show':
+            case 'cat': {
+                const id = args[1];
+                if (!id) {
+                    console.error('  Usage: beehaven library get <id>');
+                    process.exit(1);
+                }
+                const result = await rpcOnce('library-get', {
+                    id,
+                    includeSignedUrl: true,
+                }, timeout);
+                if (result?.error) {
+                    printLibraryError(result);
+                    process.exit(1);
+                }
+                if (values.json) {
+                    console.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                const row = result.row;
+                console.log('');
+                console.log(`  id:        ${row.id}`);
+                console.log(`  kind:      ${row.kind}`);
+                console.log(`  title:     ${row.title}`);
+                console.log(`  source:    ${row.source || '—'}`);
+                console.log(`  session:   ${row.session_id || '—'}`);
+                console.log(`  created:   ${new Date(row.created_at).toISOString()}`);
+                if (row.duration_ms > 0)
+                    console.log(`  duration:  ${Math.round(row.duration_ms / 1000)}s`);
+                if (row.size_bytes > 0)
+                    console.log(`  size:      ${fmtBytes(row.size_bytes)}`);
+                if (row.r2_key)
+                    console.log(`  r2_key:    ${row.r2_key}`);
+                if (result.signedUrl)
+                    console.log(`  download:  ${result.signedUrl}`);
+                console.log(`  ref_count: ${row.ref_count ?? 0}`);
+                const tags = typeof row.tags === 'string' ? JSON.parse(row.tags || '[]') : row.tags;
+                if (tags?.length)
+                    console.log(`  tags:      ${tags.join(', ')}`);
+                if (row.body_preview) {
+                    console.log('');
+                    console.log('  body:');
+                    console.log('    ' + row.body_preview.split('\n').join('\n    '));
+                }
+                console.log('');
+                return;
+            }
+            case 'add': {
+                const text = args.slice(1).join(' ');
+                if (!text) {
+                    console.error('  Usage: beehaven library add "<text>" [--kind text|code|clip|url] [--title "..."] [--tags a,b,c]');
+                    process.exit(1);
+                }
+                const tags = values.tags
+                    ? String(values.tags)
+                        .split(',')
+                        .map((t) => t.trim())
+                        .filter(Boolean)
+                    : undefined;
+                const result = await rpcOnce('library-add', {
+                    kind: values.kind || 'text',
+                    title: values.title,
+                    text,
+                    tags,
+                    source: values.source || 'cli',
+                    projectId: values.project,
+                }, timeout);
+                if (result?.error) {
+                    printLibraryError(result);
+                    process.exit(1);
+                }
+                console.log(`  Added: ${result.id}`);
+                return;
+            }
+            case 'rm':
+            case 'delete':
+            case 'remove': {
+                const id = args[1];
+                if (!id) {
+                    console.error('  Usage: beehaven library rm <id>');
+                    process.exit(1);
+                }
+                const result = await rpcOnce('library-delete', { id }, timeout);
+                if (result?.error) {
+                    printLibraryError(result);
+                    process.exit(1);
+                }
+                console.log(`  Deleted ${id}`);
+                return;
+            }
+            default:
+                console.error(`  Unknown subcommand: ${sub}`);
+                console.error(`  Try: beehaven library [list|search|get|add|rm]`);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`  ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/marketplace.js

@@ -0,0 +1,138 @@
+/**
+ * Marketplace Commands — publish and browse beehaven packages.
+ *
+ * A package is a beehaven.json manifest + tools + docs + data.
+ * Published to R2 via the cloud DO.
+ *
+ * beehaven publish              — publish current project as a package
+ * beehaven marketplace          — browse available packages
+ * beehaven marketplace search   — search packages
+ *
+ * NOTE: `beehaven install` is the shorthand for `beehaven app install` —
+ * see commands/app.ts. The previous `cmdInstall` export here (a
+ * marketplace-specific install that wrote project files to cwd) was
+ * removed when the top-level `install` verb was unified with `app
+ * install`. If a separate "install a project-level package" verb is
+ * ever needed again, register it under a different name (e.g.
+ * `beehaven marketplace install`) to keep the meanings distinct.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { rpcOnce } from '../ipc-client.js';
+import { loadManifest } from '../manifest.js';
+/**
+ * `beehaven publish` — package the current project and publish to marketplace.
+ *
+ * Reads beehaven.json, validates, creates a package bundle,
+ * uploads to the cloud DO which stores it in R2.
+ */
+export async function cmdPublish(values) {
+    const cwd = process.cwd();
+    const manifest = loadManifest(cwd);
+    if (!manifest) {
+        console.error('  No beehaven.json found in current directory.');
+        console.error('  Create one with: beehaven init --template api');
+        process.exit(1);
+    }
+    if (!manifest.name) {
+        console.error('  beehaven.json missing required "name" field.');
+        process.exit(1);
+    }
+    console.log(`  Publishing ${manifest.name}@${manifest.version || '0.0.0'}...`);
+    // Collect package metadata
+    const pkg = {
+        name: manifest.name,
+        version: manifest.version || '0.0.0',
+        description: manifest.description || '',
+        author: manifest.author || '',
+        tools: manifest.tools || [],
+        docs: manifest.docs || [],
+        install: manifest.install,
+        price: manifest.price || 'free',
+    };
+    // Include tool source files (for command-based tools)
+    const toolFiles = {};
+    if (manifest.tools) {
+        for (const tool of manifest.tools) {
+            if (tool.command) {
+                // Try to find the script referenced in the command
+                const match = tool.command.match(/^(\S+\s+)?(\S+\.\w+)/);
+                if (match?.[2]) {
+                    const scriptPath = join(cwd, match[2]);
+                    if (existsSync(scriptPath)) {
+                        toolFiles[match[2]] = readFileSync(scriptPath, 'utf8');
+                    }
+                }
+            }
+        }
+    }
+    // Include doc files
+    const docFiles = {};
+    if (manifest.docs) {
+        for (const docPath of manifest.docs) {
+            const abs = join(cwd, docPath);
+            if (existsSync(abs)) {
+                try {
+                    const stat = require('fs').statSync(abs);
+                    if (stat.isFile()) {
+                        docFiles[docPath] = readFileSync(abs, 'utf8');
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    try {
+        const result = await rpcOnce('marketplace:publish', {
+            package: pkg,
+            toolFiles,
+            docFiles,
+        }, 30_000);
+        if (result.error) {
+            console.error(`  Publish failed: ${result.error}`);
+            process.exit(1);
+        }
+        console.log(`  Published: ${manifest.name}@${pkg.version}`);
+        if (result.url)
+            console.log(`  URL: ${result.url}`);
+    }
+    catch (err) {
+        console.error(`  Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * `beehaven marketplace [search]` — browse or search the marketplace.
+ */
+export async function cmdMarketplace(query, values) {
+    try {
+        const result = await rpcOnce('marketplace:list', { query, limit: 50 }, 15_000);
+        if (values.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const packages = result.packages || [];
+        if (packages.length === 0) {
+            console.log(query ? `  No packages matching "${query}".` : '  Marketplace is empty.');
+            return;
+        }
+        console.log('');
+        console.log(`  Beehaven Marketplace — ${packages.length} package(s)`);
+        console.log('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        for (const pkg of packages) {
+            const tools = pkg.tools?.length || 0;
+            const price = pkg.price === 'free' ? '\x1b[32mfree\x1b[0m' : `\x1b[33m$${pkg.price}\x1b[0m`;
+            console.log(`  \x1b[36m${pkg.name}\x1b[0m@${pkg.version || '?'}  ${price}  ${tools} tool(s)`);
+            if (pkg.description)
+                console.log(`    ${pkg.description}`);
+        }
+        console.log('');
+        console.log('  Install: beehaven install <name>');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`  Error: ${err.message}`);
+        process.exit(1);
+    }
+}