@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopExecutor.d.ts

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'node:events';
+import type { Loop, LoopRun, LoopRunId, LoopId, LoopRunError, LoopConfig, Logger } from './types.js';
+export interface ExecutionResult {
+    readonly run: LoopRun;
+    readonly success: boolean;
+    readonly output: string | null;
+    readonly error: LoopRunError | null;
+    readonly duration: number;
+}
+export interface ExecutionContext {
+    readonly cwd: string;
+    readonly conversationHistory: Array<{
+        role: string;
+        content: string;
+    }>;
+    readonly linkedRecipes: Array<{
+        alias: string;
+        hash: string;
+    }>;
+    readonly onOutput?: (text: string) => void;
+}
+export interface LoopExecutorOptions {
+    defaultTimeoutMs?: number;
+    onStart?: (loopId: LoopId, runId: LoopRunId) => void;
+    onOutput?: (loopId: LoopId, runId: LoopRunId, text: string) => void;
+    onComplete?: (loopId: LoopId, result: ExecutionResult) => void;
+    onError?: (loopId: LoopId, runId: LoopRunId, error: Error) => void;
+    getAgenticResponse?: AgentResponseFunction;
+    executeAction?: ActionExecutorFunction;
+    logger?: Logger;
+}
+export type ExecutorOptions = LoopExecutorOptions;
+export type AgentResponseFunction = (input: string, conversationHistory: Array<{
+    role: string;
+    content: string;
+}>, linkedRecipes: Array<{
+    alias: string;
+    hash: string;
+}>, options?: {
+    modelTier?: string;
+    maxTokens?: number;
+    onToken?: (tokenDelta: number) => void;
+}) => Promise<AgentResponse>;
+export interface AgentResponse {
+    message: string;
+    action: AgentAction;
+}
+export interface AgentAction {
+    type: string;
+    payload?: unknown;
+}
+export type ActionExecutorFunction = (action: AgentAction, context: ExecutionContext) => Promise<ActionResult>;
+export interface ActionResult {
+    success: boolean;
+    error?: string;
+    data?: unknown;
+    permissionDenied?: boolean;
+    requiresPermission?: boolean;
+}
+export interface ExecutorEvents {
+    start: [loopId: LoopId, runId: LoopRunId];
+    output: [loopId: LoopId, runId: LoopRunId, text: string];
+    complete: [loopId: LoopId, result: ExecutionResult];
+    error: [loopId: LoopId, runId: LoopRunId, error: Error];
+    timeout: [loopId: LoopId, runId: LoopRunId, timeoutMs: number];
+}
+export declare class LoopExecutor extends EventEmitter {
+    private readonly maxRunDurationMs;
+    private readonly getAgenticResponseFn;
+    private readonly executeActionFn;
+    private readonly logger;
+    private readonly runningExecutions;
+    constructor(options?: LoopExecutorOptions);
+    on<K extends keyof ExecutorEvents>(event: K, listener: (...args: ExecutorEvents[K]) => void): this;
+    emit<K extends keyof ExecutorEvents>(event: K, ...args: ExecutorEvents[K]): boolean;
+    off<K extends keyof ExecutorEvents>(event: K, listener: (...args: ExecutorEvents[K]) => void): this;
+    execute(loop: Loop): Promise<ExecutionResult>;
+    cancel(runId: LoopRunId): boolean;
+    cancelAll(loopId: LoopId): number;
+    cancelAllExecutions(): number;
+    isRunning(runId: LoopRunId): boolean;
+    getRunningExecutionIds(): LoopRunId[];
+    getRunningExecutionsForLoop(loopId: LoopId): LoopRunId[];
+    getRunningCount(): number;
+    private executePrompt;
+    private createTimeoutPromise;
+    private wrapExecutionError;
+}
+export declare function createLoopExecutor(options?: LoopExecutorOptions): LoopExecutor;
+export declare function createLoopExecutorWithConfig(config: LoopConfig, options?: Omit<LoopExecutorOptions, 'maxRunDurationMs'>): LoopExecutor;
+export declare function createEmptyRun(loopId: LoopId): LoopRun;
+export declare function createSuccessfulRun(loopId: LoopId, output: string, durationMs: number): LoopRun;
+export declare function createFailedRun(loopId: LoopId, error: LoopRunError, output: string | null, durationMs: number): LoopRun;

