beecork 1.7.1 → 2.0.1

package/dist/session/subprocess.js

@@ -1,230 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../util/logger.js';
-import { getMcpConfigPath } from '../util/paths.js';
-// Cache the MCP-config existence check. The file is created at setup time and
-// stable for the daemon's lifetime; we don't need to stat() it per spawn.
-let mcpConfigExistsCache = null;
-function mcpConfigExists() {
-    if (mcpConfigExistsCache !== null)
-        return mcpConfigExistsCache;
-    mcpConfigExistsCache = fs.existsSync(getMcpConfigPath());
-    return mcpConfigExistsCache;
-}
-/** Test-only — reset the existsSync cache between test runs that toggle the mock. */
-export function _resetMcpConfigExistsCacheForTests() {
-    mcpConfigExistsCache = null;
-}
-const BEECORK_SYSTEM_PROMPT = `You are running inside Beecork, an always-on infrastructure for Claude Code.
-
-You have these special MCP tools available:
-- beecork_remember: Store important facts for future sessions (preferences, server addresses, decisions, outcomes)
-- beecork_recall: Search stored memories — ALWAYS call this at the start of complex tasks
-- beecork_task_create: Schedule recurring tasks (types: "at" for one-time, "every" for interval like "30m", "cron" for expressions like "0 9 * * 1")
-- beecork_task_list: List scheduled tasks
-- beecork_task_delete: Remove a scheduled task
-- beecork_tab_create: Create a new virtual tab for parallel work
-- beecork_tab_list: List all tabs
-- beecork_send_message: Send a message to another tab
-- beecork_notify: Send the user a notification mid-task without stopping
-- beecork_status: Check system status
-
-Guidelines:
-- You are running unattended. Be thorough and complete tasks fully.
-- Always call beecork_recall at the start of any task to check relevant memories.
-- Always call beecork_remember when you learn something important.
-- When asked for recurring tasks, use beecork_task_create.
-- Use beecork_notify for progress updates during long tasks.`;
-export class ClaudeSubprocess {
-    tabName;
-    workingDir;
-    config;
-    tabSystemPrompt;
-    proc = null;
-    buffer = '';
-    killTimer = null;
-    runtimeTimer = null;
-    startupTimer = null;
-    /**
-     * Set when the startup watchdog kills a subprocess that never emitted a
-     * single event — distinguishes a transient network/connection stall from a
-     * normal exit or a real wall-clock overrun, so the manager can retry once.
-     */
-    killReason = null;
-    sessionId;
-    constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
-        this.tabName = tabName;
-        this.workingDir = workingDir;
-        this.config = config;
-        this.tabSystemPrompt = tabSystemPrompt;
-        this.sessionId = sessionId ?? uuidv4();
-    }
-    async send(prompt, callbacks, resume = false) {
-        if (this.proc) {
-            throw new Error(`Subprocess for tab "${this.tabName}" is already running`);
-        }
-        const args = this.buildArgs(prompt, resume);
-        logger.debug(`[${this.tabName}] Spawning: ${this.config.claudeCode.bin} ${args.join(' ')}`);
-        this.proc = spawn(this.config.claudeCode.bin, args, {
-            cwd: this.workingDir,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env },
-        });
-        const pid = this.proc.pid;
-        logger.info(`[${this.tabName}] Claude subprocess started (PID: ${pid})`);
-        this.proc.stdout.on('data', (chunk) => {
-            this.buffer += chunk.toString();
-            const lines = this.buffer.split('\n');
-            this.buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const event = JSON.parse(line);
-                    // First real event proves claude initialized and the socket is alive
-                    // — the startup-stall window is over, so disarm the watchdog for good.
-                    // It never re-arms, so legitimate multi-minute tool runs (which emit
-                    // nothing on stdout until the tool returns) are never killed.
-                    if (this.startupTimer) {
-                        clearTimeout(this.startupTimer);
-                        this.startupTimer = null;
-                    }
-                    callbacks.onEvent(event);
-                }
-                catch {
-                    // Non-JSON line (verbose debug output), skip
-                    logger.debug(`[${this.tabName}] non-json: ${line.slice(0, 200)}`);
-                }
-            }
-        });
-        this.proc.stderr.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text) {
-                // claude prints auth failures, rate limits, license issues, and other
-                // operational errors to stderr. Surface at warn so they reach daemon.log
-                // at the default level — debugging "why did claude exit?" otherwise
-                // requires recompiling with a different log level.
-                logger.warn(`[${this.tabName}] claude stderr: ${text.slice(0, 500)}`);
-            }
-        });
-        this.proc.on('error', (err) => {
-            this.proc = null;
-            if (this.runtimeTimer) {
-                clearTimeout(this.runtimeTimer);
-                this.runtimeTimer = null;
-            }
-            if (this.startupTimer) {
-                clearTimeout(this.startupTimer);
-                this.startupTimer = null;
-            }
-            callbacks.onError(err);
-        });
-        this.proc.on('exit', (code) => {
-            this.proc = null;
-            if (this.killTimer) {
-                clearTimeout(this.killTimer);
-                this.killTimer = null;
-            }
-            if (this.runtimeTimer) {
-                clearTimeout(this.runtimeTimer);
-                this.runtimeTimer = null;
-            }
-            if (this.startupTimer) {
-                clearTimeout(this.startupTimer);
-                this.startupTimer = null;
-            }
-            logger.info(`[${this.tabName}] Claude subprocess exited (code: ${code})`);
-            callbacks.onExit(code);
-        });
-        // Hard runtime cap so a wedged claude can't pin a tab forever.
-        // Default 30 minutes. Disable by setting maxRuntimeMs to 0.
-        const maxRuntimeMs = this.config.claudeCode.maxRuntimeMs ?? 30 * 60 * 1000;
-        if (maxRuntimeMs > 0) {
-            this.runtimeTimer = setTimeout(() => {
-                if (!this.proc)
-                    return;
-                logger.warn(`[${this.tabName}] Subprocess exceeded maxRuntimeMs (${maxRuntimeMs}ms) — killing`);
-                callbacks.onError(new Error(`Subprocess timed out after ${Math.round(maxRuntimeMs / 1000)}s`));
-                this.kill();
-            }, maxRuntimeMs);
-        }
-        // Startup watchdog. A healthy claude emits its init event within seconds of
-        // spawn. Total silence this long means it wedged on a stalled network socket
-        // (DNS/connection blip with no client-side timeout) and would otherwise sit
-        // idle until the 30-min maxRuntime kill. Unlike maxRuntime, this routes
-        // through onExit (kill only, no onError) so the manager retries once. It is
-        // disarmed on the first event, so it can only fire before claude initializes
-        // — long-running tools, which emit nothing on stdout until they return, are
-        // never affected.
-        const silentTimeoutMs = this.config.claudeCode.silentTimeoutMs ?? 120_000;
-        if (silentTimeoutMs > 0) {
-            this.startupTimer = setTimeout(() => {
-                if (!this.proc)
-                    return;
-                logger.warn(`[${this.tabName}] No output ${silentTimeoutMs}ms after spawn — killing as silent network stall`);
-                this.killReason = 'silent';
-                this.kill();
-            }, silentTimeoutMs);
-        }
-    }
-    kill() {
-        if (!this.proc)
-            return;
-        logger.info(`[${this.tabName}] Killing subprocess (PID: ${this.proc.pid})`);
-        this.proc.kill('SIGTERM');
-        const proc = this.proc;
-        this.killTimer = setTimeout(() => {
-            try {
-                proc.kill('SIGKILL');
-            }
-            catch {
-                /* already dead */
-            }
-        }, 5000);
-    }
-    get isRunning() {
-        return this.proc !== null;
-    }
-    get pid() {
-        return this.proc?.pid ?? null;
-    }
-    buildArgs(prompt, resume) {
-        const args = [
-            '-p',
-            '--output-format',
-            'stream-json',
-            '--verbose',
-            ...this.config.claudeCode.defaultFlags,
-        ];
-        // Only add MCP config if the file exists. existsSync result is cached at
-        // module scope — the path is stable for the daemon's lifetime, so doing
-        // this once-per-process saves a syscall per claude spawn (every message,
-        // every task firing, every watcher trigger).
-        if (mcpConfigExists()) {
-            args.push('--mcp-config', getMcpConfigPath());
-        }
-        // Inject Beecork system context so Claude knows about available tools
-        if (!resume) {
-            let systemPrompt = BEECORK_SYSTEM_PROMPT;
-            if (this.tabSystemPrompt) {
-                systemPrompt += `\n\n[Tab-specific instructions for "${this.tabName}"]\n${this.tabSystemPrompt}`;
-            }
-            args.push('--system-prompt', systemPrompt);
-        }
-        if (resume) {
-            args.push('--resume', this.sessionId);
-        }
-        else {
-            args.push('--session-id', this.sessionId);
-        }
-        if (this.config.claudeCode.computerUse) {
-            args.push('--computer-use');
-        }
-        if (this.config.claudeCode.maxBudgetUsd) {
-            args.push('--max-budget-usd', String(this.config.claudeCode.maxBudgetUsd));
-        }
-        args.push(prompt);
-        return args;
-    }
-}

