@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopManager.js

@@ -0,0 +1,476 @@
+import { EventEmitter } from 'node:events';
+import { v4 as uuidv4 } from 'uuid';
+import msPkg from 'ms';
+function parseDurationString(value) {
+    return msPkg(value);
+}
+import { DEFAULT_LOOP_OPTIONS, DEFAULT_LOOP_CONFIG, INITIAL_LOOP_STATS, } from './types.js';
+import { LoopError, LoopNameTakenError, LoopInvalidStatusError, LoopLimitExceededError, LoopExpiredError, } from './errors.js';
+import { LoopStore } from './LoopStore.js';
+import { LoopScheduler } from './LoopScheduler.js';
+import { LoopExecutor } from './LoopExecutor.js';
+import { LoopValidator } from './LoopValidator.js';
+import { IntervalParser } from './IntervalParser.js';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class LoopManager extends EventEmitter {
+    store;
+    scheduler;
+    executor;
+    validator;
+    intervalParser;
+    config;
+    logger;
+    initialized = false;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger ?? noopLogger;
+        this.config = {
+            ...DEFAULT_LOOP_CONFIG,
+            ...options.config,
+            daemon: {
+                ...DEFAULT_LOOP_CONFIG.daemon,
+                ...options.config?.daemon,
+            },
+            webhooks: {
+                ...DEFAULT_LOOP_CONFIG.webhooks,
+                ...options.config?.webhooks,
+            },
+        };
+        const minIntervalMs = parseDurationString(this.config.minInterval) ?? 60000;
+        const maxRunDurationMs = parseDurationString(this.config.maxRunDuration) ?? 30 * 60 * 1000;
+        this.store = new LoopStore({
+            baseDir: options.baseDir,
+            logger: this.logger,
+        });
+        const schedulerOptions = {
+            driftThreshold: 5000,
+            logger: this.logger,
+        };
+        this.scheduler = new LoopScheduler(schedulerOptions);
+        const executorOptions = {
+            defaultTimeoutMs: maxRunDurationMs,
+            getAgenticResponse: options.getAgenticResponse,
+            executeAction: options.executeAction,
+            logger: this.logger,
+        };
+        this.executor = new LoopExecutor(executorOptions);
+        this.validator = new LoopValidator({
+            maxPromptLength: 10000,
+            maxNameLength: 100,
+        }, { minIntervalMs });
+        this.intervalParser = new IntervalParser({
+            minIntervalMs,
+        });
+        this.setupEventHandlers();
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.logger.info('LOOP', 'Initializing LoopManager');
+        await this.store.initialize();
+        const loops = await this.store.getAllLoops();
+        let scheduledCount = 0;
+        for (const loop of loops) {
+            if (this.isLoopExpired(loop)) {
+                await this.handleExpiredLoop(loop);
+                continue;
+            }
+            if (loop.status === 'running') {
+                try {
+                    this.scheduler.schedule(loop);
+                    scheduledCount++;
+                }
+                catch (error) {
+                    this.logger.error('LOOP', `Failed to schedule loop ${loop.id}`, {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+        this.logger.info('LOOP', `Initialized with ${loops.length} loops, ${scheduledCount} scheduled`);
+        this.initialized = true;
+    }
+    start() {
+        this.ensureInitialized();
+        this.scheduler.start();
+        this.logger.info('LOOP', 'LoopManager started');
+    }
+    stop() {
+        this.scheduler.stop();
+        this.executor.cancelAllExecutions();
+        this.logger.info('LOOP', 'LoopManager stopped');
+    }
+    async shutdown() {
+        this.logger.info('LOOP', 'Shutting down LoopManager');
+        this.stop();
+        this.removeAllListeners();
+        this.initialized = false;
+    }
+    async createLoop(input) {
+        this.ensureInitialized();
+        this.logger.debug('LOOP', 'Creating loop', { prompt: input.prompt.substring(0, 50) });
+        const validationResult = this.validator.validateCreateInput(input);
+        if (validationResult && validationResult.valid === false) {
+            const firstError = validationResult.errors?.[0];
+            if (firstError instanceof Error) {
+                throw firstError;
+            }
+            throw new LoopError('VALIDATION_ERROR', typeof firstError?.message === 'string' ? firstError.message : 'Invalid loop input');
+        }
+        const activeCount = await this.store.getActiveLoopCount();
+        if (activeCount >= this.config.maxConcurrentLoops) {
+            throw new LoopLimitExceededError(activeCount, this.config.maxConcurrentLoops);
+        }
+        if (input.name) {
+            const nameTaken = await this.store.isNameTaken(input.name);
+            if (nameTaken) {
+                throw new LoopNameTakenError(input.name);
+            }
+        }
+        const interval = this.intervalParser.parse(input.interval);
+        const expiresAt = this.calculateExpiration(input.expires);
+        const options = {
+            ...DEFAULT_LOOP_OPTIONS,
+            model: input.model ?? DEFAULT_LOOP_OPTIONS.model,
+            maxRuns: input.maxRuns ?? DEFAULT_LOOP_OPTIONS.maxRuns,
+            onError: input.onError ?? this.config.defaultOnError,
+            notify: input.notify ?? this.config.defaultNotify,
+            webhookUrl: input.webhookUrl ?? DEFAULT_LOOP_OPTIONS.webhookUrl,
+            quiet: input.quiet ?? DEFAULT_LOOP_OPTIONS.quiet,
+        };
+        const now = new Date();
+        const loop = {
+            id: uuidv4(),
+            name: input.name ?? null,
+            prompt: input.prompt,
+            interval,
+            status: input.dryRun ? 'paused' : 'running',
+            createdAt: now,
+            expiresAt,
+            options,
+            stats: { ...INITIAL_LOOP_STATS },
+            cwd: input.cwd ?? process.cwd(),
+        };
+        await this.store.createLoop(loop);
+        if (!input.dryRun) {
+            this.scheduler.schedule(loop);
+        }
+        this.logger.info('LOOP', `Created loop ${loop.id}`, {
+            name: loop.name,
+            interval: loop.interval.raw,
+            status: loop.status,
+        });
+        this.emit('created', loop);
+        if (!input.dryRun) {
+            this.emit('started', loop);
+        }
+        return loop;
+    }
+    async getLoop(loopId) {
+        this.ensureInitialized();
+        return this.store.getLoop(loopId);
+    }
+    async getLoopByName(name) {
+        this.ensureInitialized();
+        return this.store.getLoopByName(name);
+    }
+    async getAllLoops() {
+        this.ensureInitialized();
+        return this.store.getAllLoops();
+    }
+    async getLoopsByStatus(status) {
+        this.ensureInitialized();
+        return this.store.getLoopsByStatus(status);
+    }
+    async pauseLoop(loopId) {
+        this.ensureInitialized();
+        const loop = await this.store.getLoop(loopId);
+        if (loop.status !== 'running') {
+            throw new LoopInvalidStatusError(loopId, loop.status, 'pause', ['running']);
+        }
+        loop.status = 'paused';
+        await this.store.updateLoop(loop);
+        this.scheduler.pause(loopId);
+        this.executor.cancelAll(loopId);
+        this.logger.info('LOOP', `Paused loop ${loopId}`);
+        this.emit('paused', loop);
+        return loop;
+    }
+    async resumeLoop(loopId) {
+        this.ensureInitialized();
+        const loop = await this.store.getLoop(loopId);
+        if (loop.status !== 'paused') {
+            throw new LoopInvalidStatusError(loopId, loop.status, 'resume', ['paused']);
+        }
+        if (this.isLoopExpired(loop)) {
+            await this.handleExpiredLoop(loop);
+            throw new LoopExpiredError(loopId, loop.expiresAt);
+        }
+        const activeCount = await this.store.getActiveLoopCount();
+        if (activeCount >= this.config.maxConcurrentLoops) {
+            throw new LoopLimitExceededError(activeCount, this.config.maxConcurrentLoops);
+        }
+        loop.status = 'running';
+        loop.interval.nextRunAt = this.intervalParser.calculateNextRun(loop.interval);
+        await this.store.updateLoop(loop);
+        this.scheduler.resume(loopId);
+        this.logger.info('LOOP', `Resumed loop ${loopId}`);
+        this.emit('resumed', loop);
+        return loop;
+    }
+    async stopLoop(loopId) {
+        this.ensureInitialized();
+        const loop = await this.store.getLoop(loopId);
+        if (loop.status === 'stopped') {
+            throw new LoopInvalidStatusError(loopId, loop.status, 'stop', ['running', 'paused', 'error', 'expired']);
+        }
+        loop.status = 'stopped';
+        await this.store.updateLoop(loop);
+        this.scheduler.unschedule(loopId);
+        this.executor.cancelAll(loopId);
+        this.logger.info('LOOP', `Stopped loop ${loopId}`);
+        this.emit('stopped', loop);
+        return loop;
+    }
+    async deleteLoop(loopId) {
+        this.ensureInitialized();
+        await this.store.getLoop(loopId);
+        this.scheduler.unschedule(loopId);
+        this.executor.cancelAll(loopId);
+        await this.store.deleteLoop(loopId);
+        this.logger.info('LOOP', `Deleted loop ${loopId}`);
+        this.emit('deleted', loopId);
+    }
+    async runNow(loopId) {
+        this.ensureInitialized();
+        const loop = await this.store.getLoop(loopId);
+        if (loop.status === 'stopped' || loop.status === 'expired') {
+            throw new LoopInvalidStatusError(loopId, loop.status, 'run now', ['running', 'paused', 'error']);
+        }
+        if (this.isLoopExpired(loop)) {
+            await this.handleExpiredLoop(loop);
+            throw new LoopExpiredError(loopId, loop.expiresAt);
+        }
+        this.logger.info('LOOP', `Triggering immediate run for loop ${loopId}`);
+        const result = await this.executeLoop(loop);
+        return result.run;
+    }
+    async getRunHistory(loopId, limit) {
+        this.ensureInitialized();
+        await this.store.getLoop(loopId);
+        return this.store.getRunHistory(loopId, limit);
+    }
+    async getRun(loopId, runId) {
+        this.ensureInitialized();
+        return this.store.getRun(loopId, runId);
+    }
+    async getStats() {
+        this.ensureInitialized();
+        const allLoops = await this.store.getAllLoops();
+        let totalRuns = 0;
+        let successfulRuns = 0;
+        let failedRuns = 0;
+        const statusCounts = {
+            running: 0,
+            paused: 0,
+            stopped: 0,
+            expired: 0,
+            error: 0,
+        };
+        for (const loop of allLoops) {
+            statusCounts[loop.status]++;
+            totalRuns += loop.stats.totalRuns;
+            successfulRuns += loop.stats.successfulRuns;
+            failedRuns += loop.stats.failedRuns;
+        }
+        return {
+            totalLoops: allLoops.length,
+            activeLoops: statusCounts.running,
+            pausedLoops: statusCounts.paused,
+            errorLoops: statusCounts.error,
+            totalRuns,
+            successfulRuns,
+            failedRuns,
+            schedulerRunning: this.scheduler.isRunning(),
+            schedulerStats: this.scheduler.getStats(),
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    isRunning() {
+        return this.scheduler.isRunning();
+    }
+    setupEventHandlers() {
+        this.scheduler.on('execute', async (loop) => {
+            try {
+                await this.executeLoop(loop);
+            }
+            catch (error) {
+                this.logger.error('LOOP', `Error executing loop ${loop.id}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                this.emit('error', error instanceof Error ? error : new Error(String(error)), loop.id);
+            }
+        });
+        this.scheduler.on('expired', async (loopId) => {
+            try {
+                const loop = await this.store.getLoop(loopId);
+                await this.handleExpiredLoop(loop);
+            }
+            catch (error) {
+                this.logger.error('LOOP', `Error handling expired loop ${loopId}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        this.scheduler.on('error', (error, loopId) => {
+            this.logger.error('LOOP', 'Scheduler error', {
+                loopId,
+                error: error.message,
+            });
+            this.emit('error', error, loopId);
+        });
+        this.executor.on('start', (loopId, runId) => {
+            this.logger.debug('LOOP', `Run started: ${runId} for loop ${loopId}`);
+        });
+        this.executor.on('complete', async (loopId, result) => {
+            this.logger.debug('LOOP', `Run completed: ${result.run.id} for loop ${loopId}`, {
+                success: result.success,
+                duration: result.duration,
+            });
+        });
+        this.executor.on('error', (loopId, runId, error) => {
+            this.logger.error('LOOP', `Run error: ${runId} for loop ${loopId}`, {
+                error: error.message,
+            });
+        });
+        this.executor.on('timeout', (loopId, runId, timeoutMs) => {
+            this.logger.warn('LOOP', `Run timeout: ${runId} for loop ${loopId}`, {
+                timeoutMs,
+            });
+        });
+    }
+    async executeLoop(loop) {
+        this.logger.info('LOOP', `Executing loop ${loop.id}`, {
+            name: loop.name,
+            runNumber: loop.stats.totalRuns + 1,
+        });
+        const runId = uuidv4();
+        this.emit('runStarted', loop, runId);
+        const result = await this.executor.execute(loop);
+        await this.store.createRun(result.run);
+        await this.updateLoopStats(loop, result);
+        if (loop.options.maxRuns !== null && loop.stats.totalRuns >= loop.options.maxRuns) {
+            this.logger.info('LOOP', `Loop ${loop.id} reached max runs (${loop.options.maxRuns})`);
+            await this.stopLoop(loop.id);
+            return result;
+        }
+        if (!result.success) {
+            this.emit('runFailed', loop, result.error ? new Error(result.error.message) : new Error('Unknown error'));
+            if (loop.stats.consecutiveFailures >= this.config.errorThreshold) {
+                await this.handleErrorThreshold(loop);
+                return result;
+            }
+        }
+        else {
+            this.emit('runCompleted', loop, result);
+        }
+        await this.sendNotification(loop, result);
+        return result;
+    }
+    async updateLoopStats(loop, result) {
+        loop.stats.totalRuns++;
+        loop.stats.lastRunAt = result.run.startedAt;
+        loop.stats.lastRunDuration = result.duration;
+        if (result.success) {
+            loop.stats.successfulRuns++;
+            loop.stats.consecutiveFailures = 0;
+            loop.stats.lastRunStatus = 'success';
+            loop.stats.lastError = null;
+        }
+        else {
+            loop.stats.failedRuns++;
+            loop.stats.consecutiveFailures++;
+            loop.stats.lastRunStatus = 'error';
+            loop.stats.lastError = result.error?.message ?? 'Unknown error';
+        }
+        loop.interval.nextRunAt = this.intervalParser.calculateNextRun(loop.interval);
+        await this.store.updateLoop(loop);
+    }
+    async handleErrorThreshold(loop) {
+        const reason = `Exceeded error threshold (${this.config.errorThreshold} consecutive failures)`;
+        this.logger.warn('LOOP', `Auto-pausing loop ${loop.id}: ${reason}`);
+        switch (loop.options.onError) {
+            case 'pause':
+                loop.status = 'paused';
+                this.scheduler.pause(loop.id);
+                break;
+            case 'stop':
+                loop.status = 'stopped';
+                this.scheduler.unschedule(loop.id);
+                break;
+            case 'continue':
+                loop.stats.consecutiveFailures = 0;
+                break;
+            default:
+                break;
+        }
+        await this.store.updateLoop(loop);
+        if (loop.options.onError !== 'continue') {
+            this.emit('autoPaused', loop, reason);
+        }
+    }
+    async handleExpiredLoop(loop) {
+        this.logger.info('LOOP', `Loop ${loop.id} expired`);
+        loop.status = 'expired';
+        await this.store.updateLoop(loop);
+        this.scheduler.unschedule(loop.id);
+        this.executor.cancelAll(loop.id);
+        this.emit('expired', loop);
+    }
+    async sendNotification(loop, result) {
+        if (loop.options.notify === 'none') {
+            return;
+        }
+        if (!loop.options.quiet) {
+            const status = result.success ? '✓' : '✗';
+            const duration = `${(result.duration / 1000).toFixed(1)}s`;
+            this.logger.info('LOOP', `[${status}] Loop "${loop.name || loop.id}" completed in ${duration}`);
+        }
+    }
+    calculateExpiration(expires) {
+        const expiresStr = expires ?? this.config.defaultExpiration;
+        if (!expiresStr || expiresStr === 'never') {
+            return null;
+        }
+        const expiresMs = parseDurationString(expiresStr);
+        if (expiresMs === undefined) {
+            return null;
+        }
+        return new Date(Date.now() + expiresMs);
+    }
+    isLoopExpired(loop) {
+        if (!loop.expiresAt) {
+            return false;
+        }
+        return new Date() >= loop.expiresAt;
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new LoopError('MANAGER_NOT_INITIALIZED', 'LoopManager must be initialized before use. Call initialize() first.');
+        }
+    }
+}
+export function createLoopManager(options) {
+    return new LoopManager(options);
+}

package/dist/loop/LoopScheduler.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from 'node:events';
+import type { Loop, LoopId, LoopConfig, Logger } from './types.js';
+export interface SchedulerEvents {
+    execute: [loop: Loop];
+    scheduled: [loopId: LoopId, nextRunAt: Date];
+    unscheduled: [loopId: LoopId];
+    expired: [loopId: LoopId];
+    error: [error: Error, loopId?: LoopId];
+}
+export interface LoopSchedulerOptions {
+    config?: Partial<LoopConfig>;
+    timezone?: string;
+    maxTimerDelay?: number;
+    driftThreshold?: number;
+    logger?: Logger;
+}
+export type SchedulerOptions = LoopSchedulerOptions;
+export interface SchedulerStats {
+    scheduledCount: number;
+    pausedCount: number;
+    executionCount: number;
+    expiredCount: number;
+    startedAt: Date | null;
+    lastExecutionAt: Date | null;
+}
+export declare class LoopScheduler extends EventEmitter {
+    private readonly scheduledLoops;
+    private readonly timezone;
+    private readonly maxTimerDelay;
+    private readonly driftThreshold;
+    private readonly logger;
+    private started;
+    private startedAt;
+    private executionCount;
+    private expiredCount;
+    private lastExecutionAt;
+    constructor(options?: LoopSchedulerOptions);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    schedule(loop: Loop): void;
+    unschedule(loopId: LoopId): void;
+    update(loop: Loop): void;
+    pause(loopId: LoopId): void;
+    resume(loopId: LoopId): void;
+    triggerNow(loopId: LoopId): void;
+    isScheduled(loopId: LoopId): boolean;
+    getScheduled(loopId: LoopId): Loop | null;
+    getNextRunTime(loopId: LoopId): Date | null;
+    getScheduledLoopIds(): LoopId[];
+    getActiveLoopIds(): LoopId[];
+    getStats(): SchedulerStats;
+    private scheduleNextRun;
+    private executeLoop;
+    private calculateNextRunTime;
+    private applyDriftCorrection;
+    updateNextRunTime(loopId: LoopId, nextRunAt: Date): void;
+    clear(): void;
+    get size(): number;
+}
+export interface TypedLoopScheduler {
+    on<K extends keyof SchedulerEvents>(event: K, listener: (...args: SchedulerEvents[K]) => void): this;
+    once<K extends keyof SchedulerEvents>(event: K, listener: (...args: SchedulerEvents[K]) => void): this;
+    emit<K extends keyof SchedulerEvents>(event: K, ...args: SchedulerEvents[K]): boolean;
+    off<K extends keyof SchedulerEvents>(event: K, listener: (...args: SchedulerEvents[K]) => void): this;
+    removeListener<K extends keyof SchedulerEvents>(event: K, listener: (...args: SchedulerEvents[K]) => void): this;
+}
+export declare function createLoopScheduler(options?: LoopSchedulerOptions): LoopScheduler;
+export declare function createAndStartScheduler(options?: LoopSchedulerOptions): LoopScheduler;