@clearlysh/beehaven 0.8.16

package/dist/commands/dev-generate.js

@@ -0,0 +1,125 @@
+/**
+ * Code generation for beehaven dev and deploy.
+ *
+ * Reads the app entry point (src/hive.ts), parses imports to discover
+ * Workspace classes, and generates wrangler.toml + worker.ts (entry point).
+ *
+ * The developer writes their Workspace class directly in TypeScript.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+// ── Discovery ────────────────────────────────────────
+/**
+ * Parse the app entry point to discover building names and their Workspace classes.
+ *
+ * Looks for a `buildings:` block in defineHive() and extracts key → class mappings.
+ * Also scans imports to verify classes extend Workspace.
+ */
+export function discoverBuildings(cwd) {
+    const appEntryPath = join(cwd, 'src', 'hive.ts');
+    if (!existsSync(appEntryPath)) {
+        throw new Error('No src/hive.ts found. Run `beehaven init` first.');
+    }
+    const source = readFileSync(appEntryPath, 'utf8');
+    // Find all classes that extend Workspace (in the same file or imported)
+    // Pattern: class Foo extends Workspace
+    const classPattern = /class\s+(\w+)\s+extends\s+Workspace\b/g;
+    const workspaceClasses = new Set();
+    let classMatch;
+    while ((classMatch = classPattern.exec(source)) !== null) {
+        workspaceClasses.add(classMatch[1]);
+    }
+    // Also look for imported Workspace subclasses from other files
+    // Pattern: import { FooWorkspace } from './workspaces/foo';
+    const importPattern = /import\s+\{([^}]+)\}\s+from\s+['"][^'"]+['"]/g;
+    let importMatch;
+    const importedNames = [];
+    while ((importMatch = importPattern.exec(source)) !== null) {
+        const names = importMatch[1].split(',').map((s) => s
+            .trim()
+            .split(/\s+as\s+/)
+            .pop()
+            .trim());
+        importedNames.push(...names);
+    }
+    // Find the buildings: { ... } block
+    const buildingsPattern = /buildings\s*:\s*\{([^}]+)\}/;
+    const buildingsMatch = buildingsPattern.exec(source);
+    if (!buildingsMatch) {
+        throw new Error('No buildings: { ... } block found in src/hive.ts');
+    }
+    const buildingsBlock = buildingsMatch[1];
+    const buildings = [];
+    // Parse key: ClassName pairs from the buildings block
+    // Handles both `main: MyWorkspace` and `main: MyWorkspace,`
+    const entryPattern = /(\w+)\s*:\s*(\w+)/g;
+    let entryMatch;
+    while ((entryMatch = entryPattern.exec(buildingsBlock)) !== null) {
+        buildings.push({
+            name: entryMatch[1],
+            className: entryMatch[2],
+        });
+    }
+    if (buildings.length === 0) {
+        throw new Error('No buildings found in src/hive.ts buildings: { } block');
+    }
+    return buildings;
+}
+// ── Code Generation ──────────────────────────────────
+/**
+ * Generate wrangler.toml with DO bindings for each building.
+ */
+export function generateWrangler(cwd, buildings, port) {
+    const pkgPath = join(cwd, 'package.json');
+    const name = existsSync(pkgPath)
+        ? JSON.parse(readFileSync(pkgPath, 'utf8')).name || 'beehaven-app'
+        : 'beehaven-app';
+    const bindings = buildings
+        .map((b) => {
+        const bindingName = toScreamingSnake(b.name) + '_DO';
+        return `  { name = "${bindingName}", class_name = "${b.className}" }`;
+    })
+        .join(',\n');
+    const classNames = buildings.map((b) => b.className);
+    const sqliteClassesStr = JSON.stringify(classNames);
+    return `# Auto-generated by beehaven — do not edit
+name = "${name}"
+main = "worker.ts"
+compatibility_date = "2024-12-01"
+compatibility_flags = ["nodejs_compat"]
+
+[durable_objects]
+bindings = [
+${bindings}
+]
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ${sqliteClassesStr}
+`;
+}
+/**
+ * Generate worker.ts entry point that imports from the developer's app entry.
+ */
+export function generateWorker(buildings) {
+    const exports = buildings
+        .map((b) => `export { ${b.className} } from '../../src/hive';`)
+        .join('\n');
+    return `// Auto-generated by beehaven CLI — do not edit
+import { buildWorkerFromDefinition } from '@clearly-sh/beehaven-core/server';
+import appDefinition from '../../src/hive';
+
+${exports}
+
+const worker = buildWorkerFromDefinition(appDefinition);
+
+export default {
+  fetch: worker.fetch,
+  scheduled: worker.scheduled,
+};
+`;
+}
+// ── Helpers ──────────────────────────────────────────
+function toScreamingSnake(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase();
+}

