@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopScheduler.js

@@ -0,0 +1,329 @@
+import { EventEmitter } from 'node:events';
+import cronParser from 'cron-parser';
+import { LoopNotFoundError, LoopAlreadyExistsError, SchedulerError, InvalidLoopStateError, } from './errors.js';
+const MAX_TIMER_DELAY = 2147483647;
+const DEFAULT_DRIFT_THRESHOLD = 1000;
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class LoopScheduler extends EventEmitter {
+    scheduledLoops = new Map();
+    timezone;
+    maxTimerDelay;
+    driftThreshold;
+    logger;
+    started = false;
+    startedAt = null;
+    executionCount = 0;
+    expiredCount = 0;
+    lastExecutionAt = null;
+    constructor(options = {}) {
+        super();
+        this.timezone = options.timezone;
+        this.maxTimerDelay = options.maxTimerDelay ?? MAX_TIMER_DELAY;
+        this.driftThreshold = options.driftThreshold ?? DEFAULT_DRIFT_THRESHOLD;
+        this.logger = options.logger ?? noopLogger;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.startedAt = new Date();
+        for (const scheduled of this.scheduledLoops.values()) {
+            if (!scheduled.paused && scheduled.loop.status === 'running') {
+                this.scheduleNextRun(scheduled);
+            }
+        }
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        for (const scheduled of this.scheduledLoops.values()) {
+            if (scheduled.timer !== null) {
+                clearTimeout(scheduled.timer);
+                scheduled.timer = null;
+            }
+        }
+        this.started = false;
+    }
+    isRunning() {
+        return this.started;
+    }
+    schedule(loop) {
+        if (this.scheduledLoops.has(loop.id)) {
+            throw new LoopAlreadyExistsError(loop.id);
+        }
+        if (loop.expiresAt && loop.expiresAt <= new Date()) {
+            this.expiredCount++;
+            this.emit('expired', loop.id);
+            return;
+        }
+        const nextRunAt = this.calculateNextRunTime(loop.interval);
+        const scheduled = {
+            loopId: loop.id,
+            loop,
+            timer: null,
+            nextRunAt,
+            paused: loop.status === 'paused',
+        };
+        this.scheduledLoops.set(loop.id, scheduled);
+        if (loop.status === 'running' && this.started) {
+            this.scheduleNextRun(scheduled);
+        }
+        this.emit('scheduled', loop.id, nextRunAt);
+    }
+    unschedule(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled) {
+            throw new LoopNotFoundError(loopId);
+        }
+        if (scheduled.timer !== null) {
+            clearTimeout(scheduled.timer);
+        }
+        this.scheduledLoops.delete(loopId);
+        this.emit('unscheduled', loopId);
+    }
+    update(loop) {
+        const scheduled = this.scheduledLoops.get(loop.id);
+        if (!scheduled) {
+            throw new LoopNotFoundError(loop.id);
+        }
+        if (scheduled.timer !== null) {
+            clearTimeout(scheduled.timer);
+            scheduled.timer = null;
+        }
+        scheduled.loop = loop;
+        if (loop.status === 'paused') {
+            scheduled.paused = true;
+        }
+        else if (loop.status === 'running') {
+            scheduled.paused = false;
+            scheduled.nextRunAt = this.calculateNextRunTime(loop.interval);
+            if (this.started) {
+                this.scheduleNextRun(scheduled);
+            }
+        }
+        else if (loop.status === 'stopped' || loop.status === 'expired') {
+            scheduled.paused = true;
+        }
+    }
+    pause(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled) {
+            throw new LoopNotFoundError(loopId);
+        }
+        if (scheduled.paused) {
+            throw new InvalidLoopStateError(loopId, scheduled.loop.status, 'running');
+        }
+        if (scheduled.timer !== null) {
+            clearTimeout(scheduled.timer);
+            scheduled.timer = null;
+        }
+        scheduled.paused = true;
+        scheduled.loop = { ...scheduled.loop, status: 'paused' };
+    }
+    resume(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled) {
+            throw new LoopNotFoundError(loopId);
+        }
+        if (!scheduled.paused) {
+            throw new InvalidLoopStateError(loopId, scheduled.loop.status, 'paused');
+        }
+        if (scheduled.loop.expiresAt && scheduled.loop.expiresAt <= new Date()) {
+            this.expiredCount++;
+            this.emit('expired', loopId);
+            return;
+        }
+        scheduled.paused = false;
+        scheduled.loop = { ...scheduled.loop, status: 'running' };
+        scheduled.nextRunAt = this.calculateNextRunTime(scheduled.loop.interval);
+        if (this.started) {
+            this.scheduleNextRun(scheduled);
+        }
+        this.emit('scheduled', loopId, scheduled.nextRunAt);
+    }
+    triggerNow(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled) {
+            throw new LoopNotFoundError(loopId);
+        }
+        if (scheduled.timer !== null) {
+            clearTimeout(scheduled.timer);
+            scheduled.timer = null;
+        }
+        this.executeLoop(scheduled);
+    }
+    isScheduled(loopId) {
+        return this.scheduledLoops.has(loopId);
+    }
+    getScheduled(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        return scheduled?.loop ?? null;
+    }
+    getNextRunTime(loopId) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled || scheduled.paused) {
+            return null;
+        }
+        return scheduled.nextRunAt;
+    }
+    getScheduledLoopIds() {
+        return Array.from(this.scheduledLoops.keys());
+    }
+    getActiveLoopIds() {
+        return Array.from(this.scheduledLoops.entries())
+            .filter(([, scheduled]) => !scheduled.paused)
+            .map(([id]) => id);
+    }
+    getStats() {
+        let pausedCount = 0;
+        for (const scheduled of this.scheduledLoops.values()) {
+            if (scheduled.paused) {
+                pausedCount++;
+            }
+        }
+        return {
+            scheduledCount: this.scheduledLoops.size,
+            pausedCount,
+            executionCount: this.executionCount,
+            expiredCount: this.expiredCount,
+            startedAt: this.startedAt,
+            lastExecutionAt: this.lastExecutionAt,
+        };
+    }
+    scheduleNextRun(scheduled) {
+        if (scheduled.paused || !this.started) {
+            return;
+        }
+        if (scheduled.loop.expiresAt && scheduled.loop.expiresAt <= new Date()) {
+            this.expiredCount++;
+            this.emit('expired', scheduled.loopId);
+            return;
+        }
+        const now = new Date();
+        let delay = scheduled.nextRunAt.getTime() - now.getTime();
+        if (delay <= 0) {
+            delay = 1;
+        }
+        if (delay > this.maxTimerDelay) {
+            scheduled.timer = setTimeout(() => {
+                this.scheduleNextRun(scheduled);
+            }, this.maxTimerDelay);
+            return;
+        }
+        scheduled.timer = setTimeout(() => {
+            this.executeLoop(scheduled);
+        }, delay);
+    }
+    executeLoop(scheduled) {
+        scheduled.timer = null;
+        if (scheduled.paused || !this.started) {
+            return;
+        }
+        if (scheduled.loop.expiresAt && scheduled.loop.expiresAt <= new Date()) {
+            this.expiredCount++;
+            this.emit('expired', scheduled.loopId);
+            return;
+        }
+        if (scheduled.loop.options.maxRuns !== null &&
+            scheduled.loop.stats.totalRuns >= scheduled.loop.options.maxRuns) {
+        }
+        this.executionCount++;
+        this.lastExecutionAt = new Date();
+        try {
+            this.emit('execute', scheduled.loop);
+        }
+        catch (error) {
+            this.emit('error', error, scheduled.loopId);
+        }
+        scheduled.nextRunAt = this.calculateNextRunTime(scheduled.loop.interval);
+        this.applyDriftCorrection(scheduled);
+        this.scheduleNextRun(scheduled);
+    }
+    calculateNextRunTime(interval) {
+        const now = new Date();
+        if (interval.type === 'cron' && interval.cronExpression) {
+            try {
+                const options = {
+                    currentDate: now,
+                };
+                if (this.timezone) {
+                    options.tz = this.timezone;
+                }
+                const parsed = cronParser.parseExpression(interval.cronExpression, options);
+                return parsed.next().toDate();
+            }
+            catch (error) {
+                this.emit('error', new SchedulerError(`Failed to parse cron expression: ${interval.cronExpression}`, { interval: interval.raw, error: String(error) }));
+                return new Date(now.getTime() + interval.milliseconds);
+            }
+        }
+        return new Date(now.getTime() + interval.milliseconds);
+    }
+    applyDriftCorrection(scheduled) {
+        const now = new Date();
+        const expected = scheduled.nextRunAt;
+        if (expected.getTime() > now.getTime()) {
+            return;
+        }
+        const drift = Math.abs(now.getTime() - expected.getTime());
+        if (drift > this.driftThreshold) {
+            if (scheduled.loop.interval.type === 'duration') {
+                const intervalMs = scheduled.loop.interval.milliseconds;
+                const missedIntervals = Math.floor(drift / intervalMs);
+                if (missedIntervals > 0) {
+                    scheduled.nextRunAt = new Date(expected.getTime() + (missedIntervals + 1) * intervalMs);
+                }
+            }
+        }
+    }
+    updateNextRunTime(loopId, nextRunAt) {
+        const scheduled = this.scheduledLoops.get(loopId);
+        if (!scheduled) {
+            return;
+        }
+        scheduled.nextRunAt = nextRunAt;
+        scheduled.loop = {
+            ...scheduled.loop,
+            interval: {
+                ...scheduled.loop.interval,
+                nextRunAt,
+            },
+        };
+        if (this.started && !scheduled.paused) {
+            if (scheduled.timer !== null) {
+                clearTimeout(scheduled.timer);
+                scheduled.timer = null;
+            }
+            this.scheduleNextRun(scheduled);
+        }
+    }
+    clear() {
+        for (const scheduled of this.scheduledLoops.values()) {
+            if (scheduled.timer !== null) {
+                clearTimeout(scheduled.timer);
+            }
+        }
+        this.scheduledLoops.clear();
+        this.executionCount = 0;
+        this.expiredCount = 0;
+        this.lastExecutionAt = null;
+    }
+    get size() {
+        return this.scheduledLoops.size;
+    }
+}
+export function createLoopScheduler(options) {
+    return new LoopScheduler(options);
+}
+export function createAndStartScheduler(options) {
+    const scheduler = new LoopScheduler(options);
+    scheduler.start();
+    return scheduler;
+}

