beecork 1.7.1 → 2.0.0

package/dist/session/message-queue.js

@@ -1,52 +0,0 @@
-/**
- * Per-tab FIFO queue for messages waiting on a busy subprocess.
- *
- * Extracted from TabManager so the queue's "max size, enqueue, dequeue,
- * peek-and-mutate-next, clear-on-stop" semantics are self-contained and
- * unit-testable without spinning up a real subprocess.
- */
-export const MAX_QUEUE_SIZE = 10;
-export class MessageQueue {
-    queues = new Map();
-    /** Attempt to enqueue. Returns false if the per-tab queue is full. */
-    enqueue(tabName, msg) {
-        let queue = this.queues.get(tabName);
-        if (!queue) {
-            queue = [];
-            this.queues.set(tabName, queue);
-        }
-        if (queue.length >= MAX_QUEUE_SIZE)
-            return false;
-        queue.push(msg);
-        return true;
-    }
-    /** Remove and return the next message. Drops the per-tab entry when empty. */
-    dequeue(tabName) {
-        const queue = this.queues.get(tabName);
-        if (!queue || queue.length === 0)
-            return undefined;
-        const next = queue.shift();
-        if (queue.length === 0)
-            this.queues.delete(tabName);
-        return next;
-    }
-    /** Peek at the next queued message without removing it (used to inject loop warning prefix). */
-    peek(tabName) {
-        return this.queues.get(tabName)?.[0];
-    }
-    size(tabName) {
-        return this.queues.get(tabName)?.length ?? 0;
-    }
-    /** Drain the queue for a tab, returning the dropped messages so callers can reject them. */
-    clear(tabName) {
-        const queue = this.queues.get(tabName) ?? [];
-        this.queues.delete(tabName);
-        return queue;
-    }
-    /** Drain every queue. Returns the dropped messages grouped by tab. */
-    clearAll() {
-        const all = Array.from(this.queues.values());
-        this.queues.clear();
-        return all;
-    }
-}

package/dist/session/pending-dispatcher.d.ts

@@ -1,31 +0,0 @@
-/**
- * Polls `pending_messages` and dispatches each row by type.
- *
- * Replaces the inline `processPendingMessages` block that previously lived in
- * TabManager. Two functional changes from that code:
- *
- *  1. Claim-before-dispatch (status='processing' set atomically before send).
- *     The original poll-every-5s code re-picked the same row on every tick
- *     while its dispatch was in flight — long Claude runs could re-fire the
- *     same prompt many times.
- *
- *  2. Branch on type. The original consumer only recognized 'notification' and
- *     fell through to "send as plain user prompt" for everything else, which
- *     meant `type='media'` rows were handed to Claude as raw JSON and never
- *     actually delivered to channels.
- */
-import type { TabManager } from './manager.js';
-import type { ChannelRegistry } from '../channels/registry.js';
-export type NotifyFn = ((text: string) => Promise<void>) | null;
-export declare class PendingMessageDispatcher {
-    private tabManager;
-    private channels;
-    private onNotify;
-    private pollCount;
-    constructor(tabManager: TabManager, channels: ChannelRegistry, onNotify: NotifyFn);
-    /** Reset any rows stuck in 'processing' from a previous daemon run. */
-    recoverOnStart(): void;
-    /** Called on every daemon poll tick. */
-    tick(): void;
-    private dispatch;
-}

package/dist/session/pending-dispatcher.js