package/dist/loop/LoopExecutor.js

@@ -0,0 +1,326 @@
+import { v4 as uuidv4 } from 'uuid';
+import msPkg from 'ms';
+import { EventEmitter } from 'node:events';
+import { LoopExecutionError, LoopExecutionTimeoutError, } from './errors.js';
+function parseDurationString(value) {
+    return msPkg(value);
+}
+const DEFAULT_MAX_RUN_DURATION_MS = 30 * 60 * 1000;
+const MAX_OUTPUT_BUFFER_SIZE = 1024 * 1024;
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class LoopExecutor extends EventEmitter {
+    maxRunDurationMs;
+    getAgenticResponseFn;
+    executeActionFn;
+    logger;
+    runningExecutions = new Map();
+    constructor(options = {}) {
+        super();
+        this.maxRunDurationMs = options.defaultTimeoutMs ?? DEFAULT_MAX_RUN_DURATION_MS;
+        this.getAgenticResponseFn = options.getAgenticResponse ?? null;
+        this.executeActionFn = options.executeAction ?? null;
+        this.logger = options.logger ?? noopLogger;
+        if (options.onStart) {
+            this.on('start', options.onStart);
+        }
+        if (options.onOutput) {
+            this.on('output', options.onOutput);
+        }
+        if (options.onComplete) {
+            this.on('complete', options.onComplete);
+        }
+        if (options.onError) {
+            this.on('error', options.onError);
+        }
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    async execute(loop) {
+        const runId = uuidv4();
+        const startedAt = new Date();
+        const abortController = new AbortController();
+        const run = {
+            id: runId,
+            loopId: loop.id,
+            startedAt,
+            completedAt: null,
+            status: 'running',
+            duration: null,
+            output: null,
+            error: null,
+        };
+        this.runningExecutions.set(runId, {
+            loopId: loop.id,
+            abortController,
+            startedAt,
+        });
+        this.emit('start', loop.id, runId);
+        const outputBuffer = [];
+        let outputSize = 0;
+        const handleOutput = (text) => {
+            if (outputSize + text.length <= MAX_OUTPUT_BUFFER_SIZE) {
+                outputBuffer.push(text);
+                outputSize += text.length;
+            }
+            this.emit('output', loop.id, runId, text);
+        };
+        const timeoutPromise = this.createTimeoutPromise(loop.id, runId, this.maxRunDurationMs, abortController);
+        try {
+            const executionPromise = this.executePrompt(loop, runId, handleOutput, abortController.signal);
+            const result = await Promise.race([executionPromise, timeoutPromise]);
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            const finalRun = {
+                ...run,
+                completedAt,
+                status: result.success ? 'success' : 'error',
+                duration,
+                output: outputBuffer.join('') || null,
+                error: result.error,
+            };
+            const executionResult = {
+                run: finalRun,
+                success: result.success,
+                output: finalRun.output,
+                error: result.error,
+                duration,
+            };
+            if (!result.success && result.error && this.listenerCount('error') > 0) {
+                const loopError = new LoopExecutionError(loop.id, runId, result.error.message);
+                this.emit('error', loop.id, runId, loopError);
+            }
+            this.emit('complete', loop.id, executionResult);
+            return executionResult;
+        }
+        catch (error) {
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            const loopError = this.wrapExecutionError(error, loop.id, runId);
+            const runError = {
+                code: loopError.code,
+                message: loopError.message,
+                stack: loopError.stack ?? null,
+            };
+            const finalRun = {
+                ...run,
+                completedAt,
+                status: 'error',
+                duration,
+                output: outputBuffer.join('') || null,
+                error: runError,
+            };
+            const executionResult = {
+                run: finalRun,
+                success: false,
+                output: finalRun.output,
+                error: runError,
+                duration,
+            };
+            if (this.listenerCount('error') > 0) {
+                this.emit('error', loop.id, runId, loopError);
+            }
+            this.emit('complete', loop.id, executionResult);
+            return executionResult;
+        }
+        finally {
+            this.runningExecutions.delete(runId);
+        }
+    }
+    cancel(runId) {
+        const execution = this.runningExecutions.get(runId);
+        if (!execution) {
+            return false;
+        }
+        execution.abortController.abort();
+        return true;
+    }
+    cancelAll(loopId) {
+        let cancelled = 0;
+        for (const [, execution] of this.runningExecutions) {
+            if (execution.loopId === loopId) {
+                execution.abortController.abort();
+                cancelled++;
+            }
+        }
+        return cancelled;
+    }
+    cancelAllExecutions() {
+        let cancelled = 0;
+        for (const [, execution] of this.runningExecutions) {
+            execution.abortController.abort();
+            cancelled++;
+        }
+        return cancelled;
+    }
+    isRunning(runId) {
+        return this.runningExecutions.has(runId);
+    }
+    getRunningExecutionIds() {
+        return Array.from(this.runningExecutions.keys());
+    }
+    getRunningExecutionsForLoop(loopId) {
+        const result = [];
+        for (const [runId, execution] of this.runningExecutions) {
+            if (execution.loopId === loopId) {
+                result.push(runId);
+            }
+        }
+        return result;
+    }
+    getRunningCount() {
+        return this.runningExecutions.size;
+    }
+    async executePrompt(loop, runId, onOutput, signal) {
+        if (signal.aborted) {
+            return {
+                success: false,
+                error: {
+                    code: 'LOOP_EXECUTION_ERROR',
+                    message: 'Execution was cancelled',
+                    stack: null,
+                },
+            };
+        }
+        const context = {
+            cwd: loop.cwd,
+            conversationHistory: [],
+            linkedRecipes: [],
+            onOutput,
+        };
+        try {
+            if (!this.getAgenticResponseFn) {
+                throw new Error('Agent response function not configured. Inject via constructor options.');
+            }
+            const response = await this.getAgenticResponseFn(loop.prompt, context.conversationHistory, context.linkedRecipes, {
+                modelTier: loop.options.model,
+            });
+            if (signal.aborted) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'LOOP_EXECUTION_ERROR',
+                        message: 'Execution was cancelled',
+                        stack: null,
+                    },
+                };
+            }
+            if (response.message) {
+                onOutput(response.message);
+            }
+            if (response.action && response.action.type !== 'none') {
+                if (!this.executeActionFn) {
+                    throw new Error('Action executor function not configured. Inject via constructor options.');
+                }
+                const actionResult = await this.executeActionFn(response.action, context);
+                if (!actionResult.success) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'LOOP_EXECUTION_ERROR',
+                            message: actionResult.error ?? 'Action execution failed',
+                            stack: null,
+                        },
+                    };
+                }
+            }
+            return { success: true, error: null };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : null;
+            return {
+                success: false,
+                error: {
+                    code: 'LOOP_EXECUTION_ERROR',
+                    message: errorMessage,
+                    stack: errorStack ?? null,
+                },
+            };
+        }
+    }
+    createTimeoutPromise(loopId, runId, timeoutMs, abortController) {
+        return new Promise((_, reject) => {
+            const timer = setTimeout(() => {
+                abortController.abort();
+                this.emit('timeout', loopId, runId, timeoutMs);
+                reject(new LoopExecutionTimeoutError(loopId, runId, timeoutMs));
+            }, timeoutMs);
+            abortController.signal.addEventListener('abort', () => {
+                clearTimeout(timer);
+            });
+        });
+    }
+    wrapExecutionError(error, loopId, runId) {
+        if (error instanceof LoopExecutionTimeoutError) {
+            return error;
+        }
+        if (error instanceof LoopExecutionError) {
+            return error;
+        }
+        const cause = error instanceof Error ? error : new Error(String(error));
+        return new LoopExecutionError(loopId, runId, cause.message, cause);
+    }
+}
+export function createLoopExecutor(options) {
+    return new LoopExecutor(options);
+}
+export function createLoopExecutorWithConfig(config, options) {
+    const maxRunDurationMs = parseDurationString(config.maxRunDuration);
+    if (maxRunDurationMs === undefined) {
+        throw new Error(`Invalid maxRunDuration config: ${config.maxRunDuration}`);
+    }
+    return new LoopExecutor({
+        ...options,
+        defaultTimeoutMs: maxRunDurationMs,
+    });
+}
+export function createEmptyRun(loopId) {
+    return {
+        id: uuidv4(),
+        loopId,
+        startedAt: new Date(),
+        completedAt: null,
+        status: 'running',
+        duration: null,
+        output: null,
+        error: null,
+    };
+}
+export function createSuccessfulRun(loopId, output, durationMs) {
+    const startedAt = new Date(Date.now() - durationMs);
+    return {
+        id: uuidv4(),
+        loopId,
+        startedAt,
+        completedAt: new Date(),
+        status: 'success',
+        duration: durationMs,
+        output,
+        error: null,
+    };
+}
+export function createFailedRun(loopId, error, output, durationMs) {
+    const startedAt = new Date(Date.now() - durationMs);
+    return {
+        id: uuidv4(),
+        loopId,
+        startedAt,
+        completedAt: new Date(),
+        status: 'error',
+        duration: durationMs,
+        output,
+        error,
+    };
+}