package/dist/loop/LoopStore.d.ts

@@ -0,0 +1,57 @@
+import type { Loop, LoopId, LoopRun, LoopRunId, LoopRegistry, LoopRegistryEntry, LoopStatus, Logger } from './types.js';
+export interface LoopStoreOptions {
+    baseDir?: string;
+    flowdotDir?: string;
+    maxHistoryEntries?: number;
+    logger?: Logger;
+}
+export declare class LoopStore {
+    private readonly baseDir;
+    private readonly flowdotDir;
+    private readonly maxHistoryEntries;
+    private readonly loopsPath;
+    private readonly registryPath;
+    private readonly logger;
+    constructor(options?: LoopStoreOptions);
+    initialize(): Promise<void>;
+    isInitialized(): Promise<boolean>;
+    createLoop(loop: Loop): Promise<void>;
+    getLoop(loopId: LoopId): Promise<Loop>;
+    getLoopByName(name: string): Promise<Loop | null>;
+    updateLoop(loop: Loop): Promise<void>;
+    deleteLoop(loopId: LoopId): Promise<void>;
+    loopExists(loopId: LoopId): Promise<boolean>;
+    isNameTaken(name: string, excludeLoopId?: LoopId): Promise<boolean>;
+    getAllLoops(): Promise<Loop[]>;
+    getLoopsByStatus(status: LoopStatus): Promise<Loop[]>;
+    getActiveLoopCount(): Promise<number>;
+    createRun(run: LoopRun): Promise<void>;
+    updateRun(run: LoopRun): Promise<void>;
+    getRun(loopId: LoopId, runId: LoopRunId): Promise<LoopRun>;
+    getRunHistory(loopId: LoopId, limit?: number): Promise<LoopRun[]>;
+    cleanupRunHistory(loopId: LoopId): Promise<number>;
+    readRegistry(): Promise<LoopRegistry>;
+    getRegistryEntries(): Promise<LoopRegistryEntry[]>;
+    private addToRegistry;
+    private updateRegistryEntry;
+    private removeFromRegistry;
+    private writeRegistry;
+    private ensureRegistry;
+    private createEmptyRegistry;
+    private migrateRegistry;
+    writeDaemonPid(pid: number): Promise<void>;
+    readDaemonPid(): Promise<{
+        pid: number;
+        startedAt: Date;
+    } | null>;
+    deleteDaemonPid(): Promise<void>;
+    private getLoopDirectory;
+    private getRunPath;
+    private ensureDirectory;
+    private readJsonFile;
+    private writeJsonFile;
+    private isNotFoundError;
+    getStoragePath(): string;
+}
+export declare function createLoopStore(options?: LoopStoreOptions): LoopStore;
+export declare function initializeLoopStore(options?: LoopStoreOptions): Promise<LoopStore>;