beecork 1.4.6 → 1.4.8

package/dist/daemon.js

@@ -149,6 +149,8 @@ async function main() {
         try {
             taskScheduler.checkForReload();
             watcherScheduler.checkForReload();
+            taskScheduler.tick();
+            watcherScheduler.tick();
             tabManager.processPendingMessages();
             // Media cleanup every 60 seconds
             if (Date.now() - lastMediaCleanup > 60000) {

package/dist/tasks/scheduler.d.ts

@@ -4,16 +4,25 @@ export declare const execAsync: typeof exec.__promisify__;
 export declare class TaskScheduler {
     private tabManager;
     private onNotify;
-    private scheduledJobs;
+    private nextRunAt;
+    private running;
+    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;
-    /** Stop all scheduled tasks */
+    /**
+     * 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;
-    private scheduleJob;
+    /** Compute next run time in ms epoch, given a "from" anchor. Returns null if invalid. */
+    private computeNextRun;
     private fireJob;
     private handleSystemEvent;
 }

package/dist/tasks/scheduler.js

@@ -1,4 +1,4 @@
-import cron from 'node-cron';
+import { CronExpressionParser } from 'cron-parser';
 import fs from 'node:fs';
 import path from 'node:path';
 import { exec } from 'node:child_process';
@@ -10,7 +10,11 @@ export const execAsync = promisify(exec);
 export class TaskScheduler {
     tabManager;
     onNotify;
-    scheduledJobs = new Map();
+    // taskId -> due time in ms epoch
+    nextRunAt = new Map();
+    // taskIds with an in-flight fireJob
+    running = new Set();
+    stopping = false;
     store = new TaskStore();
     constructor(tabManager, onNotify) {
         this.tabManager = tabManager;
@@ -18,29 +22,42 @@ export class TaskScheduler {
     }
     /** Load all tasks from store and schedule them */
     loadAndSchedule() {
-        // Cancel existing
-        for (const [, task] of this.scheduledJobs) {
-            task.stop();
-        }
-        this.scheduledJobs.clear();
+        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;
-            // Detect missed fires: one-time "at" jobs whose time has passed but never ran
+            // 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 (targetTime <= Date.now()) {
+                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.fireJob(job);
-                    this.store.update(job.id, { enabled: false }); // Disable after one-time execution
+                    this.store.update(job.id, { enabled: false, nextRunAt: null });
+                    void this.fireJob(job);
                     continue;
                 }
             }
-            this.scheduleJob(job);
+            // 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` : ''}`);
@@ -57,62 +74,75 @@ export class TaskScheduler {
             this.loadAndSchedule();
         }
     }
-    /** Stop all scheduled tasks */
-    stopAll() {
-        for (const [, task] of this.scheduledJobs) {
-            task.stop();
-        }
-        this.scheduledJobs.clear();
-    }
-    scheduleJob(job) {
-        switch (job.scheduleType) {
-            case 'cron': {
-                if (!cron.validate(job.schedule)) {
-                    logger.error(`Task: invalid expression for "${job.name}": ${job.schedule}`);
-                    return;
-                }
-                const task = cron.schedule(job.schedule, () => this.fireJob(job));
-                this.scheduledJobs.set(job.id, task);
-                break;
+    /**
+     * 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;
             }
-            case 'every': {
-                const cronExpr = intervalToCron(job.schedule);
-                if (cronExpr) {
-                    if (!cron.validate(cronExpr)) {
-                        logger.error(`Task: invalid cron expression for "${job.name}": ${cronExpr}`);
-                        return;
-                    }
-                    const task = cron.schedule(cronExpr, () => this.fireJob(job));
-                    this.scheduledJobs.set(job.id, task);
+            // 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;
                 }
-                else {
-                    // Use setInterval for non-cron-expressible intervals
-                    const totalMs = intervalToMs(job.schedule);
-                    if (totalMs) {
-                        const timer = setInterval(() => this.fireJob(job), totalMs);
-                        this.scheduledJobs.set(job.id, { stop: () => clearInterval(timer) });
-                    }
-                    else {
-                        logger.error(`Task: invalid interval for "${job.name}": ${job.schedule}`);
+                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;
                 }
-                break;
-            }
-            case 'at': {
-                const targetTime = new Date(job.schedule).getTime();
-                const delay = targetTime - Date.now();
-                if (delay <= 0) {
-                    logger.warn(`Task: one-time task "${job.name}" is in the past, skipping`);
-                    return;
+                case 'at': {
+                    const t = new Date(job.schedule).getTime();
+                    return Number.isFinite(t) ? t : null;
                 }
-                const timer = setTimeout(() => {
-                    this.fireJob(job);
-                    this.store.update(job.id, { enabled: false });
-                }, delay);
-                this.scheduledJobs.set(job.id, { stop: () => clearTimeout(timer) });
-                break;
             }
         }
+        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}`);
@@ -214,6 +244,6 @@ export function intervalToCron(interval) {
     // Weekly intervals
     if (mins === 0 && hours === 0 && days === 0 && weeks > 0)
         return `0 0 * * 0`;
-    // Combined or large intervals -- return null, handled by setInterval in scheduleJob
+    // Combined or large intervals -- return null, handled by intervalToMs fallback
     return null;
 }

package/dist/tasks/store.js

@@ -35,7 +35,14 @@ export class TaskStore {
         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;
     }

package/dist/watchers/scheduler.d.ts

@@ -1,12 +1,19 @@
 export declare class WatcherScheduler {
     private store;
-    private intervals;
+    private nextCheckAt;
+    private running;
+    private stopping;
     onNotify: ((text: string) => Promise<void>) | null;
     /** Load all watchers from store and schedule them */
     loadAndSchedule(): void;
     /** Check for the reload signal file and reload if present */
     checkForReload(): void;
-    /** Stop all scheduled watchers */
+    /**
+     * Fire any watchers whose nextCheckAt has elapsed. Called every ~5s by the daemon
+     * poll loop. Sleep-resilient: after wake, the next tick catches all overdue checks.
+     */
+    tick(): void;
+    /** Stop the scheduler. In-flight runCheck promises detach and resolve naturally. */
     stopAll(): void;
     private runCheck;
     private executeAction;

package/dist/watchers/scheduler.js

@@ -8,11 +8,16 @@ import { logger } from '../util/logger.js';
 const WATCHER_RELOAD_SIGNAL_NAME = '.watcher-reload';
 export class WatcherScheduler {
     store = new WatcherStore();
-    intervals = new Map();
+    // watcherId -> due time in ms epoch for next check
+    nextCheckAt = new Map();
+    // watcherIds with an in-flight runCheck
+    running = new Set();
+    stopping = false;
     onNotify = null;
     /** Load all watchers from store and schedule them */
     loadAndSchedule() {
         this.stopAll();
+        this.stopping = false;
         const watchers = this.store.list();
         let scheduled = 0;
         for (const watcher of watchers) {
@@ -23,8 +28,18 @@ export class WatcherScheduler {
                 logger.error(`Watcher: invalid schedule for "${watcher.name}": ${watcher.schedule}`);
                 continue;
             }
-            const timer = setInterval(() => this.runCheck(watcher), ms);
-            this.intervals.set(watcher.id, timer);
+            // Seed nextCheckAt: if we have a lastCheckAt, fire `intervalMs` after it
+            // (catches up overdue checks after sleep/restart on the next tick).
+            // Otherwise wait `intervalMs` before first fire — matches today's setInterval semantics.
+            let due;
+            if (watcher.lastCheckAt) {
+                const last = new Date(watcher.lastCheckAt).getTime();
+                due = Number.isFinite(last) ? last + ms : Date.now() + ms;
+            }
+            else {
+                due = Date.now() + ms;
+            }
+            this.nextCheckAt.set(watcher.id, due);
             scheduled++;
         }
         if (scheduled > 0 || watchers.length > 0) {
@@ -43,12 +58,41 @@ export class WatcherScheduler {
             this.loadAndSchedule();
         }
     }
-    /** Stop all scheduled watchers */
-    stopAll() {
-        for (const [, timer] of this.intervals) {
-            clearInterval(timer);
+    /**
+     * Fire any watchers whose nextCheckAt has elapsed. Called every ~5s by the daemon
+     * poll loop. Sleep-resilient: after wake, the next tick catches all overdue checks.
+     */
+    tick() {
+        if (this.stopping)
+            return;
+        const now = Date.now();
+        for (const [id, due] of [...this.nextCheckAt]) {
+            if (this.stopping)
+                return;
+            if (due > now)
+                continue;
+            if (this.running.has(id))
+                continue;
+            const watcher = this.store.get(id);
+            if (!watcher || !watcher.enabled) {
+                this.nextCheckAt.delete(id);
+                continue;
+            }
+            const intervalMs = parseScheduleToMs(watcher.schedule);
+            if (!intervalMs) {
+                this.nextCheckAt.delete(id);
+                continue;
+            }
+            // Advance BEFORE running — eliminates double-fire race
+            this.nextCheckAt.set(id, now + intervalMs);
+            this.running.add(id);
+            void this.runCheck(watcher).finally(() => this.running.delete(id));
         }
-        this.intervals.clear();
+    }
+    /** Stop the scheduler. In-flight runCheck promises detach and resolve naturally. */
+    stopAll() {
+        this.stopping = true;
+        this.nextCheckAt.clear();
     }
     async runCheck(watcher) {
         const logFile = path.join(getLogsDir(), `watcher-${watcher.name}.log`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
@@ -23,8 +23,8 @@
     "@whiskeysockets/baileys": "^6.7.0",
     "better-sqlite3": "^12.8.0",
     "commander": "^14.0.3",
+    "cron-parser": "^5.5.0",
     "discord.js": "^14.26.2",
-    "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.67.0",
     "qrcode-terminal": "^0.12.0",
     "uuid": "^13.0.0"
@@ -33,7 +33,6 @@
     "@tailwindcss/cli": "^4.2.2",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.0.0",
-    "@types/node-cron": "^3.0.11",
     "@types/node-telegram-bot-api": "^0.64.14",
     "eslint": "^10.2.0",
     "tailwindcss": "^4.2.2",