@clearlysh/beehaven 0.8.16

package/dist/buildings/daemon-workspace.js

@@ -0,0 +1,475 @@
+/**
+ * DaemonWorkspace — The local Workspace that IS the beehaven daemon.
+ *
+ * Runs inside the local app server on the user's machine. Exposes filesystem,
+ * shell, metrics, transcripts, and events as proper Workspace primitives so:
+ *   - Electron app connects via ws://localhost:9876/cell/daemon/main/ws
+ *   - Same useFolder(), useRPC() hooks work against local data (zero latency)
+ *   - Cloud DO bridges to this via relay.onLocalAppFetch
+ *   - Claude Code agent calls actions for tool use
+ *
+ * Replaces: bespoke relay handlers, IPC server, .clearly/ YAML sync,
+ * in-memory AgentMetrics, TranscriptTailer JSONL, file-browser.ts.
+ */
+import { readFileSync, writeFileSync, existsSync, statSync, readdirSync, mkdirSync } from 'fs';
+import { execSync, execFileSync, spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+// ── Workspace Class ─────────────────────────────────────────────────
+// The actual base class is injected at registration time by LocalHive.
+// For authoring: we declare the shape and cast in the factory export.
+/**
+ * Build the DaemonWorkspace class dynamically.
+ * Called once from daemon.ts after dynamic-importing the SDK.
+ *
+ * This factory pattern avoids a top-level import of @clearly-sh/beehaven-core
+ * which would fail if the package isn't installed (it's a peer dep).
+ */
+export function createDaemonWorkspaceClass(Workspace) {
+    return class DaemonWorkspace extends Workspace {
+        // ════════════════════════════════════════════════════════════════
+        // TABLES — Persistent, queryable, auto-synced to connected clients
+        // ════════════════════════════════════════════════════════════════
+        /** Claude Code hook events (sessionStart, toolUse, etc.) */
+        events = this.folder('events', {
+            session_id: 'string',
+            event_type: 'string', // SessionStart, PostToolUse, etc.
+            tool_name: 'string',
+            summary: 'string',
+            cwd: 'string',
+            timestamp: 'date',
+        }, {
+            indexes: [['timestamp'], ['session_id'], ['event_type']],
+            sync: 'full',
+            clientWrite: false,
+        });
+        /** Agent metrics snapshots */
+        metrics = this.folder('metrics', {
+            session_id: 'string',
+            tool_calls: 'int',
+            files_changed: 'int',
+            errors: 'int',
+            velocity: 'number',
+            timestamp: 'date',
+        }, {
+            indexes: [['timestamp'], ['session_id']],
+            sync: 'full',
+            clientWrite: false,
+        });
+        /** Full conversation transcript entries */
+        transcript = this.folder('transcript', {
+            session_id: 'string',
+            entry_type: 'string', // user, assistant, tool_use, tool_result, thinking
+            role: 'string',
+            content: 'string',
+            tool_name: 'string',
+            tool_input: 'json',
+            tool_response: 'string',
+            uuid: 'string',
+            timestamp: 'date',
+        }, {
+            indexes: [['session_id'], ['timestamp'], ['entry_type']],
+            sync: 'lazy', // Large — don't hydrate all at once
+            clientWrite: false,
+        });
+        /** Active tunnel URLs */
+        tunnels = this.folder('tunnels', {
+            session_id: 'string',
+            port: 'int',
+            url: 'string',
+            started_at: 'date',
+        }, {
+            sync: 'full',
+            clientWrite: false,
+        });
+        /** Daemon status / presence */
+        status = this.folder('status', {
+            key: 'string',
+            value: 'json',
+            updated_at: 'date',
+        }, {
+            sync: 'full',
+            clientWrite: false,
+        });
+        // ════════════════════════════════════════════════════════════════
+        // RING BUFFERS — Ephemeral, capacity-limited, real-time
+        // ════════════════════════════════════════════════════════════════
+        /** Live activity log (last 200 events for REPL/avatar display) */
+        activityLog = this.ringBuffer('activity', {
+            schema: {
+                type: 'string',
+                summary: 'string',
+                session_id: 'string',
+                timestamp: 'date',
+            },
+            capacity: 200,
+        });
+        // ════════════════════════════════════════════════════════════════
+        // ACTIONS — Filesystem
+        // ════════════════════════════════════════════════════════════════
+        /** Read a file with optional line range */
+        fsRead = this.install('fs:read', {
+            input: { path: 'string', offset: 'int', limit: 'int' },
+            run: async (input) => {
+                const filePath = input.path;
+                if (!filePath)
+                    throw new Error('path is required');
+                if (!existsSync(filePath))
+                    throw new Error(`File not found: ${filePath}`);
+                const stat = statSync(filePath);
+                if (stat.isDirectory())
+                    throw new Error(`${filePath} is a directory, not a file`);
+                if (stat.size > 5 * 1024 * 1024)
+                    throw new Error(`File too large (${Math.round(stat.size / 1024)}KB). Max 5MB.`);
+                const text = readFileSync(filePath, 'utf8');
+                const lines = text.split('\n');
+                const offset = Math.max(0, (input.offset || 1) - 1);
+                const limit = input.limit || lines.length;
+                const slice = lines.slice(offset, offset + limit);
+                const numbered = slice
+                    .map((line, i) => {
+                    const lineNum = String(offset + i + 1).padStart(6, ' ');
+                    return `${lineNum}\t${line}`;
+                })
+                    .join('\n');
+                const content = numbered.length > 50_000 ? numbered.slice(0, 50_000) + '\n... (truncated)' : numbered;
+                return { content };
+            },
+        });
+        /** Write content to a file */
+        fsWrite = this.install('fs:write', {
+            input: { path: 'string', content: 'string' },
+            run: async (input) => {
+                const { path: filePath, content } = input;
+                if (!filePath || content === undefined)
+                    throw new Error('path and content are required');
+                const dir = dirname(filePath);
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true });
+                writeFileSync(filePath, content, 'utf8');
+                return { path: filePath, bytes: content.length };
+            },
+        });
+        /** Edit a file with string replacement */
+        fsEdit = this.install('fs:edit', {
+            input: { path: 'string', old_string: 'string', new_string: 'string' },
+            run: async (input) => {
+                const { path: filePath, old_string: oldStr, new_string: newStr } = input;
+                if (!filePath || !oldStr || newStr === undefined)
+                    throw new Error('path, old_string, and new_string are required');
+                if (!existsSync(filePath))
+                    throw new Error(`File not found: ${filePath}`);
+                const text = readFileSync(filePath, 'utf8');
+                const occurrences = text.split(oldStr).length - 1;
+                if (occurrences === 0)
+                    throw new Error(`old_string not found in ${filePath}`);
+                if (occurrences > 1)
+                    throw new Error(`old_string appears ${occurrences} times — must be unique`);
+                writeFileSync(filePath, text.replace(oldStr, newStr), 'utf8');
+                return { path: filePath, replacements: 1 };
+            },
+        });
+        /** Glob pattern matching */
+        fsGlob = this.install('fs:glob', {
+            input: { pattern: 'string' },
+            run: async (input) => {
+                let pattern = input.pattern;
+                if (!pattern)
+                    throw new Error('pattern is required');
+                pattern = pattern.replace(/\/\//g, '/');
+                const globStart = pattern.search(/[*?{[]/);
+                const baseDir = globStart >= 0
+                    ? pattern.slice(0, pattern.lastIndexOf('/', globStart) + 1) || '.'
+                    : pattern;
+                if (!existsSync(baseDir))
+                    throw new Error(`Directory not found: ${baseDir}`);
+                const matches = [];
+                const regex = patternToRegex(pattern);
+                walkDir(baseDir, matches, regex, 500, 8);
+                return { matches, count: matches.length };
+            },
+        });
+        /** List directory contents */
+        fsLs = this.install('fs:ls', {
+            input: { path: 'string' },
+            run: async (input) => {
+                const dirPath = input.path || homedir();
+                if (!existsSync(dirPath))
+                    throw new Error(`Directory not found: ${dirPath}`);
+                const stat = statSync(dirPath);
+                if (!stat.isDirectory())
+                    throw new Error(`Not a directory: ${dirPath}`);
+                const entries = readdirSync(dirPath, { withFileTypes: true });
+                const items = [];
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = join(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        items.push({ name: entry.name, type: 'dir' });
+                    }
+                    else {
+                        try {
+                            const fstat = statSync(fullPath);
+                            items.push({ name: entry.name, type: 'file', size: fstat.size });
+                        }
+                        catch {
+                            items.push({ name: entry.name, type: 'file', size: 0 });
+                        }
+                    }
+                }
+                return { path: dirPath, entries: items };
+            },
+        });
+        /** Search file contents with regex */
+        fsGrep = this.install('fs:grep', {
+            input: { pattern: 'string', path: 'string' },
+            run: async (input) => {
+                const { pattern, path: searchPath } = input;
+                if (!pattern)
+                    throw new Error('pattern is required');
+                const dir = searchPath || homedir();
+                try {
+                    const output = execFileSync('grep', ['-rn', '--include=*', pattern, dir], {
+                        cwd: dir,
+                        timeout: 30_000,
+                        maxBuffer: 1024 * 1024,
+                        encoding: 'utf8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    const content = output.length > 50_000 ? output.slice(0, 50_000) + '\n... (truncated)' : output;
+                    return { content, truncated: output.length > 50_000 };
+                }
+                catch (err) {
+                    if (err.status === 1)
+                        return { content: '', truncated: false };
+                    throw new Error(err.stderr || err.message || 'grep failed');
+                }
+            },
+        });
+        // ════════════════════════════════════════════════════════════════
+        // ACTIONS — Shell
+        // ════════════════════════════════════════════════════════════════
+        /** Execute a shell command */
+        shell = this.install('shell', {
+            input: { command: 'string', cwd: 'string', timeout: 'int' },
+            run: async (input) => {
+                const command = input.command;
+                if (!command)
+                    throw new Error('command is required');
+                let cwd = input.cwd || homedir();
+                // Resolve virtual /local/ prefix from cloud agent
+                if (cwd.startsWith('/local/'))
+                    cwd = cwd.slice('/local'.length);
+                if (!existsSync(cwd) && cwd.startsWith('/')) {
+                    const asHome = join(homedir(), cwd);
+                    if (existsSync(asHome))
+                        cwd = asHome;
+                }
+                if (!existsSync(cwd))
+                    throw new Error(`Working directory does not exist: ${cwd}`);
+                const timeout = Math.min(input.timeout || 30_000, 120_000);
+                try {
+                    const output = execSync(command, {
+                        cwd,
+                        timeout,
+                        maxBuffer: 1024 * 1024,
+                        encoding: 'utf8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                        env: { ...process.env, TERM: 'dumb' },
+                    });
+                    const stdout = output.length > 50_000 ? output.slice(0, 50_000) + '\n... (truncated)' : output;
+                    return { stdout, stderr: '', exitCode: 0 };
+                }
+                catch (err) {
+                    return {
+                        stdout: String(err.stdout || '').slice(0, 2000),
+                        stderr: String(err.stderr || '').slice(0, 2000),
+                        exitCode: err.status || 1,
+                    };
+                }
+            },
+        });
+        // ════════════════════════════════════════════════════════════════
+        // ACTIONS — Background Processes
+        // ════════════════════════════════════════════════════════════════
+        _bgProcesses = new Map();
+        /** Start a long-running background process (dev server, watcher) */
+        processStart = this.install('process:start', {
+            input: { command: 'string', cwd: 'string' },
+            run: async (input) => {
+                const command = input.command;
+                if (!command)
+                    throw new Error('command is required');
+                let cwd = input.cwd || homedir();
+                if (cwd.startsWith('/local/'))
+                    cwd = cwd.slice('/local'.length);
+                if (!existsSync(cwd))
+                    cwd = homedir();
+                const id = `proc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+                const proc = spawn('sh', ['-c', command], {
+                    cwd,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    env: { ...process.env, TERM: 'dumb' },
+                });
+                const entry = { proc, output: [], startedAt: Date.now(), command, cwd };
+                this._bgProcesses.set(id, entry);
+                proc.stdout?.on('data', (d) => {
+                    const line = d.toString();
+                    entry.output.push(line);
+                    if (entry.output.length > 200)
+                        entry.output.shift();
+                });
+                proc.stderr?.on('data', (d) => {
+                    const line = d.toString();
+                    entry.output.push(line);
+                    if (entry.output.length > 200)
+                        entry.output.shift();
+                });
+                proc.on('exit', () => {
+                    // Keep for 5 min so output can be read
+                    setTimeout(() => this._bgProcesses.delete(id), 300_000);
+                });
+                return { id, pid: proc.pid, command, cwd };
+            },
+        });
+        /** Check a background process */
+        processCheck = this.install('process:check', {
+            input: { id: 'string' },
+            run: async (input) => {
+                const entry = this._bgProcesses.get(input.id);
+                if (!entry)
+                    throw new Error(`Process not found: ${input.id}`);
+                const running = !entry.proc.killed && entry.proc.exitCode === null;
+                return {
+                    id: input.id,
+                    running,
+                    exitCode: entry.proc.exitCode,
+                    output: entry.output.slice(-50).join(''),
+                    command: entry.command,
+                    cwd: entry.cwd,
+                    uptime: Date.now() - entry.startedAt,
+                };
+            },
+        });
+        /** Kill a background process */
+        processKill = this.install('process:kill', {
+            input: { id: 'string' },
+            run: async (input) => {
+                const entry = this._bgProcesses.get(input.id);
+                if (!entry)
+                    throw new Error(`Process not found: ${input.id}`);
+                entry.proc.kill('SIGTERM');
+                return { id: input.id, killed: true };
+            },
+        });
+        /** List all background processes */
+        processList = this.install('process:list', {
+            run: async () => {
+                const processes = [];
+                for (const [id, entry] of this._bgProcesses) {
+                    const running = !entry.proc.killed && entry.proc.exitCode === null;
+                    processes.push({
+                        id,
+                        command: entry.command,
+                        cwd: entry.cwd,
+                        running,
+                        pid: entry.proc.pid,
+                        uptime: Date.now() - entry.startedAt,
+                    });
+                }
+                return { processes };
+            },
+        });
+        // ════════════════════════════════════════════════════════════════
+        // LIFECYCLE
+        // ════════════════════════════════════════════════════════════════
+        /** Called when a client connects — send initial status */
+        async onConnect(userId, ws) {
+            this.status.upsert({
+                id: 'daemon',
+                key: 'daemon',
+                value: JSON.stringify({
+                    pid: process.pid,
+                    hostname: (await import('os')).hostname(),
+                    platform: process.platform,
+                    arch: process.arch,
+                    nodeVersion: process.version,
+                    startedAt: Date.now(),
+                }),
+                updated_at: Date.now(),
+            });
+        }
+    };
+}
+// ── Utility Functions (extracted from relay.ts) ──────────────────────
+/** Convert a glob pattern to a regex */
+function patternToRegex(pattern) {
+    let regexStr = '^';
+    let i = 0;
+    while (i < pattern.length) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                regexStr += '.*';
+                i += 2;
+                if (pattern[i] === '/') {
+                    i++;
+                } // skip trailing /
+                continue;
+            }
+            regexStr += '[^/]*';
+        }
+        else if (c === '?') {
+            regexStr += '[^/]';
+        }
+        else if (c === '{') {
+            const end = pattern.indexOf('}', i);
+            if (end > i) {
+                const alts = pattern
+                    .slice(i + 1, end)
+                    .split(',')
+                    .map((a) => a.replace(/[.*+?^$|()[\]\\]/g, '\\$&'));
+                regexStr += `(?:${alts.join('|')})`;
+                i = end;
+            }
+            else {
+                regexStr += '\\{';
+            }
+        }
+        else if ('[.*+?^$|()\\]'.includes(c)) {
+            regexStr += '\\' + c;
+        }
+        else {
+            regexStr += c;
+        }
+        i++;
+    }
+    regexStr += '$';
+    return new RegExp(regexStr);
+}
+/** Walk a directory tree, collecting matching paths */
+function walkDir(dir, matches, regex, maxMatches, maxDepth, depth = 0) {
+    if (depth > maxDepth || matches.length >= maxMatches)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (matches.length >= maxMatches)
+            return;
+        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+            continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkDir(fullPath, matches, regex, maxMatches, maxDepth, depth + 1);
+        }
+        else if (regex.test(fullPath)) {
+            matches.push(fullPath);
+        }
+    }
+}