@@ -1,120 +0,0 @@
-/**
- * Polls `pending_messages` and dispatches each row by type.
- *
- * Replaces the inline `processPendingMessages` block that previously lived in
- * TabManager. Two functional changes from that code:
- *
- *  1. Claim-before-dispatch (status='processing' set atomically before send).
- *     The original poll-every-5s code re-picked the same row on every tick
- *     while its dispatch was in flight — long Claude runs could re-fire the
- *     same prompt many times.
- *
- *  2. Branch on type. The original consumer only recognized 'notification' and
- *     fell through to "send as plain user prompt" for everything else, which
- *     meant `type='media'` rows were handed to Claude as raw JSON and never
- *     actually delivered to channels.
- */
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-import { PendingMessageStore } from './pending-store.js';
-const POLL_LIMIT = 50;
-const CLEANUP_EVERY_N_TICKS = 100;
-export class PendingMessageDispatcher {
-    tabManager;
-    channels;
-    onNotify;
-    pollCount = 0;
-    constructor(tabManager, channels, onNotify) {
-        this.tabManager = tabManager;
-        this.channels = channels;
-        this.onNotify = onNotify;
-    }
-    /** Reset any rows stuck in 'processing' from a previous daemon run. */
-    recoverOnStart() {
-        PendingMessageStore.recoverProcessing();
-    }
-    /** Called on every daemon poll tick. */
-    tick() {
-        const db = getDb();
-        this.pollCount++;
-        if (this.pollCount % CLEANUP_EVERY_N_TICKS === 0) {
-            db.prepare("DELETE FROM pending_messages WHERE (status = 'done' OR status = 'failed') AND created_at < datetime('now', '-1 day')").run();
-        }
-        const claimed = PendingMessageStore.claimBatch(POLL_LIMIT, db);
-        for (const row of claimed) {
-            // Fire-and-forget per row — the row is already marked 'processing' so
-            // the next tick won't double-dispatch. The .finally() handles the
-            // terminal transition.
-            void this.dispatch(row);
-        }
-    }
-    async dispatch(row) {
-        try {
-            switch (row.type) {
-                case 'notification':
-                    await this.onNotify?.(row.message);
-                    break;
-                case 'media': {
-                    const payload = PendingMessageStore.parseMediaPayload(row.message);
-                    if (!payload) {
-                        logger.warn(`Pending media row ${row.id} has malformed payload, skipping`);
-                        break;
-                    }
-                    const attachment = inferAttachmentType(payload.filePath, payload.caption);
-                    await this.channels.broadcastMedia(attachment);
-                    break;
-                }
-                case 'user':
-                case 'delegation':
-                case 'delegation_result':
-                case 'replay': {
-                    if (!row.tabName) {
-                        logger.warn(`Pending row ${row.id} (type=${row.type}) has no tab_name, skipping`);
-                        break;
-                    }
-                    await this.tabManager.sendMessage(row.tabName, row.message);
-                    break;
-                }
-                default: {
-                    // Unknown discriminant — log and bail rather than fall through to
-                    // "send as a plain prompt" (which is how H5 ended up shipping).
-                    logger.warn(`Pending row ${row.id} has unknown type "${row.type}", marking failed`);
-                    PendingMessageStore.markFailed(row.id);
-                    return;
-                }
-            }
-            PendingMessageStore.markDone(row.id);
-        }
-        catch (err) {
-            logger.error(`Failed to process pending message ${row.id} (type=${row.type}):`, err);
-            await this.onNotify?.(`Pending message ${row.type === 'notification' ? '' : `for tab "${row.tabName}"`} failed: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
-            PendingMessageStore.markFailed(row.id);
-        }
-    }
-}
-/**
- * Heuristic: derive a MediaAttachment from a file path so the channel's
- * broadcastMedia knows whether to send as voice / image / video / document.
- */
-function inferAttachmentType(filePath, caption) {
-    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
-    let type = 'document';
-    let mimeType = 'application/octet-stream';
-    if (['png', 'jpg', 'jpeg', 'gif', 'webp'].includes(ext)) {
-        type = 'image';
-        mimeType = `image/${ext === 'jpg' ? 'jpeg' : ext}`;
-    }
-    else if (['mp4', 'mov', 'webm', 'mkv'].includes(ext)) {
-        type = 'video';
-        mimeType = `video/${ext === 'mov' ? 'quicktime' : ext}`;
-    }
-    else if (['ogg', 'opus', 'oga'].includes(ext)) {
-        type = 'voice';
-        mimeType = 'audio/ogg';
-    }
-    else if (['mp3', 'm4a', 'wav', 'flac', 'aac'].includes(ext)) {
-        type = 'audio';
-        mimeType = `audio/${ext}`;
-    }
-    return { type, mimeType, filePath, caption };
-}

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

@@ -1,60 +0,0 @@
-/**
- * Inter-process IPC store for the `pending_messages` table.
- *
- * Beecork uses this table as a shared queue between writers (MCP handlers,
- * dashboard routes, watchers, delegations) and the daemon's poll loop. Before
- * this module the writes were inline `INSERT INTO pending_messages` calls
- * scattered across nine sites; the consumer in TabManager only branched on
- * type='notification' which meant every other type fell through to "send as
- * a plain user prompt" — including `type='media'` rows whose JSON envelope
- * was being handed to Claude as text instead of being rendered.
- *
- * This store owns:
- *   - the typed envelope (`PendingMessageType` union, no more magic strings)
- *   - 3-state status (`pending` → `processing` → `done|failed`) so the 5s
- *     poll loop doesn't re-dispatch long-running rows
- *   - the `_notify` sentinel removal (notifications now use type alone,
- *     tab_name is nullable)
- *   - claim/recover semantics so a daemon crash mid-dispatch resets in-flight
- *     rows back to pending after a 30-minute timeout
- */
-import type Database from 'better-sqlite3';
-export type PendingMessageType = 'user' | 'notification' | 'media' | 'delegation' | 'delegation_result' | 'replay';
-export interface PendingRow {
-    id: number;
-    tabName: string | null;
-    message: string;
-    type: PendingMessageType;
-    status: 'pending' | 'processing' | 'done' | 'failed';
-    createdAt: string;
-}
-interface MediaPayload {
-    type: 'media';
-    filePath: string;
-    caption?: string;
-}
-export declare const PendingMessageStore: {
-    enqueueUser(tabName: string, message: string, db?: Database.Database): void;
-    enqueueNotification(message: string, db?: Database.Database): void;
-    enqueueMedia(tabName: string, payload: MediaPayload, db?: Database.Database): void;
-    enqueueDelegation(tabName: string, message: string, db?: Database.Database): void;
-    enqueueDelegationResult(tabName: string, message: string, db?: Database.Database): void;
-    enqueueReplay(tabName: string, message: string, db?: Database.Database): void;
-    /**
-     * Claim up to `limit` pending rows atomically. The rows are flipped to
-     * status='processing' inside a transaction so a second poll tick can't pick
-     * them up. Returns the claimed rows.
-     */
-    claimBatch(limit: number, db?: Database.Database): PendingRow[];
-    markDone(id: number, db?: Database.Database): void;
-    markFailed(id: number, db?: Database.Database): void;
-    /**
-     * Reset stuck `processing` rows back to `pending`. Run at daemon startup so
-     * a crash mid-dispatch doesn't leave rows permanently in-flight. The 30min
-     * window is well beyond the 30min subprocess runtime cap.
-     */
-    recoverProcessing(db?: Database.Database): number;
-    /** Parse a media row's message JSON. Returns null on malformed JSON. */
-    parseMediaPayload(message: string): MediaPayload | null;
-};
-export {};

package/dist/session/pending-store.js

@@ -1,118 +0,0 @@
-/**
- * Inter-process IPC store for the `pending_messages` table.
- *
- * Beecork uses this table as a shared queue between writers (MCP handlers,
- * dashboard routes, watchers, delegations) and the daemon's poll loop. Before
- * this module the writes were inline `INSERT INTO pending_messages` calls
- * scattered across nine sites; the consumer in TabManager only branched on
- * type='notification' which meant every other type fell through to "send as
- * a plain user prompt" — including `type='media'` rows whose JSON envelope
- * was being handed to Claude as text instead of being rendered.
- *
- * This store owns:
- *   - the typed envelope (`PendingMessageType` union, no more magic strings)
- *   - 3-state status (`pending` → `processing` → `done|failed`) so the 5s
- *     poll loop doesn't re-dispatch long-running rows
- *   - the `_notify` sentinel removal (notifications now use type alone,
- *     tab_name is nullable)
- *   - claim/recover semantics so a daemon crash mid-dispatch resets in-flight
- *     rows back to pending after a 30-minute timeout
- */
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-function rowToPending(r) {
-    return {
-        id: r.id,
-        tabName: r.tab_name,
-        message: r.message,
-        type: r.type || 'user',
-        status: r.status || 'pending',
-        createdAt: r.created_at,
-    };
-}
-const STALE_PROCESSING_MS = 30 * 60 * 1000; // 30 minutes
-// Private INSERT helper — all five enqueue* methods were the same INSERT with
-// different literals. Notification rows use '' for tab_name since the consumer
-// branches on type rather than reading the tab.
-function insertPending(db, tabName, message, type) {
-    db.prepare('INSERT INTO pending_messages (tab_name, message, type, status) VALUES (?, ?, ?, ?)').run(tabName, message, type, 'pending');
-}
-export const PendingMessageStore = {
-    enqueueUser(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'user');
-    },
-    enqueueNotification(message, db = getDb()) {
-        insertPending(db, '', message, 'notification');
-    },
-    enqueueMedia(tabName, payload, db = getDb()) {
-        insertPending(db, tabName, JSON.stringify(payload), 'media');
-    },
-    enqueueDelegation(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'delegation');
-    },
-    enqueueDelegationResult(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'delegation_result');
-    },
-    enqueueReplay(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'replay');
-    },
-    /**
-     * Claim up to `limit` pending rows atomically. The rows are flipped to
-     * status='processing' inside a transaction so a second poll tick can't pick
-     * them up. Returns the claimed rows.
-     */
-    claimBatch(limit, db = getDb()) {
-        const claim = db.transaction((max) => {
-            const rows = db
-                .prepare("SELECT id, tab_name, message, type, status, created_at FROM pending_messages WHERE status = 'pending' ORDER BY created_at ASC LIMIT ?")
-                .all(max);
-            if (rows.length === 0)
-                return [];
-            const stmt = db.prepare("UPDATE pending_messages SET status = 'processing' WHERE id = ? AND status = 'pending'");
-            const claimed = [];
-            for (const r of rows) {
-                const result = stmt.run(r.id);
-                if (result.changes > 0)
-                    claimed.push(rowToPending(r));
-            }
-            return claimed;
-        });
-        return claim(limit);
-    },
-    markDone(id, db = getDb()) {
-        db.prepare("UPDATE pending_messages SET status = 'done', processed = 1 WHERE id = ?").run(id);
-    },
-    markFailed(id, db = getDb()) {
-        // 'failed' rows are kept for diagnostics until the periodic cleanup sweeps
-        // them. They are NOT re-dispatched — preserves the original "no infinite
-        // retries" policy while keeping the row visible for postmortem queries.
-        db.prepare("UPDATE pending_messages SET status = 'failed', processed = 1 WHERE id = ?").run(id);
-    },
-    /**
-     * Reset stuck `processing` rows back to `pending`. Run at daemon startup so
-     * a crash mid-dispatch doesn't leave rows permanently in-flight. The 30min
-     * window is well beyond the 30min subprocess runtime cap.
-     */
-    recoverProcessing(db = getDb()) {
-        const result = db
-            .prepare(`UPDATE pending_messages SET status = 'pending'
-       WHERE status = 'processing' AND created_at < datetime('now', '-' || ? || ' seconds')`)
-            .run(Math.floor(STALE_PROCESSING_MS / 1000));
-        if (result.changes > 0) {
-            logger.warn(`Recovered ${result.changes} stuck pending_messages rows from 'processing' state`);
-        }
-        return result.changes;
-    },
-    /** Parse a media row's message JSON. Returns null on malformed JSON. */
-    parseMediaPayload(message) {
-        try {
-            const parsed = JSON.parse(message);
-            if (parsed?.type === 'media' && typeof parsed.filePath === 'string')
-                return parsed;
-            return null;
-        }
-        catch {
-            return null;
-        }
-    },
-};

package/dist/session/stale-session.d.ts

@@ -1,31 +0,0 @@
-/**
- * Detection + recovery for "Claude Code session not found / expired" errors.
- *
- * Extracted from TabManager.executeMessage so the two responsibilities
- * (recognize the symptom, build the recovery prompt) live in one focused
- * module instead of tangled inline with the subprocess callbacks.
- */
-import type Database from 'better-sqlite3';
-import type { StreamResult } from '../types.js';
-import type { SendResult } from './manager.js';
-export interface StaleSessionRecovery {
-    newSessionId: string;
-    /** A prompt that wraps the original enrichedPrompt with the last few messages
-     * for context, since Claude Code lost the session and won't have any. */
-    contextPrompt: string;
-}
-export declare const StaleSessionDetector: {
-    /**
-     * Was this result an "I can't resume that session" failure?
-     *
-     * Covers both the legacy text-based error and the modern
-     * `error_during_execution` event shape.
-     */
-    isStale(result: SendResult, resultEvent: StreamResult | null, shouldResume: boolean, retryDepth: number): boolean;
-    /**
-     * Build a recovery prompt seeded with the tab's last 5 messages as context,
-     * and allocate a fresh session ID. Caller is responsible for updating the
-     * tab's session_id in the DB before retrying.
-     */
-    buildRecovery(tabId: string, enrichedPrompt: string, db: Database.Database): StaleSessionRecovery;
-};

package/dist/session/stale-session.js

@@ -1,45 +0,0 @@
-/**
- * Detection + recovery for "Claude Code session not found / expired" errors.
- *
- * Extracted from TabManager.executeMessage so the two responsibilities
- * (recognize the symptom, build the recovery prompt) live in one focused
- * module instead of tangled inline with the subprocess callbacks.
- */
-import { v4 as uuidv4 } from 'uuid';
-export const StaleSessionDetector = {
-    /**
-     * Was this result an "I can't resume that session" failure?
-     *
-     * Covers both the legacy text-based error and the modern
-     * `error_during_execution` event shape.
-     */
-    isStale(result, resultEvent, shouldResume, retryDepth) {
-        if (!result.error || !shouldResume || retryDepth !== 0)
-            return false;
-        if (/session (not found|expired|invalid)/i.test(result.text))
-            return true;
-        if (resultEvent?.subtype === 'error_during_execution' &&
-            resultEvent.errors?.some((e) => /no conversation found|session.*not found|session.*expired|session.*invalid/i.test(e))) {
-            return true;
-        }
-        return false;
-    },
-    /**
-     * Build a recovery prompt seeded with the tab's last 5 messages as context,
-     * and allocate a fresh session ID. Caller is responsible for updating the
-     * tab's session_id in the DB before retrying.
-     */
-    buildRecovery(tabId, enrichedPrompt, db) {
-        const recentMsgs = db
-            .prepare("SELECT role, content FROM messages WHERE tab_id = ? AND content != '' ORDER BY created_at DESC LIMIT 5")
-            .all(tabId);
-        const context = recentMsgs
-            .reverse()
-            .map((m) => `${m.role}: ${m.content.slice(0, 200)}`)
-            .join('\n');
-        const contextPrompt = context
-            ? `[Previous conversation context:\n${context}\n]\n\n${enrichedPrompt}`
-            : enrichedPrompt;
-        return { newSessionId: uuidv4(), contextPrompt };
-    },
-};

package/dist/session/subprocess.d.ts

@@ -1,32 +0,0 @@
-import type { BeecorkConfig, StreamEvent } from '../types.js';
-/** Test-only — reset the existsSync cache between test runs that toggle the mock. */
-export declare function _resetMcpConfigExistsCacheForTests(): void;
-export interface SubprocessCallbacks {
-    onEvent: (event: StreamEvent) => void;
-    onExit: (code: number | null) => void;
-    onError: (err: Error) => void;
-}
-export declare class ClaudeSubprocess {
-    private tabName;
-    private workingDir;
-    private config;
-    private tabSystemPrompt?;
-    private proc;
-    private buffer;
-    private killTimer;
-    private runtimeTimer;
-    private startupTimer;
-    /**
-     * 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: 'silent' | null;
-    readonly sessionId: string;
-    constructor(tabName: string, workingDir: string, config: BeecorkConfig, sessionId?: string, tabSystemPrompt?: string | null | undefined);
-    send(prompt: string, callbacks: SubprocessCallbacks, resume?: boolean): Promise<void>;
-    kill(): void;
-    get isRunning(): boolean;
-    get pid(): number | null;
-    private buildArgs;
-}