package/dist/loop/LoopManager.d.ts

@@ -0,0 +1,79 @@
+import { EventEmitter } from 'node:events';
+import type { Loop, LoopId, LoopRun, LoopRunId, LoopStatus, LoopConfig, LoopCreateInput, Logger } from './types.js';
+import type { AgentResponseFunction, ActionExecutorFunction } from './LoopExecutor.js';
+import { LoopScheduler } from './LoopScheduler.js';
+import { type ExecutionResult } from './LoopExecutor.js';
+export interface ManagerEvents {
+    created: [loop: Loop];
+    started: [loop: Loop];
+    paused: [loop: Loop];
+    resumed: [loop: Loop];
+    stopped: [loop: Loop];
+    deleted: [loopId: LoopId];
+    expired: [loop: Loop];
+    runStarted: [loop: Loop, runId: LoopRunId];
+    runCompleted: [loop: Loop, result: ExecutionResult];
+    runFailed: [loop: Loop, error: Error];
+    autoPaused: [loop: Loop, reason: string];
+    error: [error: Error, loopId?: LoopId];
+}
+export interface LoopManagerOptions {
+    baseDir?: string;
+    config?: Partial<LoopConfig>;
+    getAgenticResponse?: AgentResponseFunction;
+    executeAction?: ActionExecutorFunction;
+    autoStart?: boolean;
+    logger?: Logger;
+}
+export interface ManagerStats {
+    totalLoops: number;
+    activeLoops: number;
+    pausedLoops: number;
+    errorLoops: number;
+    totalRuns: number;
+    successfulRuns: number;
+    failedRuns: number;
+    schedulerRunning: boolean;
+    schedulerStats: ReturnType<LoopScheduler['getStats']>;
+}
+export declare class LoopManager extends EventEmitter {
+    private readonly store;
+    private readonly scheduler;
+    private readonly executor;
+    private readonly validator;
+    private readonly intervalParser;
+    private readonly config;
+    private readonly logger;
+    private initialized;
+    constructor(options?: LoopManagerOptions);
+    initialize(): Promise<void>;
+    start(): void;
+    stop(): void;
+    shutdown(): Promise<void>;
+    createLoop(input: LoopCreateInput): Promise<Loop>;
+    getLoop(loopId: LoopId): Promise<Loop>;
+    getLoopByName(name: string): Promise<Loop | null>;
+    getAllLoops(): Promise<Loop[]>;
+    getLoopsByStatus(status: LoopStatus): Promise<Loop[]>;
+    pauseLoop(loopId: LoopId): Promise<Loop>;
+    resumeLoop(loopId: LoopId): Promise<Loop>;
+    stopLoop(loopId: LoopId): Promise<Loop>;
+    deleteLoop(loopId: LoopId): Promise<void>;
+    runNow(loopId: LoopId): Promise<LoopRun>;
+    getRunHistory(loopId: LoopId, limit?: number): Promise<LoopRun[]>;
+    getRun(loopId: LoopId, runId: LoopRunId): Promise<LoopRun>;
+    getStats(): Promise<ManagerStats>;
+    getConfig(): Readonly<LoopConfig>;
+    isInitialized(): boolean;
+    isRunning(): boolean;
+    private setupEventHandlers;
+    private executeLoop;
+    private updateLoopStats;
+    private handleErrorThreshold;
+    private handleExpiredLoop;
+    private sendNotification;
+    private calculateExpiration;
+    private isLoopExpired;
+    private ensureInitialized;
+}
+export declare function createLoopManager(options?: LoopManagerOptions): LoopManager;