package/dist/session/tab-store.d.ts

@@ -1,28 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Tab, TabStatus } from '../types.js';
-/**
- * SQL helpers for the `tabs` table. Single place for any code that needs to
- * read/write tab rows. TabManager owns subprocess lifecycle; TabStore owns
- * the schema knowledge.
- *
- * All methods accept an optional `db` param so they're testable against an
- * in-memory database. The no-arg form uses the singleton.
- */
-export declare const TabStore: {
-    listAll(db?: Database.Database): Tab[];
-    findByName(name: string, db?: Database.Database): Tab | undefined;
-    getIdByName(name: string, db?: Database.Database): string | undefined;
-    countAll(db?: Database.Database): number;
-    countRunning(db?: Database.Database): number;
-    /** All tabs marked 'running' — used by daemon crash-recovery on startup. */
-    findRunning(db?: Database.Database): Tab[];
-    /** Most-recently-active tab — used by MCP to surface "current" context. */
-    mostRecent(db?: Database.Database): Tab | undefined;
-    setStatus(name: string, status: TabStatus, db?: Database.Database): void;
-    setIdleById(id: string, db?: Database.Database): void;
-    /** Used by MCP close-tab to nudge daemon recovery loop. */
-    markRunningAsStopped(name: string, db?: Database.Database): void;
-    setSystemPrompt(name: string, systemPrompt: string, db?: Database.Database): boolean;
-    /** Delete a tab and all of its messages atomically. Returns true if it existed. */
-    deleteWithMessages(name: string, db?: Database.Database): boolean;
-};

