beecork 1.7.1 → 2.0.0

package/dist/tasks/scheduler.js

@@ -1,329 +0,0 @@
-import { CronExpressionParser } from 'cron-parser';
-import fs from 'node:fs';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { TaskStore } from './store.js';
-import { getCronReloadSignalPath, getLogsDir } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-export const execAsync = promisify(exec);
-/**
- * Disable a task after this many consecutive failures so a misconfigured
- * cron doesn't fire (and notify) every interval indefinitely. Reset on
- * success.
- */
-const MAX_CONSECUTIVE_FAILURES = 5;
-export class TaskScheduler {
-    tabManager;
-    onNotify;
-    // taskId -> due time in ms epoch
-    nextRunAt = new Map();
-    // taskIds with an in-flight fireJob
-    running = new Set();
-    // taskId -> consecutive failure count, used for auto-disable
-    failureCounts = new Map();
-    stopping = false;
-    store = new TaskStore();
-    constructor(tabManager, onNotify) {
-        this.tabManager = tabManager;
-        this.onNotify = onNotify;
-    }
-    /** Load all tasks from store and schedule them */
-    loadAndSchedule() {
-        this.nextRunAt.clear();
-        this.stopping = false;
-        const jobs = this.store.list();
-        let scheduled = 0;
-        let missedFires = 0;
-        for (const job of jobs) {
-            if (!job.enabled)
-                continue;
-            // Fast path: one-time 'at' tasks whose target time has passed without ever firing.
-            // (The general tick() loop would catch these too, but this keeps the original
-            // single-pass startup behavior — fire now and disable atomically.)
-            if (job.scheduleType === 'at' && !job.lastRunAt) {
-                const targetTime = new Date(job.schedule).getTime();
-                if (Number.isFinite(targetTime) && targetTime <= Date.now()) {
-                    logger.warn(`Task: missed fire detected for "${job.name}" (was scheduled for ${job.schedule}), firing now`);
-                    missedFires++;
-                    this.store.update(job.id, { enabled: false, nextRunAt: null });
-                    void this.fireJob(job);
-                    continue;
-                }
-            }
-            // Seed nextRunAt: prefer stored value (catch-up after sleep/restart);
-            // otherwise compute fresh from now.
-            let due = null;
-            if (job.nextRunAt) {
-                const stored = new Date(job.nextRunAt).getTime();
-                if (Number.isFinite(stored))
-                    due = stored;
-            }
-            if (due === null) {
-                due = this.computeNextRun(job, Date.now());
-                if (due === null)
-                    continue; // computeNextRun already logged
-                this.store.update(job.id, { nextRunAt: new Date(due).toISOString() });
-            }
-            this.nextRunAt.set(job.id, due);
-            scheduled++;
-        }
-        logger.info(`Tasks: loaded ${scheduled} active tasks (${jobs.length} total)${missedFires > 0 ? `, fired ${missedFires} missed` : ''}`);
-    }
-    /** Check for the reload signal file and reload if present */
-    checkForReload() {
-        const signalPath = getCronReloadSignalPath();
-        if (fs.existsSync(signalPath)) {
-            try {
-                fs.unlinkSync(signalPath);
-            }
-            catch {
-                /* race condition, ok */
-            }
-            logger.info('Tasks: reload signal detected, reloading schedules');
-            this.loadAndSchedule();
-        }
-    }
-    /**
-     * 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() {
-        if (this.stopping)
-            return;
-        const now = Date.now();
-        for (const [id, due] of [...this.nextRunAt]) {
-            if (this.stopping)
-                return;
-            if (due > now)
-                continue;
-            if (this.running.has(id))
-                continue;
-            const job = this.store.get(id);
-            if (!job || !job.enabled) {
-                this.nextRunAt.delete(id);
-                continue;
-            }
-            // Advance BEFORE firing — eliminates double-fire race if tick is re-entered
-            // before the async fireJob completes.
-            if (job.scheduleType === 'at') {
-                this.nextRunAt.delete(id);
-                this.store.update(id, { enabled: false, nextRunAt: null });
-            }
-            else {
-                const next = this.computeNextRun(job, now);
-                if (next === null) {
-                    this.nextRunAt.delete(id);
-                    continue;
-                }
-                this.nextRunAt.set(id, next);
-                this.store.update(id, { nextRunAt: new Date(next).toISOString() });
-            }
-            this.running.add(id);
-            void this.fireJob(job).finally(() => this.running.delete(id));
-        }
-    }
-    /** Stop the scheduler. In-flight fireJob promises are detached and resolve naturally. */
-    stopAll() {
-        this.stopping = true;
-        this.nextRunAt.clear();
-    }
-    /** Compute next run time in ms epoch, given a "from" anchor. Returns null if invalid. */
-    computeNextRun(job, fromMs) {
-        try {
-            switch (job.scheduleType) {
-                case 'cron':
-                    return CronExpressionParser.parse(job.schedule, { currentDate: new Date(fromMs) })
-                        .next()
-                        .getTime();
-                case 'every': {
-                    const expr = intervalToCron(job.schedule);
-                    if (expr) {
-                        return CronExpressionParser.parse(expr, { currentDate: new Date(fromMs) })
-                            .next()
-                            .getTime();
-                    }
-                    const ms = intervalToMs(job.schedule);
-                    return ms ? fromMs + ms : null;
-                }
-                case 'at': {
-                    const t = new Date(job.schedule).getTime();
-                    return Number.isFinite(t) ? t : null;
-                }
-            }
-        }
-        catch (err) {
-            logger.error(`Task: invalid expression for "${job.name}": ${job.schedule}`, err);
-            return null;
-        }
-    }
-    async fireJob(job) {
-        logger.info(`Task firing: "${job.name}" (${job.payloadType || 'agentTurn'}) -> tab:${job.tabName}`);
-        const logFile = path.join(getLogsDir(), `task-${job.name}.log`);
-        // Handle systemEvent -- internal Beecork actions, not Claude Code
-        if (job.payloadType === 'systemEvent') {
-            try {
-                await this.handleSystemEvent(job);
-                this.store.update(job.id, { lastRunAt: new Date().toISOString() });
-                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] SYSTEM: ${job.message}\n`);
-            }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                logger.error(`System event "${job.name}" failed:`, err);
-                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
-            }
-            return;
-        }
-        try {
-            this.tabManager.ensureTab(job.tabName);
-            const result = await this.tabManager.sendMessage(job.tabName, job.message);
-            this.store.update(job.id, { lastRunAt: new Date().toISOString() });
-            const firstLine = result.text.split('\n')[0]?.slice(0, 200) || '(no output)';
-            const status = result.error ? 'ERROR' : 'SUCCESS';
-            // Log result (status reflects subprocess exit / is_error, not just completion)
-            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ${status}: ${firstLine}\n`);
-            if (result.error) {
-                this.recordFailure(job);
-            }
-            else {
-                this.failureCounts.delete(job.id);
-            }
-            // Notify (separate try/catch -- notification failure shouldn't be reported as job failure)
-            try {
-                if (this.onNotify) {
-                    if (result.error) {
-                        await this.onNotify(`[${job.name}] Failed -- ${firstLine}`);
-                    }
-                    else {
-                        await this.onNotify(`[${job.name}] Done -- ${firstLine}`);
-                    }
-                }
-            }
-            catch (notifyErr) {
-                logger.warn(`Task "${job.name}" notification failed:`, notifyErr);
-            }
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            logger.error(`Task "${job.name}" failed:`, err);
-            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
-            this.recordFailure(job);
-            try {
-                await this.onNotify?.(`[${job.name}] Failed -- ${errMsg}`);
-            }
-            catch {
-                /* notification best-effort */
-            }
-        }
-    }
-    /**
-     * 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.
-     */
-    recordFailure(job) {
-        const count = (this.failureCounts.get(job.id) ?? 0) + 1;
-        this.failureCounts.set(job.id, count);
-        if (count >= MAX_CONSECUTIVE_FAILURES) {
-            logger.warn(`Task "${job.name}" hit ${count} consecutive failures — auto-disabling`);
-            this.store.update(job.id, { enabled: false });
-            this.nextRunAt.delete(job.id);
-            this.failureCounts.delete(job.id);
-            // Notify once. Subsequent enable + re-failure will trigger again.
-            this.onNotify?.(`Task "${job.name}" auto-disabled after ${count} consecutive failures. Re-enable from the dashboard or via beecork_task_update.`).catch(() => { });
-        }
-    }
-    async handleSystemEvent(job) {
-        switch (job.message) {
-            case 'health_check':
-                logger.info('System event: health check -- daemon alive');
-                if (this.onNotify) {
-                    await this.onNotify('Beecork health check: all systems operational');
-                }
-                break;
-            default:
-                logger.warn(`Unknown system event: ${job.message}`);
-        }
-    }
-}
-/** Parse a "1w2d3h45m"-style interval into its parts. Returns null on invalid input. */
-function parseInterval(interval) {
-    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
-    if (!match || match.slice(1).every((g) => g === undefined))
-        return null;
-    return {
-        weeks: parseInt(match[1] || '0', 10),
-        days: parseInt(match[2] || '0', 10),
-        hours: parseInt(match[3] || '0', 10),
-        mins: parseInt(match[4] || '0', 10),
-    };
-}
-/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
-export function intervalToMs(interval) {
-    const parts = parseInterval(interval);
-    if (!parts)
-        return null;
-    const { weeks, days, hours, mins } = parts;
-    const totalMs = (weeks * 7 * 24 * 60 + days * 24 * 60 + hours * 60 + mins) * 60 * 1000;
-    return totalMs > 0 ? totalMs : null;
-}
-/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
-export function intervalToCron(interval) {
-    const parts = parseInterval(interval);
-    if (!parts)
-        return null;
-    const { weeks, days, hours, mins } = parts;
-    // Convert to total minutes for simple intervals
-    const totalMins = weeks * 7 * 24 * 60 + days * 24 * 60 + hours * 60 + mins;
-    if (totalMins <= 0)
-        return null;
-    // Simple minute interval
-    if (totalMins <= 59)
-        return `*/${totalMins} * * * *`;
-    // Hourly intervals
-    if (mins === 0 && days === 0 && weeks === 0 && hours > 0 && hours <= 23)
-        return `0 */${hours} * * *`;
-    // Daily intervals
-    if (mins === 0 && hours === 0 && weeks === 0 && days > 0)
-        return `0 0 */${days} * *`;
-    // Weekly intervals
-    if (mins === 0 && hours === 0 && days === 0 && weeks > 0)
-        return `0 0 * * 0`;
-    // Combined or large intervals -- return null, handled by intervalToMs fallback
-    return 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 function validateSchedule(scheduleType, schedule) {
-    if (!schedule)
-        return 'schedule is required';
-    switch (scheduleType) {
-        case 'at': {
-            const ts = Date.parse(schedule);
-            if (Number.isNaN(ts))
-                return `"${schedule}" is not a valid ISO datetime`;
-            return null;
-        }
-        case 'every': {
-            if (intervalToMs(schedule) === null) {
-                return `"${schedule}" is not a valid interval. Use formats like "30m", "2h", "1d", "1h30m".`;
-            }
-            return null;
-        }
-        case 'cron': {
-            try {
-                CronExpressionParser.parse(schedule);
-                return null;
-            }
-            catch (err) {
-                return `"${schedule}" is not a valid cron expression: ${err instanceof Error ? err.message : String(err)}`;
-            }
-        }
-        default:
-            return `unknown scheduleType "${scheduleType}"`;
-    }
-}

package/dist/tasks/store.d.ts

@@ -1,11 +0,0 @@
-import type { Task } from '../types.js';
-export declare class TaskStore {
-    constructor();
-    list(): Task[];
-    get(id: string): Task | undefined;
-    add(job: Task): void;
-    update(id: string, updates: Partial<Task>): boolean;
-    delete(id: string): boolean;
-    /** One-time migration from crontab.json to SQLite */
-    private migrateFromJson;
-}

package/dist/tasks/store.js

@@ -1,103 +0,0 @@
-import fs from 'node:fs';
-import { getDb } from '../db/index.js';
-import { getCrontabPath } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-function rowToTask(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        scheduleType: row.schedule_type,
-        schedule: row.schedule,
-        tabName: row.tab_name,
-        message: row.message,
-        payloadType: row.payload_type || 'agentTurn',
-        enabled: row.enabled === 1,
-        createdAt: row.created_at,
-        lastRunAt: row.last_run_at,
-        nextRunAt: row.next_run_at,
-    };
-}
-// One-shot JSON migration only needs to run once per process lifetime, but the
-// dashboard creates a fresh TaskStore per request and MCP creates one per task
-// call. Without this flag, every instantiation re-fired existsSync + COUNT(*).
-let migrationChecked = false;
-export class TaskStore {
-    constructor() {
-        if (!migrationChecked) {
-            migrationChecked = true;
-            this.migrateFromJson();
-        }
-    }
-    list() {
-        const db = getDb();
-        return db.prepare('SELECT * FROM tasks ORDER BY created_at').all().map(rowToTask);
-    }
-    get(id) {
-        const db = getDb();
-        const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
-        return row ? rowToTask(row) : undefined;
-    }
-    add(job) {
-        const db = getDb();
-        db.prepare(`INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, created_at, last_run_at, next_run_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(job.id, job.name, job.scheduleType, job.schedule, job.tabName, job.message, job.payloadType || 'agentTurn', job.enabled ? 1 : 0, job.createdAt, job.lastRunAt, job.nextRunAt);
-    }
-    update(id, updates) {
-        const db = getDb();
-        const existing = this.get(id);
-        if (!existing)
-            return false;
-        // If the schedule changes, the stored next_run_at is no longer valid —
-        // null it out so the scheduler recomputes from the new expression on
-        // next load. Caller can override by explicitly passing nextRunAt.
-        const scheduleChanged = (updates.schedule !== undefined && updates.schedule !== existing.schedule) ||
-            (updates.scheduleType !== undefined && updates.scheduleType !== existing.scheduleType);
-        const merged = { ...existing, ...updates };
-        if (scheduleChanged && updates.nextRunAt === undefined)
-            merged.nextRunAt = null;
-        db.prepare(`UPDATE tasks SET name=?, schedule_type=?, schedule=?, tab_name=?, message=?, enabled=?, last_run_at=?, next_run_at=? WHERE id=?`).run(merged.name, merged.scheduleType, merged.schedule, merged.tabName, merged.message, merged.enabled ? 1 : 0, merged.lastRunAt, merged.nextRunAt, id);
-        return true;
-    }
-    delete(id) {
-        const db = getDb();
-        const result = db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
-        return result.changes > 0;
-    }
-    /** One-time migration from crontab.json to SQLite */
-    migrateFromJson() {
-        const jsonPath = getCrontabPath();
-        if (!fs.existsSync(jsonPath))
-            return;
-        const db = getDb();
-        const count = db.prepare('SELECT COUNT(*) as count FROM tasks').get();
-        if (count.count > 0) {
-            // Already migrated, clean up JSON
-            try {
-                fs.renameSync(jsonPath, jsonPath + '.bak');
-            }
-            catch {
-                /* ok */
-            }
-            return;
-        }
-        try {
-            const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
-            const jobs = data.jobs || [];
-            if (jobs.length === 0)
-                return;
-            const insert = db.prepare(`INSERT OR IGNORE INTO tasks (id, name, schedule_type, schedule, tab_name, message, enabled, created_at, last_run_at, next_run_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-            const tx = db.transaction(() => {
-                for (const j of jobs) {
-                    insert.run(j.id, j.name, j.scheduleType, j.schedule, j.tabName || 'default', j.message, j.enabled ? 1 : 0, j.createdAt, j.lastRunAt, j.nextRunAt);
-                }
-            });
-            tx();
-            fs.renameSync(jsonPath, jsonPath + '.bak');
-            logger.info(`Migrated ${jobs.length} tasks from JSON to SQLite`);
-        }
-        catch (err) {
-            logger.error('Failed to migrate tasks from JSON:', err);
-        }
-    }
-}

package/dist/timeline/index.d.ts

@@ -1,3 +0,0 @@
-export type { ActivityEvent, EventType } from './types.js';
-export { logActivity } from './logger.js';
-export { getTimeline, formatTimeline, getReplayInfo } from './query.js';

package/dist/timeline/index.js

@@ -1,2 +0,0 @@
-export { logActivity } from './logger.js';
-export { getTimeline, formatTimeline, getReplayInfo } from './query.js';

package/dist/timeline/logger.d.ts

@@ -1,8 +0,0 @@
-import type { EventType } from './types.js';
-export declare function logActivity(eventType: EventType, summary: string, options?: {
-    projectName?: string;
-    tabName?: string;
-    details?: string;
-    durationMs?: number;
-    costUsd?: number;
-}): void;

package/dist/timeline/logger.js

@@ -1,11 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.js';
-export function logActivity(eventType, summary, options) {
-    try {
-        const db = getDb();
-        db.prepare('INSERT INTO activity_log (id, event_type, project_name, tab_name, summary, details, duration_ms, cost_usd) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(uuidv4(), eventType, options?.projectName || null, options?.tabName || null, summary, options?.details || null, options?.durationMs || null, options?.costUsd || null);
-    }
-    catch {
-        /* non-critical — don't crash if logging fails */
-    }
-}

package/dist/timeline/query.d.ts

@@ -1,11 +0,0 @@
-import type { ActivityEvent } from './types.js';
-export declare function getTimeline(options?: {
-    date?: string;
-    tabName?: string;
-    limit?: number;
-}): ActivityEvent[];
-export declare function formatTimeline(events: ActivityEvent[]): string;
-export declare function getReplayInfo(eventId: string): {
-    tabName: string;
-    message: string;
-} | null;

package/dist/timeline/query.js

@@ -1,67 +0,0 @@
-import { getDb } from '../db/index.js';
-function rowToEvent(r) {
-    return {
-        id: r.id,
-        eventType: r.event_type,
-        projectName: r.project_name,
-        tabName: r.tab_name,
-        summary: r.summary,
-        details: r.details,
-        durationMs: r.duration_ms,
-        costUsd: r.cost_usd,
-        createdAt: r.created_at,
-    };
-}
-export function getTimeline(options) {
-    const db = getDb();
-    let query = 'SELECT * FROM activity_log';
-    const conditions = [];
-    const params = [];
-    if (options?.date) {
-        // Sargable range so idx_activity_log_created can serve the query.
-        // `date(created_at) = ?` is non-sargable and forces a full scan.
-        const dayStart = `${options.date} 00:00:00`;
-        const dayEnd = `${options.date} 23:59:59.999`;
-        conditions.push('created_at >= ? AND created_at <= ?');
-        params.push(dayStart, dayEnd);
-    }
-    if (options?.tabName) {
-        conditions.push('tab_name = ?');
-        params.push(options.tabName);
-    }
-    if (conditions.length > 0)
-        query += ' WHERE ' + conditions.join(' AND ');
-    query += ' ORDER BY created_at DESC';
-    query += ' LIMIT ?';
-    params.push(options?.limit || 50);
-    return db.prepare(query).all(...params).map(rowToEvent);
-}
-export function formatTimeline(events) {
-    if (events.length === 0)
-        return 'No activity recorded.';
-    const byDate = new Map();
-    for (const event of events.reverse()) {
-        const date = event.createdAt.slice(0, 10);
-        if (!byDate.has(date))
-            byDate.set(date, []);
-        byDate.get(date).push(event);
-    }
-    const lines = [];
-    for (const [date, dayEvents] of byDate) {
-        lines.push(`\n📅 ${date}`);
-        for (const e of dayEvents) {
-            const time = e.createdAt.slice(11, 16);
-            const tab = e.tabName ? `[${e.tabName}]` : '';
-            const cost = e.costUsd ? ` $${e.costUsd.toFixed(4)}` : '';
-            lines.push(`  ${time}  ${tab} ${e.summary}${cost}`);
-        }
-    }
-    return lines.join('\n');
-}
-export function getReplayInfo(eventId) {
-    const db = getDb();
-    const event = db.prepare('SELECT * FROM activity_log WHERE id = ?').get(eventId);
-    if (!event || !event.tab_name || !event.details)
-        return null;
-    return { tabName: event.tab_name, message: event.details };
-}

package/dist/timeline/types.d.ts

@@ -1,12 +0,0 @@
-export type EventType = 'task_started' | 'task_completed' | 'task_failed' | 'watcher_triggered' | 'media_generated' | 'delegation_completed' | 'user_command' | 'system_event';
-export interface ActivityEvent {
-    id: string;
-    eventType: EventType;
-    projectName: string | null;
-    tabName: string | null;
-    summary: string;
-    details: string | null;
-    durationMs: number | null;
-    costUsd: number | null;
-    createdAt: string;
-}

package/dist/timeline/types.js

@@ -1 +0,0 @@
-export {};