@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopStore.js

@@ -0,0 +1,406 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { LOOP_REGISTRY_VERSION, serializeLoop, deserializeLoop, serializeLoopRun, deserializeLoopRun, } from './types.js';
+import { StorageReadError, StorageWriteError, StorageCorruptError, StorageMigrationError, LoopNotFoundError, LoopRunNotFoundError, wrapError, } from './errors.js';
+const LOOPS_DIRECTORY = 'loops';
+const REGISTRY_FILE = 'registry.json';
+const CONFIG_FILE = 'config.json';
+const HISTORY_DIRECTORY = 'history';
+const DEFAULT_STORE_OPTIONS = {
+    baseDir: process.cwd(),
+    flowdotDir: '.flowdot',
+    maxHistoryEntries: 100,
+};
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class LoopStore {
+    baseDir;
+    flowdotDir;
+    maxHistoryEntries;
+    loopsPath;
+    registryPath;
+    logger;
+    constructor(options = {}) {
+        const opts = { ...DEFAULT_STORE_OPTIONS, ...options };
+        this.baseDir = opts.baseDir;
+        this.flowdotDir = opts.flowdotDir;
+        this.maxHistoryEntries = opts.maxHistoryEntries;
+        this.loopsPath = path.join(this.baseDir, this.flowdotDir, LOOPS_DIRECTORY);
+        this.registryPath = path.join(this.loopsPath, REGISTRY_FILE);
+        this.logger = options.logger ?? noopLogger;
+    }
+    async initialize() {
+        await this.ensureDirectory(this.loopsPath);
+        await this.ensureRegistry();
+    }
+    async isInitialized() {
+        try {
+            await fs.access(this.registryPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createLoop(loop) {
+        const loopDir = this.getLoopDirectory(loop.id);
+        const historyDir = path.join(loopDir, HISTORY_DIRECTORY);
+        try {
+            await this.ensureDirectory(loopDir);
+            await this.ensureDirectory(historyDir);
+            const configPath = path.join(loopDir, CONFIG_FILE);
+            await this.writeJsonFile(configPath, serializeLoop(loop));
+            await this.addToRegistry(loop);
+        }
+        catch (error) {
+            try {
+                await fs.rm(loopDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', `Failed to create loop ${loop.id}`);
+        }
+    }
+    async getLoop(loopId) {
+        const configPath = path.join(this.getLoopDirectory(loopId), CONFIG_FILE);
+        try {
+            const data = await this.readJsonFile(configPath);
+            return deserializeLoop(data);
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                throw new LoopNotFoundError(loopId, 'id');
+            }
+            throw wrapError(error, 'STORAGE_READ_ERROR', `Failed to read loop ${loopId}`);
+        }
+    }
+    async getLoopByName(name) {
+        const registry = await this.readRegistry();
+        const entry = Object.values(registry.loops).find((e) => e.name === name);
+        if (!entry) {
+            return null;
+        }
+        return this.getLoop(entry.id);
+    }
+    async updateLoop(loop) {
+        const loopDir = this.getLoopDirectory(loop.id);
+        const configPath = path.join(loopDir, CONFIG_FILE);
+        const exists = await this.loopExists(loop.id);
+        if (!exists) {
+            throw new LoopNotFoundError(loop.id, 'id');
+        }
+        try {
+            await this.writeJsonFile(configPath, serializeLoop(loop));
+            await this.updateRegistryEntry(loop);
+        }
+        catch (error) {
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', `Failed to update loop ${loop.id}`);
+        }
+    }
+    async deleteLoop(loopId) {
+        const loopDir = this.getLoopDirectory(loopId);
+        const exists = await this.loopExists(loopId);
+        if (!exists) {
+            throw new LoopNotFoundError(loopId, 'id');
+        }
+        try {
+            await this.removeFromRegistry(loopId);
+            await fs.rm(loopDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', `Failed to delete loop ${loopId}`);
+        }
+    }
+    async loopExists(loopId) {
+        const registry = await this.readRegistry();
+        return loopId in registry.loops;
+    }
+    async isNameTaken(name, excludeLoopId) {
+        const registry = await this.readRegistry();
+        return Object.values(registry.loops).some((entry) => entry.name === name && entry.id !== excludeLoopId);
+    }
+    async getAllLoops() {
+        const registry = await this.readRegistry();
+        const loops = [];
+        for (const loopId of Object.keys(registry.loops)) {
+            try {
+                const loop = await this.getLoop(loopId);
+                loops.push(loop);
+            }
+            catch {
+            }
+        }
+        return loops;
+    }
+    async getLoopsByStatus(status) {
+        const allLoops = await this.getAllLoops();
+        return allLoops.filter((loop) => loop.status === status);
+    }
+    async getActiveLoopCount() {
+        const registry = await this.readRegistry();
+        return Object.values(registry.loops).filter((entry) => entry.status === 'running').length;
+    }
+    async createRun(run) {
+        const historyDir = path.join(this.getLoopDirectory(run.loopId), HISTORY_DIRECTORY);
+        const runPath = path.join(historyDir, `${run.id}.json`);
+        try {
+            await this.ensureDirectory(historyDir);
+            await this.writeJsonFile(runPath, serializeLoopRun(run));
+        }
+        catch (error) {
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', `Failed to create run ${run.id} for loop ${run.loopId}`);
+        }
+    }
+    async updateRun(run) {
+        const runPath = this.getRunPath(run.loopId, run.id);
+        try {
+            await this.writeJsonFile(runPath, serializeLoopRun(run));
+        }
+        catch (error) {
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', `Failed to update run ${run.id} for loop ${run.loopId}`);
+        }
+    }
+    async getRun(loopId, runId) {
+        const runPath = this.getRunPath(loopId, runId);
+        try {
+            const data = await this.readJsonFile(runPath);
+            return deserializeLoopRun(data);
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                throw new LoopRunNotFoundError(loopId, runId);
+            }
+            throw wrapError(error, 'STORAGE_READ_ERROR', `Failed to read run ${runId} for loop ${loopId}`);
+        }
+    }
+    async getRunHistory(loopId, limit) {
+        const historyDir = path.join(this.getLoopDirectory(loopId), HISTORY_DIRECTORY);
+        try {
+            const files = await fs.readdir(historyDir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json'));
+            const runs = [];
+            for (const file of jsonFiles) {
+                try {
+                    const filePath = path.join(historyDir, file);
+                    const data = await this.readJsonFile(filePath);
+                    runs.push(deserializeLoopRun(data));
+                }
+                catch {
+                }
+            }
+            runs.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+            if (limit !== undefined && limit > 0) {
+                return runs.slice(0, limit);
+            }
+            return runs;
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                return [];
+            }
+            throw wrapError(error, 'STORAGE_READ_ERROR', `Failed to read run history for loop ${loopId}`);
+        }
+    }
+    async cleanupRunHistory(loopId) {
+        const runs = await this.getRunHistory(loopId);
+        if (runs.length <= this.maxHistoryEntries) {
+            return 0;
+        }
+        const runsToDelete = runs.slice(this.maxHistoryEntries);
+        let deletedCount = 0;
+        for (const run of runsToDelete) {
+            try {
+                const runPath = this.getRunPath(loopId, run.id);
+                await fs.unlink(runPath);
+                deletedCount++;
+            }
+            catch {
+            }
+        }
+        return deletedCount;
+    }
+    async readRegistry() {
+        try {
+            const data = await this.readJsonFile(this.registryPath);
+            if (data.version !== LOOP_REGISTRY_VERSION) {
+                await this.migrateRegistry(data);
+                return this.readRegistry();
+            }
+            return data;
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                return this.createEmptyRegistry();
+            }
+            throw wrapError(error, 'STORAGE_READ_ERROR', 'Failed to read loop registry');
+        }
+    }
+    async getRegistryEntries() {
+        const registry = await this.readRegistry();
+        return Object.values(registry.loops);
+    }
+    async addToRegistry(loop) {
+        const registry = await this.readRegistry();
+        const entry = {
+            id: loop.id,
+            name: loop.name,
+            status: loop.status,
+            createdAt: loop.createdAt.toISOString(),
+            lastRunAt: loop.stats.lastRunAt?.toISOString() ?? null,
+        };
+        registry.loops[loop.id] = entry;
+        registry.updatedAt = new Date().toISOString();
+        await this.writeRegistry(registry);
+    }
+    async updateRegistryEntry(loop) {
+        const registry = await this.readRegistry();
+        if (!(loop.id in registry.loops)) {
+            throw new LoopNotFoundError(loop.id, 'id');
+        }
+        registry.loops[loop.id] = {
+            ...registry.loops[loop.id],
+            name: loop.name,
+            status: loop.status,
+            lastRunAt: loop.stats.lastRunAt?.toISOString() ?? null,
+        };
+        registry.updatedAt = new Date().toISOString();
+        await this.writeRegistry(registry);
+    }
+    async removeFromRegistry(loopId) {
+        const registry = await this.readRegistry();
+        if (!(loopId in registry.loops)) {
+            throw new LoopNotFoundError(loopId, 'id');
+        }
+        delete registry.loops[loopId];
+        registry.updatedAt = new Date().toISOString();
+        await this.writeRegistry(registry);
+    }
+    async writeRegistry(registry) {
+        await this.writeJsonFile(this.registryPath, registry);
+    }
+    async ensureRegistry() {
+        try {
+            await fs.access(this.registryPath);
+        }
+        catch {
+            const registry = this.createEmptyRegistry();
+            await this.writeRegistry(registry);
+        }
+    }
+    createEmptyRegistry() {
+        return {
+            version: LOOP_REGISTRY_VERSION,
+            updatedAt: new Date().toISOString(),
+            loops: {},
+        };
+    }
+    async migrateRegistry(oldRegistry) {
+        if (oldRegistry.version > LOOP_REGISTRY_VERSION) {
+            throw new StorageMigrationError(oldRegistry.version, LOOP_REGISTRY_VERSION, 'Registry version is newer than supported');
+        }
+        const migratedRegistry = {
+            ...oldRegistry,
+            version: LOOP_REGISTRY_VERSION,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.writeRegistry(migratedRegistry);
+    }
+    async writeDaemonPid(pid) {
+        const pidPath = path.join(this.loopsPath, 'daemon.pid');
+        try {
+            await this.writeJsonFile(pidPath, {
+                pid,
+                startedAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            throw wrapError(error, 'STORAGE_WRITE_ERROR', 'Failed to write daemon PID file');
+        }
+    }
+    async readDaemonPid() {
+        const pidPath = path.join(this.loopsPath, 'daemon.pid');
+        try {
+            const data = await this.readJsonFile(pidPath);
+            return {
+                pid: data.pid,
+                startedAt: new Date(data.startedAt),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async deleteDaemonPid() {
+        const pidPath = path.join(this.loopsPath, 'daemon.pid');
+        try {
+            await fs.unlink(pidPath);
+        }
+        catch {
+        }
+    }
+    getLoopDirectory(loopId) {
+        return path.join(this.loopsPath, loopId);
+    }
+    getRunPath(loopId, runId) {
+        return path.join(this.getLoopDirectory(loopId), HISTORY_DIRECTORY, `${runId}.json`);
+    }
+    async ensureDirectory(dirPath) {
+        try {
+            await fs.mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            throw new StorageWriteError(dirPath, 'Failed to create directory', error);
+        }
+    }
+    async readJsonFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                throw error;
+            }
+            if (error instanceof SyntaxError) {
+                throw new StorageCorruptError(filePath, 'Invalid JSON');
+            }
+            throw new StorageReadError(filePath, 'Failed to read file', error);
+        }
+    }
+    async writeJsonFile(filePath, data) {
+        const content = JSON.stringify(data, null, 2);
+        const tempPath = `${filePath}.tmp`;
+        try {
+            await fs.writeFile(tempPath, content, 'utf-8');
+            await fs.rename(tempPath, filePath);
+        }
+        catch (error) {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch {
+            }
+            throw new StorageWriteError(filePath, 'Failed to write file', error);
+        }
+    }
+    isNotFoundError(error) {
+        return (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT');
+    }
+    getStoragePath() {
+        return this.loopsPath;
+    }
+}
+export function createLoopStore(options) {
+    return new LoopStore(options);
+}
+export async function initializeLoopStore(options) {
+    const store = new LoopStore(options);
+    await store.initialize();
+    return store;
+}

package/dist/loop/LoopValidator.d.ts

@@ -0,0 +1,55 @@
+import type { CreateLoopInput, UpdateLoopInput, LoopConfig } from './types.js';
+import { type IntervalParserOptions } from './IntervalParser.js';
+export interface ValidationConstraints {
+    maxPromptLength: number;
+    minPromptLength: number;
+    maxNameLength: number;
+    minNameLength: number;
+    namePattern: RegExp;
+    maxWebhookUrlLength: number;
+    maxMaxRuns: number;
+    validModelTiers: readonly string[];
+}
+export declare const DEFAULT_VALIDATION_CONSTRAINTS: ValidationConstraints;
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+}
+export interface ValidationIssue {
+    field: string;
+    message: string;
+    value?: unknown;
+}
+export declare class LoopValidator {
+    private readonly constraints;
+    private readonly intervalParser;
+    constructor(constraints?: Partial<ValidationConstraints>, intervalParserOptions?: IntervalParserOptions);
+    validateCreateInput(input: CreateLoopInput): void;
+    safeValidateCreateInput(input: CreateLoopInput): ValidationResult;
+    private collectCreateInputErrors;
+    validateUpdateInput(input: UpdateLoopInput): void;
+    safeValidateUpdateInput(input: UpdateLoopInput): ValidationResult;
+    private collectUpdateInputErrors;
+    private validatePromptField;
+    private validateIntervalField;
+    private validateNameField;
+    private validateIdentifierField;
+    private validateMaxRunsField;
+    private validateExpiresField;
+    private validateModelField;
+    private validateOnErrorField;
+    private validateNotifyField;
+    private validateWebhookUrlField;
+    validateConfig(config: Partial<LoopConfig>): void;
+    safeValidateConfig(config: Partial<LoopConfig>): ValidationResult;
+    private collectConfigErrors;
+    validateName(name: string): void;
+    validatePrompt(prompt: string): void;
+    validateInterval(interval: string): void;
+    private throwValidationError;
+}
+export declare function createLoopValidator(constraints?: Partial<ValidationConstraints>, intervalParserOptions?: IntervalParserOptions): LoopValidator;
+export declare function validateCreateInput(input: CreateLoopInput): void;
+export declare function validateUpdateInput(input: UpdateLoopInput): void;
+export declare function validateLoopName(name: string): void;
+export declare function validatePrompt(prompt: string): void;