package/dist/session/tab-store.js

@@ -1,78 +0,0 @@
-import { getDb } from '../db/index.js';
-function rowToTab(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        sessionId: row.session_id,
-        status: row.status,
-        workingDir: row.working_dir,
-        createdAt: row.created_at,
-        lastActivityAt: row.last_activity_at,
-        pid: row.pid,
-        systemPrompt: row.system_prompt,
-    };
-}
-/**
- * SQL helpers for the `tabs` table. Single place for any code that needs to
- * read/write tab rows. TabManager owns subprocess lifecycle; TabStore owns
- * the schema knowledge.
- *
- * All methods accept an optional `db` param so they're testable against an
- * in-memory database. The no-arg form uses the singleton.
- */
-export const TabStore = {
-    listAll(db = getDb()) {
-        return db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC').all().map(rowToTab);
-    },
-    findByName(name, db = getDb()) {
-        const row = db.prepare('SELECT * FROM tabs WHERE name = ?').get(name);
-        return row ? rowToTab(row) : undefined;
-    },
-    getIdByName(name, db = getDb()) {
-        const row = db.prepare('SELECT id FROM tabs WHERE name = ?').get(name);
-        return row?.id;
-    },
-    countAll(db = getDb()) {
-        return db.prepare('SELECT COUNT(*) as c FROM tabs').get().c;
-    },
-    countRunning(db = getDb()) {
-        return db.prepare("SELECT COUNT(*) as c FROM tabs WHERE status = 'running'").get().c;
-    },
-    /** All tabs marked 'running' — used by daemon crash-recovery on startup. */
-    findRunning(db = getDb()) {
-        return db.prepare("SELECT * FROM tabs WHERE status = 'running'").all().map(rowToTab);
-    },
-    /** Most-recently-active tab — used by MCP to surface "current" context. */
-    mostRecent(db = getDb()) {
-        const row = db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC LIMIT 1').get();
-        return row ? rowToTab(row) : undefined;
-    },
-    setStatus(name, status, db = getDb()) {
-        db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?').run(status, new Date().toISOString(), name);
-    },
-    setIdleById(id, db = getDb()) {
-        db.prepare("UPDATE tabs SET status = 'idle', pid = NULL WHERE id = ?").run(id);
-    },
-    /** Used by MCP close-tab to nudge daemon recovery loop. */
-    markRunningAsStopped(name, db = getDb()) {
-        db.prepare("UPDATE tabs SET status = 'stopped', pid = NULL WHERE name = ? AND status = 'running'").run(name);
-    },
-    setSystemPrompt(name, systemPrompt, db = getDb()) {
-        const result = db
-            .prepare('UPDATE tabs SET system_prompt = ? WHERE name = ?')
-            .run(systemPrompt, name);
-        return result.changes > 0;
-    },
-    /** Delete a tab and all of its messages atomically. Returns true if it existed. */
-    deleteWithMessages(name, db = getDb()) {
-        const id = this.getIdByName(name, db);
-        if (!id)
-            return false;
-        const tx = db.transaction(() => {
-            db.prepare('DELETE FROM messages WHERE tab_id = ?').run(id);
-            db.prepare('DELETE FROM tabs WHERE id = ?').run(id);
-        });
-        tx();
-        return true;
-    },
-};

package/dist/session/tool-classifier.d.ts

@@ -1,4 +0,0 @@
-/** Reserved for future approval mode implementation. Not currently wired into the runtime. */
-export type ToolRisk = 'safe' | 'dangerous';
-/** Classify a tool call as safe or dangerous */
-export declare function classifyTool(toolName: string, input: Record<string, unknown>): ToolRisk;

