beehaven 0.8.16

package/dist/commands/compose.js

@@ -0,0 +1,507 @@
+/**
+ * beehaven compose — site-publishing command family.
+ *
+ *   beehaven compose create [--name <name>]
+ *     Creates a new composition in the user's workspace and writes
+ *     `.beehaven.json` in the current directory linking them together.
+ *     No build yet — use `push` when ready.
+ *
+ *   beehaven compose push
+ *     Reads `.beehaven.json` for compositionId. Detects the project's
+ *     framework (Vite / Next static / Astro / SvelteKit-static / plain
+ *     static). Runs the framework's build command. Uploads the built
+ *     dist/ to R2 under compositions/<id>/build/ via the workspace's
+ *     composition-scoped teleport flag. Updates composition metadata
+ *     with source_type, entry_point, build_size, last_build_at.
+ *
+ *   beehaven compose status
+ *     Prints composition metadata, active share links, view counts.
+ *
+ *   beehaven compose share [--password <pw>] [--expires <date>]
+ *                         [--allow <email,email>] [--immersive]
+ *     Creates a share link. Prints the URL.
+ *
+ *   beehaven compose rm
+ *     Deletes composition + all share links + R2 assets. Confirms first.
+ *
+ * Requires an authed daemon connection (same as all `beehaven call`-
+ * backed commands). The CLI does the local FS work; the workspace DO
+ * handles the persistent state. Source code is not uploaded — only the
+ * built bundle (intentional — keeps R2 footprint small and avoids
+ * leaking .env.local / secrets / node_modules).
+ */
+import { spawnSync } from 'child_process';
+import { readFileSync, writeFileSync, statSync, existsSync, readdirSync } from 'fs';
+import { join, resolve as resolvePath, relative, basename, extname } from 'path';
+import { rpcOnce } from '../ipc-client.js';
+const LINK_FILE = '.beehaven.json';
+// ── Link file (.beehaven.json) ───────────────────────────────────────
+function loadLink(cwd) {
+    const path = join(cwd, LINK_FILE);
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed?.compositionId)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function saveLink(cwd, link) {
+    writeFileSync(join(cwd, LINK_FILE), JSON.stringify(link, null, 2) + '\n');
+}
+// ── Framework detection ──────────────────────────────────────────────
+export function detectProject(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    if (existsSync(pkgPath)) {
+        let pkg = {};
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        }
+        catch { }
+        const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        const hasScript = (name) => pkg.scripts && typeof pkg.scripts[name] === 'string';
+        // Vite — `vite.config.{ts,js,mjs}` + vite dep. Default output: dist/
+        if (hasConfig(cwd, 'vite.config') || deps.vite) {
+            return {
+                framework: 'vite',
+                buildCommand: hasScript('build') ? 'npm run build' : 'npx vite build',
+                distDir: 'dist',
+                entryPoint: 'index.html',
+            };
+        }
+        // Next.js static export. `next.config.{ts,js,mjs}` WITH
+        // `output: 'export'` enables static mode → out/. If not set, Next
+        // needs a Node runtime which we don't support yet.
+        if (deps.next) {
+            const nextConfig = readIfExists(cwd, ['next.config.mjs', 'next.config.ts', 'next.config.js']);
+            if (nextConfig && /output\s*:\s*['"]export['"]/.test(nextConfig)) {
+                return {
+                    framework: 'next-static',
+                    buildCommand: hasScript('build') ? 'npm run build' : 'npx next build',
+                    distDir: 'out',
+                    entryPoint: 'index.html',
+                };
+            }
+            // Non-static Next — can't host, bail with a helpful error.
+            throw new Error('Next.js is present but not configured for static export.\n' +
+                'Add `output: "export"` to next.config.{js,ts,mjs} and re-run, or use a build service that runs Node.');
+        }
+        // Astro — default output: dist/
+        if (deps.astro) {
+            return {
+                framework: 'astro',
+                buildCommand: hasScript('build') ? 'npm run build' : 'npx astro build',
+                distDir: 'dist',
+                entryPoint: 'index.html',
+            };
+        }
+        // SvelteKit with adapter-static → build/
+        if (deps['@sveltejs/kit']) {
+            const svelteConfig = readIfExists(cwd, ['svelte.config.js', 'svelte.config.ts']);
+            if (svelteConfig && /adapter-static/.test(svelteConfig)) {
+                return {
+                    framework: 'sveltekit-static',
+                    buildCommand: hasScript('build') ? 'npm run build' : 'npx vite build',
+                    distDir: 'build',
+                    entryPoint: 'index.html',
+                };
+            }
+            throw new Error('SvelteKit is present but adapter-static is not configured.\n' +
+                'Switch to @sveltejs/adapter-static and re-run.');
+        }
+    }
+    // No package.json OR no known framework deps — treat as static site
+    // if there's an index.html at the root.
+    if (existsSync(join(cwd, 'index.html'))) {
+        return {
+            framework: 'static',
+            buildCommand: null,
+            distDir: '.',
+            entryPoint: 'index.html',
+        };
+    }
+    if (readdirSync(cwd).some((f) => f.endsWith('.html'))) {
+        return {
+            framework: 'plain-html',
+            buildCommand: null,
+            distDir: '.',
+            entryPoint: readdirSync(cwd).find((f) => f.endsWith('.html')) || 'index.html',
+        };
+    }
+    return null;
+}
+function hasConfig(cwd, stem) {
+    return ['.ts', '.js', '.mjs', '.cjs'].some((ext) => existsSync(join(cwd, stem + ext)));
+}
+function readIfExists(cwd, candidates) {
+    for (const c of candidates) {
+        const p = join(cwd, c);
+        if (existsSync(p)) {
+            try {
+                return readFileSync(p, 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+// ── Walk + upload ────────────────────────────────────────────────────
+function walkFiles(root, acc = [], ignore = new Set(['node_modules', '.git', '.beehaven.json'])) {
+    for (const name of readdirSync(root)) {
+        if (ignore.has(name))
+            continue;
+        const full = join(root, name);
+        const stat = statSync(full);
+        if (stat.isDirectory())
+            walkFiles(full, acc, ignore);
+        else
+            acc.push(full);
+    }
+    return acc;
+}
+async function uploadFile(file, relPath, compositionId) {
+    const INLINE_MAX_BYTES = 900 * 1024;
+    const content = readFileSync(file);
+    const size = content.length;
+    const mimeMap = {
+        html: 'text/html',
+        js: 'application/javascript',
+        mjs: 'application/javascript',
+        css: 'text/css',
+        json: 'application/json',
+        svg: 'image/svg+xml',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        webp: 'image/webp',
+        gif: 'image/gif',
+        ico: 'image/x-icon',
+        mp3: 'audio/mpeg',
+        mp4: 'video/mp4',
+        wav: 'audio/wav',
+        woff: 'font/woff',
+        woff2: 'font/woff2',
+        ttf: 'font/ttf',
+        pdf: 'application/pdf',
+        zip: 'application/zip',
+        txt: 'text/plain',
+        md: 'text/markdown',
+        xml: 'application/xml',
+    };
+    const ext = extname(relPath).slice(1).toLowerCase();
+    const mimeType = mimeMap[ext] || 'application/octet-stream';
+    const key = `compositions/${compositionId}/build/${relPath}`;
+    try {
+        if (size <= INLINE_MAX_BYTES) {
+            const data = content.toString('base64');
+            const res = await rpcOnce('file-teleport-inline', {
+                key,
+                name: basename(relPath),
+                mimeType,
+                size,
+                data,
+                composition: true,
+            });
+            if (res?.error)
+                return { ok: false, size, error: res.error };
+            return { ok: true, size };
+        }
+        // Large-file path — get presigned URL, PUT directly, then notify.
+        const intent = await rpcOnce('get-upload-url', {
+            key,
+            contentType: mimeType,
+            maxSize: size,
+        });
+        if (!intent?.uploadUrl)
+            return { ok: false, size, error: intent?.error || 'no uploadUrl' };
+        let uploadUrl = intent.uploadUrl;
+        if (uploadUrl.startsWith('/')) {
+            // Prepend relay host from daemon config (same pattern as cmdTeleport).
+            let relayHost = 'https://relay.clearly.sh';
+            try {
+                const cfg = JSON.parse(readFileSync(join(process.env.HOME || '~', '.beehaven', 'config.json'), 'utf-8'));
+                if (cfg.endpoint)
+                    relayHost = String(cfg.endpoint)
+                        .replace(/^wss:/, 'https:')
+                        .replace(/^ws:/, 'http:')
+                        .replace(/\/$/, '');
+            }
+            catch { }
+            uploadUrl = relayHost + uploadUrl;
+        }
+        const putRes = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: { 'Content-Type': mimeType },
+            body: content,
+        });
+        if (!putRes.ok)
+            return { ok: false, size, error: `PUT ${putRes.status}` };
+        const confirm = await rpcOnce('file-uploaded', {
+            key,
+            name: basename(relPath),
+            mime: mimeType,
+            size,
+            composition: true,
+        });
+        if (confirm?.error)
+            return { ok: false, size, error: confirm.error };
+        return { ok: true, size };
+    }
+    catch (err) {
+        return { ok: false, size, error: err?.message || String(err) };
+    }
+}
+// ── Commands ─────────────────────────────────────────────────────────
+export async function cmdComposeCreate(values) {
+    const cwd = process.cwd();
+    if (loadLink(cwd)) {
+        console.error(`  This directory is already linked to a composition. Use \`beehaven compose push\` to update it, or delete ${LINK_FILE} first.`);
+        process.exit(1);
+    }
+    const name = values.name || basename(cwd);
+    try {
+        // Use the dedicated site-publish RPC so the composition lands with
+        // type='site' + source_type set (distinguishes pushed sites from
+        // legacy design compositions). Falls back to composition-create on
+        // older deployments for graceful rollout.
+        let res = await rpcOnce('compose-upload-init', { name });
+        if (!res?.id) {
+            res = await rpcOnce('composition-create', {
+                title: name,
+                data: JSON.stringify({ blocks: [] }),
+                type: 'site',
+            });
+        }
+        if (!res?.id) {
+            console.error(`  Failed to create composition: ${res?.error ?? 'unknown'}`);
+            process.exit(1);
+        }
+        saveLink(cwd, { compositionId: res.id, name, createdAt: Date.now() });
+        console.log(`  \u2713 Composition "${name}" created`);
+        console.log(`    id: ${res.id}`);
+        console.log(`    Linked to: ${cwd}`);
+        console.log('');
+        console.log(`  Next: \`beehaven compose push\` to build + publish.`);
+    }
+    catch (err) {
+        console.error(`  Error: ${err?.message || err}`);
+        process.exit(1);
+    }
+}
+export async function cmdComposePush(_values) {
+    // Two callers: the CLI verb (`beehaven compose push`) reads
+    // `_values.dir` + `_values.composition` if present to support
+    // arbitrary dirs + explicit composition ids — the publish-landing
+    // verb uses this to upload Claude-generated builds without first
+    // running `compose create`. The legacy form (no overrides) falls
+    // back to cwd + .beehaven.json link file.
+    const cwd = String(_values?.dir || process.cwd());
+    const explicitCompId = String(_values?.composition || '').trim();
+    const link = explicitCompId
+        ? { compositionId: explicitCompId, name: 'unnamed', createdAt: Date.now() }
+        : loadLink(cwd);
+    if (!link) {
+        console.error(`  No composition linked. Run \`beehaven compose create\` first, or pass --composition <id> + --dir <path>.`);
+        process.exit(1);
+    }
+    // Detect project
+    let project;
+    try {
+        project = detectProject(cwd);
+    }
+    catch (err) {
+        console.error(`  ${err.message}`);
+        process.exit(1);
+    }
+    if (!project) {
+        console.error(`  No supported project detected in ${cwd}.\n  Supported: Vite, Next (output: 'export'), Astro, SvelteKit (adapter-static), plain static HTML.`);
+        process.exit(1);
+    }
+    console.log(`  Detected: ${project.framework}`);
+    // Build (if needed)
+    if (project.buildCommand) {
+        console.log(`  Running: ${project.buildCommand}`);
+        const [cmd, ...args] = project.buildCommand.split(' ');
+        const res = spawnSync(cmd, args, { cwd, stdio: 'inherit' });
+        if (res.status !== 0) {
+            console.error(`  Build failed with exit ${res.status}`);
+            process.exit(1);
+        }
+    }
+    // Verify dist exists
+    const distPath = resolvePath(cwd, project.distDir);
+    if (!existsSync(distPath)) {
+        console.error(`  Build output missing: ${distPath}`);
+        process.exit(1);
+    }
+    const entryFullPath = join(distPath, project.entryPoint);
+    if (!existsSync(entryFullPath)) {
+        console.error(`  Entry point missing: ${relative(cwd, entryFullPath)}`);
+        process.exit(1);
+    }
+    // Walk + upload
+    const files = walkFiles(distPath);
+    let totalSize = 0;
+    let ok = 0, failed = 0;
+    console.log(`  Uploading ${files.length} files...`);
+    for (const file of files) {
+        const relPath = relative(distPath, file);
+        const res = await uploadFile(file, relPath, link.compositionId);
+        if (res.ok) {
+            ok++;
+            totalSize += res.size;
+        }
+        else {
+            failed++;
+            console.error(`    \u2717 ${relPath}: ${res.error}`);
+        }
+    }
+    console.log(`  \u2713 Uploaded ${ok}/${files.length} files (${(totalSize / 1024).toFixed(1)}KB)`);
+    if (failed > 0) {
+        console.error(`  ${failed} files failed — composition may be partial. Retry with \`beehaven compose push\`.`);
+        process.exit(1);
+    }
+    // Stamp composition metadata (source_type, entry_point, build_size,
+    // last_build_at). Uses the dedicated finalize RPC; falls back to the
+    // legacy update-meta for older deployments.
+    try {
+        await rpcOnce('compose-upload-finalize', {
+            compositionId: link.compositionId,
+            totalBytes: totalSize,
+            entryPoint: project.entryPoint,
+        });
+        // compose-upload-init on replay sets source_type; idempotent refresh.
+        await rpcOnce('compose-upload-init', {
+            compositionId: link.compositionId,
+            sourceType: project.framework,
+            entryPoint: project.entryPoint,
+        });
+    }
+    catch {
+        try {
+            await rpcOnce('composition-update-meta', {
+                compositionId: link.compositionId,
+                type: 'site',
+                source_type: project.framework,
+                entry_point: project.entryPoint,
+                build_size: totalSize,
+                last_build_at: Date.now(),
+            });
+        }
+        catch {
+            /* non-blocking */
+        }
+    }
+    console.log('');
+    console.log(`  Composition live at:`);
+    console.log(`    https://clearly.sh/app/compositions/${link.compositionId}`);
+    console.log('');
+    console.log(`  Create a public share link with:`);
+    console.log(`    beehaven compose share --password <pw>`);
+}
+export async function cmdComposeStatus(_values) {
+    const cwd = process.cwd();
+    const link = loadLink(cwd);
+    if (!link) {
+        console.error(`  No composition linked here. Run \`beehaven compose create\` first.`);
+        process.exit(1);
+    }
+    console.log(`  ${link.name}`);
+    console.log(`    id: ${link.compositionId}`);
+    console.log(`    linked: ${new Date(link.createdAt).toLocaleString()}`);
+    try {
+        const shares = await rpcOnce('share-link-list', { compositionId: link.compositionId });
+        const links = shares?.links ?? [];
+        console.log('');
+        console.log(`  Share links: ${links.length}`);
+        for (const l of links) {
+            const lock = l.has_password ? '🔒' : '·';
+            const revoked = l.revoked_at ? ' (revoked)' : '';
+            const expired = l.expires_at && l.expires_at < Date.now() ? ' (expired)' : '';
+            console.log(`    ${lock} /r/${l.id} — ${l.view_count} views${revoked}${expired}`);
+        }
+    }
+    catch (err) {
+        console.error(`    (couldn't load share links: ${err?.message})`);
+    }
+}
+export async function cmdComposeShare(values) {
+    const cwd = process.cwd();
+    const link = loadLink(cwd);
+    if (!link) {
+        console.error(`  No composition linked here. Run \`beehaven compose create\` first.`);
+        process.exit(1);
+    }
+    const input = { compositionId: link.compositionId };
+    if (values.password)
+        input.password = String(values.password);
+    if (values.label)
+        input.label = String(values.label);
+    if (values.immersive)
+        input.immersive = true;
+    if (values.expires) {
+        const t = Date.parse(String(values.expires));
+        if (Number.isFinite(t))
+            input.expiresAt = t;
+    }
+    if (values.allow) {
+        const list = String(values.allow)
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (list.length > 0)
+            input.allowList = list;
+    }
+    try {
+        const res = await rpcOnce('share-link-create', input);
+        if (!res?.id) {
+            console.error(`  Failed: ${res?.error ?? 'unknown'}`);
+            process.exit(1);
+        }
+        console.log(`  \u2713 Share link created`);
+        console.log(`    https://clearly.sh/r/${res.id}`);
+        if (input.password)
+            console.log(`    Password: ${input.password}`);
+        if (input.expiresAt)
+            console.log(`    Expires: ${new Date(input.expiresAt).toLocaleString()}`);
+        if (input.allowList)
+            console.log(`    Allow-list: ${input.allowList.join(', ')}`);
+    }
+    catch (err) {
+        console.error(`  Error: ${err?.message || err}`);
+        process.exit(1);
+    }
+}
+export async function cmdComposeRm(values) {
+    const cwd = process.cwd();
+    const link = loadLink(cwd);
+    if (!link) {
+        console.error(`  No composition linked here.`);
+        process.exit(1);
+    }
+    if (!values.force) {
+        console.error(`  This will delete composition "${link.name}" and all its share links.`);
+        console.error(`  Re-run with --force to confirm.`);
+        process.exit(1);
+    }
+    try {
+        await rpcOnce('composition-delete', { id: link.compositionId });
+        // Remove link file last so we don't orphan the directory if the RPC fails
+        try {
+            writeFileSync(join(cwd, LINK_FILE), '', { flag: 'wx' });
+        }
+        catch { }
+        console.log(`  \u2713 Composition deleted`);
+    }
+    catch (err) {
+        console.error(`  Error: ${err?.message || err}`);
+        process.exit(1);
+    }
+}

package/dist/commands/composition.js

@@ -0,0 +1,95 @@
+/**
+ * `beehaven composition` (#47b) — bind a Clearly composition (canvas
+ * board) to a local repo, so a daemon-spawned coding agent works in the
+ * real codebase and shares a Claude Code project 1:1 with that repo.
+ *
+ *   beehaven composition bind <compositionId> <repoPath>
+ *   beehaven composition unbind <compositionId>
+ *   beehaven composition list
+ *
+ * The binding lives in `~/.clearly/composition-repos.json` and is read
+ * fresh by the daemon on the next omni session for that composition — no
+ * daemon restart needed to (un)bind. See `composition-repos.ts` for the
+ * resolution rules (stale bindings fall back to the scratch dir).
+ */
+import { resolve as resolvePath } from 'node:path';
+import { existsSync, statSync } from 'node:fs';
+import { setCompositionRepo, listCompositionRepos, resolveBoundRepo, compositionRepoMapPath, } from '../composition-repos.js';
+export async function cmdComposition(sub, positionals, values) {
+    switch (sub) {
+        case 'bind':
+            return cmdBind(positionals, values);
+        case 'unbind':
+        case 'unmap':
+            return cmdUnbind(positionals, values);
+        case 'list':
+        case 'ls':
+        case undefined:
+        case '':
+            return cmdList(values);
+        default:
+            console.error(`  Unknown subcommand: ${sub}`);
+            console.error('  Usage: beehaven composition <bind|unbind|list> [args]');
+            process.exit(1);
+    }
+}
+function cmdBind(positionals, values) {
+    const compositionId = positionals[0];
+    const rawPath = positionals[1];
+    if (!compositionId || !rawPath) {
+        console.error('  Usage: beehaven composition bind <compositionId> <repoPath>');
+        process.exit(1);
+        return;
+    }
+    const repoPath = resolvePath(rawPath);
+    if (!existsSync(repoPath) || !statSync(repoPath).isDirectory()) {
+        console.error(`  ✗ Not a directory: ${repoPath}`);
+        process.exit(1);
+        return;
+    }
+    const isGit = existsSync(resolvePath(repoPath, '.git'));
+    setCompositionRepo(compositionId, repoPath);
+    if (values.json) {
+        console.log(JSON.stringify({ compositionId, repoPath, isGit }, null, 2));
+        return;
+    }
+    console.log(`  ✓ Bound composition ${compositionId}`);
+    console.log(`      → ${repoPath}${isGit ? '' : '   (note: no .git — agent will still run here)'}`);
+    console.log(`    The next Claude-model run on this board opens its agent in that repo,`);
+    console.log(`    sharing the repo's Claude Code project (1:1). No daemon restart needed.`);
+}
+function cmdUnbind(positionals, values) {
+    const compositionId = positionals[0];
+    if (!compositionId) {
+        console.error('  Usage: beehaven composition unbind <compositionId>');
+        process.exit(1);
+        return;
+    }
+    const had = resolveBoundRepo(compositionId);
+    setCompositionRepo(compositionId, null);
+    if (values.json) {
+        console.log(JSON.stringify({ compositionId, unbound: true, was: had }, null, 2));
+        return;
+    }
+    console.log(`  ✓ Unbound composition ${compositionId}${had ? ` (was ${had})` : ''}`);
+    console.log(`    Future runs fall back to ~/.clearly/compositions/${compositionId}/`);
+}
+function cmdList(values) {
+    const map = listCompositionRepos();
+    const entries = Object.entries(map);
+    if (values.json) {
+        console.log(JSON.stringify(map, null, 2));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log('  No composition→repo bindings.');
+        console.log('  Bind one:  beehaven composition bind <compositionId> <repoPath>');
+        return;
+    }
+    console.log(`  Composition → repo bindings  (${compositionRepoMapPath()})`);
+    for (const [id, path] of entries) {
+        const live = existsSync(path);
+        console.log(`    ${id}`);
+        console.log(`      → ${path}${live ? '' : '   ✗ missing — falls back to scratch dir'}`);
+    }
+}