package/dist/commands/dev.js

@@ -0,0 +1,109 @@
+/**
+ * beehaven dev — Start local development server.
+ *
+ * Reads the app entry point (src/hive.ts), discovers Workspace classes,
+ * generates wrangler.toml and worker.ts, then starts wrangler dev. The
+ * developer writes TypeScript directly — wrangler watches src/ for changes
+ * natively.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+import { discoverBuildings, generateWrangler, generateWorker } from './dev-generate.js';
+import { spinner, color } from '../spinner.js';
+export async function dev(cwd, opts = {}) {
+    const port = opts.port || 8787;
+    const appEntryPath = join(cwd, 'src', 'hive.ts');
+    if (!existsSync(appEntryPath)) {
+        console.error('  No src/hive.ts found. Run `beehaven init` first.');
+        process.exit(1);
+    }
+    const s = spinner('Starting dev server...').start();
+    // Discover buildings from app entry
+    const buildings = discoverBuildings(cwd);
+    s.update(`Generating config for ${buildings.length} building(s)...`);
+    // Generate wrangler.toml + worker.ts
+    const genDir = join(cwd, '.beehaven', 'generated');
+    if (!existsSync(genDir))
+        mkdirSync(genDir, { recursive: true });
+    writeFileSync(join(genDir, 'wrangler.toml'), generateWrangler(cwd, buildings, port));
+    writeFileSync(join(genDir, 'worker.ts'), generateWorker(buildings));
+    s.succeed(`Dev server starting on port ${color.bold(String(port))}`);
+    console.log(`  Buildings: ${buildings.map((b) => `${b.name} (${b.className})`).join(', ')}`);
+    console.log(`  Generated ${color.dim('.beehaven/generated/wrangler.toml')}`);
+    console.log(`  Generated ${color.dim('.beehaven/generated/worker.ts')}`);
+    console.log('');
+    // Start wrangler dev — it watches src/ for changes natively
+    // Validate port to prevent shell injection
+    const safePort = parseInt(String(port), 10);
+    if (isNaN(safePort) || safePort < 1 || safePort > 65535) {
+        console.error(`  Invalid port: ${port}. Must be 1-65535.`);
+        process.exit(1);
+    }
+    const wranglerArgs = [
+        'wrangler',
+        'dev',
+        '--port',
+        String(safePort),
+        '--config',
+        join(genDir, 'wrangler.toml'),
+    ];
+    if (opts.env)
+        wranglerArgs.push('--env', opts.env);
+    const wrangler = spawn('npx', wranglerArgs, {
+        cwd,
+        stdio: 'inherit',
+        shell: false,
+        env: { ...process.env },
+    });
+    wrangler.on('error', (err) => {
+        console.error('  Failed to start wrangler:', err.message);
+        console.error('  Make sure wrangler is installed: npm install -D wrangler');
+        process.exit(1);
+    });
+    // ── Tunnel ──────────────────────────────────────────
+    // Expose local dev server to the internet via Cloudflare Quick Tunnel.
+    // Free, no signup, ephemeral URL. Useful for mobile testing + webhooks.
+    let tunnelProc = null;
+    if (opts.tunnel) {
+        // Wait for wrangler to be ready before starting tunnel
+        setTimeout(() => {
+            console.log(`\n  ${color.cyan('Tunnel')} starting...`);
+            tunnelProc = spawn('npx', ['cloudflared', 'tunnel', '--url', `http://localhost:${safePort}`], {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: false,
+                env: { ...process.env },
+            });
+            // Parse the tunnel URL from cloudflared output
+            const parseUrl = (data) => {
+                const output = data.toString();
+                // cloudflared prints: INF |  https://random-name.trycloudflare.com
+                const match = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+                if (match) {
+                    console.log(`\n  ${color.green('Tunnel ready')}: ${color.bold(match[0])}`);
+                    console.log(`  ${color.dim('Share this URL for mobile testing or webhooks')}\n`);
+                }
+            };
+            tunnelProc.stdout?.on('data', parseUrl);
+            tunnelProc.stderr?.on('data', parseUrl);
+            tunnelProc.on('error', (err) => {
+                console.error(`\n  ${color.yellow('Tunnel failed')}: ${err.message}`);
+                console.error(`  Install cloudflared: ${color.dim('brew install cloudflared')}`);
+                console.error(`  Or: ${color.dim('npm install -g cloudflared')}\n`);
+                // Don't exit — dev server still works without tunnel
+            });
+        }, 3000); // Give wrangler 3s to start
+    }
+    const cleanup = () => {
+        if (tunnelProc)
+            tunnelProc.kill('SIGTERM');
+        wrangler.kill('SIGTERM');
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    wrangler.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+}

package/dist/commands/devices.js

@@ -0,0 +1,135 @@
+/**
+ * `beehaven devices` — list connected clients for the current user and
+ * pin/unpin one as the default target for canvas-invoke calls.
+ *
+ *   beehaven devices                    # list
+ *   beehaven devices pin <clientId>     # persist target in ~/.beehaven/target.json
+ *   beehaven devices unpin              # clear the pin
+ *   beehaven devices target             # show what's pinned
+ *
+ * The pinned deviceId is auto-appended to `beehaven call canvas-invoke ...`
+ * and to the `beehaven canvas ...` subcommands.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { rpcOnce } from '../ipc-client.js';
+const DEVICE_TARGET_PATH = join(homedir(), '.beehaven', 'canvas-device.json');
+function readPinned() {
+    try {
+        if (!existsSync(DEVICE_TARGET_PATH))
+            return null;
+        return JSON.parse(readFileSync(DEVICE_TARGET_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writePinned(pin) {
+    mkdirSync(join(homedir(), '.beehaven'), { recursive: true });
+    writeFileSync(DEVICE_TARGET_PATH, JSON.stringify(pin, null, 2), 'utf-8');
+}
+function clearPinned() {
+    try {
+        unlinkSync(DEVICE_TARGET_PATH);
+    }
+    catch { }
+}
+export function getPinnedDevice() {
+    return readPinned();
+}
+function ago(ts) {
+    if (!ts)
+        return '—';
+    const s = Math.floor((Date.now() - ts) / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ago`;
+    if (s < 86400)
+        return `${Math.floor(s / 3600)}h ago`;
+    return `${Math.floor(s / 86400)}d ago`;
+}
+function pad(s, n) {
+    if (s.length >= n)
+        return s.slice(0, n);
+    return s + ' '.repeat(n - s.length);
+}
+export async function cmdDevices(sub, arg, values) {
+    if (sub === 'pin' || sub === 'target-set') {
+        if (!arg) {
+            console.error('  Usage: beehaven devices pin <clientId>');
+            process.exit(1);
+        }
+        // Resolve clientId to a device by listing first — nice UX, enables friendly labels.
+        const list = await fetchDevices();
+        const match = list.find((d) => d.clientId === arg || d.deviceId === arg);
+        if (!match) {
+            console.error(`  No connected device matches '${arg}'. Run 'beehaven devices' to list.`);
+            process.exit(1);
+        }
+        writePinned({
+            clientId: match.clientId,
+            deviceId: match.deviceId,
+            deviceLabel: match.deviceLabel,
+            clientType: match.clientType,
+            pinnedAt: Date.now(),
+        });
+        console.log(`Pinned: ${match.deviceLabel || match.clientId} (${match.clientType || 'web'})`);
+        return;
+    }
+    if (sub === 'unpin' || sub === 'target-clear') {
+        clearPinned();
+        console.log('Pin cleared.');
+        return;
+    }
+    if (sub === 'target' || sub === 'pinned') {
+        const p = readPinned();
+        if (!p) {
+            console.log('No device pinned.');
+            return;
+        }
+        console.log(`Pinned: ${p.deviceLabel || p.clientId}`);
+        console.log(`  clientId:   ${p.clientId}`);
+        console.log(`  clientType: ${p.clientType ?? '—'}`);
+        console.log(`  deviceId:   ${p.deviceId ?? '—'}`);
+        console.log(`  since:      ${new Date(p.pinnedAt).toLocaleString()}`);
+        return;
+    }
+    // Default: list
+    const list = await fetchDevices();
+    if (values.json) {
+        console.log(JSON.stringify({ devices: list, pinned: readPinned() }, null, 2));
+        return;
+    }
+    if (list.length === 0) {
+        console.log('No devices currently connected.');
+        console.log('Open the Clearly web app or the Clearly Dev Mac app on a composition to register one.');
+        return;
+    }
+    const pinned = readPinned();
+    console.log(pad('CLIENT ID', 38) +
+        pad('TYPE', 10) +
+        pad('LABEL', 32) +
+        pad('APP', 10) +
+        pad('LAST ACTIVE', 12));
+    console.log('─'.repeat(102));
+    for (const d of list) {
+        const isPinned = pinned && pinned.clientId === d.clientId;
+        const marker = isPinned ? '★ ' : '  ';
+        const id = d.clientId.length > 32 ? d.clientId.slice(0, 29) + '...' : d.clientId;
+        console.log(marker +
+            pad(id, 36) +
+            pad(d.clientType ?? '—', 10) +
+            pad((d.deviceLabel ?? '—').slice(0, 30), 32) +
+            pad(d.appContext ?? '—', 10) +
+            pad(ago(d.lastActivityAt || d.connectedAt), 12));
+    }
+    if (!pinned) {
+        console.log('\nPin one as the canvas-invoke default:  beehaven devices pin <clientId>');
+    }
+}
+async function fetchDevices() {
+    const out = (await rpcOnce('list-devices', {}, 15_000));
+    return out?.devices ?? [];
+}

package/dist/commands/explain-router.js

@@ -0,0 +1,24 @@
+/**
+ * Thin routing helper extracted from workspace.ts's `resolveBuilding`
+ * so `explain.ts` doesn't import the larger command file.
+ */
+export function resolveBuildingForExplain(action, input, building) {
+    if (!building || building === 'home')
+        return { action, input };
+    const colonIdx = building.indexOf(':');
+    if (colonIdx === -1)
+        return { action, input };
+    const buildingType = building.slice(0, colonIdx);
+    const buildingId = building.slice(colonIdx + 1);
+    // Same type alias as workspace.ts:resolveBuilding — keeps routing consistent.
+    const typeMap = {
+        store: 'store',
+        shopifyStore: 'store',
+        team: 'team',
+    };
+    const resolvedType = typeMap[buildingType] ?? buildingType;
+    return {
+        action: `admin:${resolvedType}-rpc`,
+        input: { storeId: buildingId, action, input },
+    };
+}