package/dist/session/tool-classifier.js

@@ -1,56 +0,0 @@
-const SAFE_TOOLS = new Set([
-    'Read', 'Glob', 'Grep', 'LSP', 'WebFetch', 'WebSearch',
-    'ToolSearch', 'TaskGet', 'TaskList',
-]);
-const DANGEROUS_TOOLS = new Set([
-    'Write', 'Edit', 'NotebookEdit',
-    'TaskCreate', 'TaskUpdate', 'TaskStop',
-]);
-const SAFE_BASH_PATTERNS = [
-    /^(ls|cat|head|tail|wc|file|stat|which|type|echo|printf)\b/,
-    /^git\s+(status|log|diff|show|branch|tag|remote)\b/,
-    /^(pwd|whoami|hostname|date|uname|env|printenv)\b/,
-    /^(find|grep|rg|fd|ag)\b/,
-    /^(node|python|ruby|go)\s+--?(version|help)/,
-    /^npm\s+(list|ls|view|info|outdated|audit)\b/,
-    /^curl\s.*-X\s*GET\b/,
-    /^curl\s+(?!.*-X\s*(POST|PUT|DELETE|PATCH))(?!.*--data)(?!.*-d\s)/,
-];
-const DANGEROUS_BASH_PATTERNS = [
-    /^rm\b/,
-    /^(mv|cp)\b.*--?(force|f)\b/,
-    /^chmod\b/,
-    /^chown\b/,
-    /^git\s+(push|reset|rebase|merge|checkout\s+--)\b/,
-    /^(docker|kubectl|terraform|ansible)\b/,
-    /^(sudo|su)\b/,
-    /^npm\s+(publish|install|uninstall|link)\b/,
-    /^(kill|killall|pkill)\b/,
-    /^curl\s.*-X\s*(POST|PUT|DELETE|PATCH)\b/,
-];
-/** Classify a tool call as safe or dangerous */
-export function classifyTool(toolName, input) {
-    if (SAFE_TOOLS.has(toolName))
-        return 'safe';
-    if (DANGEROUS_TOOLS.has(toolName))
-        return 'dangerous';
-    // Bash tool: inspect the command
-    if (toolName === 'Bash') {
-        const command = String(input.command || '').trim();
-        for (const pattern of SAFE_BASH_PATTERNS) {
-            if (pattern.test(command))
-                return 'safe';
-        }
-        for (const pattern of DANGEROUS_BASH_PATTERNS) {
-            if (pattern.test(command))
-                return 'dangerous';
-        }
-        // Default: unknown bash commands are dangerous
-        return 'dangerous';
-    }
-    // MCP tools from external servers: default to dangerous
-    if (toolName.startsWith('mcp__'))
-        return 'dangerous';
-    // Unknown tools: default to dangerous
-    return 'dangerous';
-}

package/dist/tasks/scheduler.d.ts

@@ -1,45 +0,0 @@
-import { exec } from 'node:child_process';
-import type { TabManager, NotifyCallback } from '../session/manager.js';
-export declare const execAsync: typeof exec.__promisify__;
-export declare class TaskScheduler {
-    private tabManager;
-    private onNotify;
-    private nextRunAt;
-    private running;
-    private failureCounts;
-    private stopping;
-    private store;
-    constructor(tabManager: TabManager, onNotify: NotifyCallback | null);
-    /** Load all tasks from store and schedule them */
-    loadAndSchedule(): void;
-    /** Check for the reload signal file and reload if present */
-    checkForReload(): void;
-    /**
-     * Fire any tasks whose nextRunAt has elapsed. Called every ~5s by the daemon
-     * poll loop. This is the macOS-sleep-resilient replacement for setTimeout-driven
-     * cron heartbeats — after a wake, the next tick catches all overdue tasks.
-     */
-    tick(): void;
-    /** Stop the scheduler. In-flight fireJob promises are detached and resolve naturally. */
-    stopAll(): void;
-    /** Compute next run time in ms epoch, given a "from" anchor. Returns null if invalid. */
-    private computeNextRun;
-    private fireJob;
-    /**
-     * Track consecutive failures per task. After MAX_CONSECUTIVE_FAILURES the
-     * task is auto-disabled in the DB and a single "auto-disabled" notification
-     * is sent. Counter resets on the next successful fire.
-     */
-    private recordFailure;
-    private handleSystemEvent;
-}
-/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
-export declare function intervalToMs(interval: string): number | null;
-/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
-export declare function intervalToCron(interval: string): string | null;
-/**
- * Validate a schedule string for a given scheduleType. Returns an error string
- * on invalid input or null when valid. Used by MCP + dashboard before insert
- * so misconfigured tasks fail loud instead of silently never firing.
- */
-export declare function validateSchedule(scheduleType: string, schedule: string): string | null;