@flowdot.ai/daemon 1.0.0

package/dist/loop/LoopValidator.js

@@ -0,0 +1,603 @@
+import msPkg from 'ms';
+import { isNotifyMethod, isOnErrorAction, } from './types.js';
+import { ValidationError, InvalidPromptError, InvalidNameError, InvalidOptionsError, InvalidIntervalError, ConfigError, } from './errors.js';
+import { IntervalParser } from './IntervalParser.js';
+function parseDurationString(value) {
+    return msPkg(value);
+}
+export const DEFAULT_VALIDATION_CONSTRAINTS = {
+    maxPromptLength: 10000,
+    minPromptLength: 1,
+    maxNameLength: 64,
+    minNameLength: 1,
+    namePattern: /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/,
+    maxWebhookUrlLength: 2048,
+    maxMaxRuns: 1000000,
+    validModelTiers: ['simple', 'capable', 'complex'],
+};
+export class LoopValidator {
+    constraints;
+    intervalParser;
+    constructor(constraints = {}, intervalParserOptions = {}) {
+        this.constraints = { ...DEFAULT_VALIDATION_CONSTRAINTS, ...constraints };
+        this.intervalParser = new IntervalParser(intervalParserOptions);
+    }
+    validateCreateInput(input) {
+        const errors = this.collectCreateInputErrors(input);
+        if (errors.length > 0) {
+            const first = errors[0];
+            this.throwValidationError(first);
+        }
+    }
+    safeValidateCreateInput(input) {
+        const errors = this.collectCreateInputErrors(input);
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    collectCreateInputErrors(input) {
+        const errors = [];
+        const promptError = this.validatePromptField(input.prompt);
+        if (promptError)
+            errors.push(promptError);
+        const intervalError = this.validateIntervalField(input.interval);
+        if (intervalError)
+            errors.push(intervalError);
+        if (input.name !== undefined) {
+            const nameError = this.validateNameField(input.name);
+            if (nameError)
+                errors.push(nameError);
+        }
+        if (input.maxRuns !== undefined) {
+            const maxRunsError = this.validateMaxRunsField(input.maxRuns);
+            if (maxRunsError)
+                errors.push(maxRunsError);
+        }
+        if (input.expires !== undefined) {
+            const expiresError = this.validateExpiresField(input.expires);
+            if (expiresError)
+                errors.push(expiresError);
+        }
+        if (input.model !== undefined) {
+            const modelError = this.validateModelField(input.model);
+            if (modelError)
+                errors.push(modelError);
+        }
+        if (input.onError !== undefined) {
+            const onErrorError = this.validateOnErrorField(input.onError);
+            if (onErrorError)
+                errors.push(onErrorError);
+        }
+        if (input.notify !== undefined) {
+            const notifyError = this.validateNotifyField(input.notify);
+            if (notifyError)
+                errors.push(notifyError);
+        }
+        if (input.webhookUrl !== undefined) {
+            const webhookError = this.validateWebhookUrlField(input.webhookUrl);
+            if (webhookError)
+                errors.push(webhookError);
+        }
+        if (input.notify === 'webhook' && !input.webhookUrl) {
+            errors.push({
+                field: 'webhookUrl',
+                message: 'Webhook URL is required when notify is set to "webhook"',
+                value: undefined,
+            });
+        }
+        return errors;
+    }
+    validateUpdateInput(input) {
+        const errors = this.collectUpdateInputErrors(input);
+        if (errors.length > 0) {
+            const first = errors[0];
+            this.throwValidationError(first);
+        }
+    }
+    safeValidateUpdateInput(input) {
+        const errors = this.collectUpdateInputErrors(input);
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    collectUpdateInputErrors(input) {
+        const errors = [];
+        const identifierError = this.validateIdentifierField(input.identifier);
+        if (identifierError)
+            errors.push(identifierError);
+        if (input.name !== undefined) {
+            const nameError = this.validateNameField(input.name);
+            if (nameError)
+                errors.push(nameError);
+        }
+        if (input.interval !== undefined) {
+            const intervalError = this.validateIntervalField(input.interval);
+            if (intervalError)
+                errors.push(intervalError);
+        }
+        if (input.model !== undefined) {
+            const modelError = this.validateModelField(input.model);
+            if (modelError)
+                errors.push(modelError);
+        }
+        if (input.onError !== undefined) {
+            const onErrorError = this.validateOnErrorField(input.onError);
+            if (onErrorError)
+                errors.push(onErrorError);
+        }
+        if (input.notify !== undefined) {
+            const notifyError = this.validateNotifyField(input.notify);
+            if (notifyError)
+                errors.push(notifyError);
+        }
+        return errors;
+    }
+    validatePromptField(prompt) {
+        if (typeof prompt !== 'string') {
+            return {
+                field: 'prompt',
+                message: 'Prompt must be a string',
+                value: prompt,
+            };
+        }
+        const trimmed = prompt.trim();
+        if (trimmed.length < this.constraints.minPromptLength) {
+            return {
+                field: 'prompt',
+                message: 'Prompt cannot be empty',
+                value: prompt,
+            };
+        }
+        if (trimmed.length > this.constraints.maxPromptLength) {
+            return {
+                field: 'prompt',
+                message: `Prompt exceeds maximum length of ${this.constraints.maxPromptLength} characters`,
+                value: `(${trimmed.length} characters)`,
+            };
+        }
+        return null;
+    }
+    validateIntervalField(interval) {
+        if (typeof interval !== 'string') {
+            return {
+                field: 'interval',
+                message: 'Interval must be a string',
+                value: interval,
+            };
+        }
+        const trimmed = interval.trim();
+        if (!trimmed) {
+            return {
+                field: 'interval',
+                message: 'Interval cannot be empty',
+                value: interval,
+            };
+        }
+        const result = this.intervalParser.validate(trimmed);
+        if (!result.valid) {
+            return {
+                field: 'interval',
+                message: result.error ?? 'Invalid interval format',
+                value: interval,
+            };
+        }
+        return null;
+    }
+    validateNameField(name) {
+        if (typeof name !== 'string') {
+            return {
+                field: 'name',
+                message: 'Name must be a string',
+                value: name,
+            };
+        }
+        const trimmed = name.trim();
+        if (trimmed.length < this.constraints.minNameLength) {
+            return {
+                field: 'name',
+                message: `Name must be at least ${this.constraints.minNameLength} character(s)`,
+                value: name,
+            };
+        }
+        if (trimmed.length > this.constraints.maxNameLength) {
+            return {
+                field: 'name',
+                message: `Name exceeds maximum length of ${this.constraints.maxNameLength} characters`,
+                value: name,
+            };
+        }
+        if (!this.constraints.namePattern.test(trimmed)) {
+            return {
+                field: 'name',
+                message: 'Name must start with a letter or number and contain only letters, numbers, dashes, and underscores',
+                value: name,
+            };
+        }
+        return null;
+    }
+    validateIdentifierField(identifier) {
+        if (typeof identifier !== 'string') {
+            return {
+                field: 'identifier',
+                message: 'Identifier must be a string',
+                value: identifier,
+            };
+        }
+        const trimmed = identifier.trim();
+        if (!trimmed) {
+            return {
+                field: 'identifier',
+                message: 'Identifier cannot be empty',
+                value: identifier,
+            };
+        }
+        return null;
+    }
+    validateMaxRunsField(maxRuns) {
+        if (typeof maxRuns !== 'number') {
+            return {
+                field: 'maxRuns',
+                message: 'maxRuns must be a number',
+                value: maxRuns,
+            };
+        }
+        if (!Number.isInteger(maxRuns)) {
+            return {
+                field: 'maxRuns',
+                message: 'maxRuns must be an integer',
+                value: maxRuns,
+            };
+        }
+        if (maxRuns < 1) {
+            return {
+                field: 'maxRuns',
+                message: 'maxRuns must be at least 1',
+                value: maxRuns,
+            };
+        }
+        if (maxRuns > this.constraints.maxMaxRuns) {
+            return {
+                field: 'maxRuns',
+                message: `maxRuns cannot exceed ${this.constraints.maxMaxRuns}`,
+                value: maxRuns,
+            };
+        }
+        return null;
+    }
+    validateExpiresField(expires) {
+        if (typeof expires !== 'string') {
+            return {
+                field: 'expires',
+                message: 'expires must be a string',
+                value: expires,
+            };
+        }
+        const trimmed = expires.trim();
+        if (!trimmed) {
+            return {
+                field: 'expires',
+                message: 'expires cannot be empty',
+                value: expires,
+            };
+        }
+        const milliseconds = parseDurationString(trimmed);
+        if (milliseconds === undefined || typeof milliseconds !== 'number' || isNaN(milliseconds)) {
+            return {
+                field: 'expires',
+                message: 'Invalid expiration duration. Use formats like "3d", "1w", "24h"',
+                value: expires,
+            };
+        }
+        if (milliseconds <= 0) {
+            return {
+                field: 'expires',
+                message: 'Expiration duration must be positive',
+                value: expires,
+            };
+        }
+        return null;
+    }
+    validateModelField(model) {
+        if (typeof model !== 'string') {
+            return {
+                field: 'model',
+                message: 'model must be a string',
+                value: model,
+            };
+        }
+        if (!this.constraints.validModelTiers.includes(model)) {
+            return {
+                field: 'model',
+                message: `Invalid model tier. Must be one of: ${this.constraints.validModelTiers.join(', ')}`,
+                value: model,
+            };
+        }
+        return null;
+    }
+    validateOnErrorField(onError) {
+        if (typeof onError !== 'string') {
+            return {
+                field: 'onError',
+                message: 'onError must be a string',
+                value: onError,
+            };
+        }
+        if (!isOnErrorAction(onError)) {
+            return {
+                field: 'onError',
+                message: 'Invalid onError action. Must be one of: continue, pause, stop',
+                value: onError,
+            };
+        }
+        return null;
+    }
+    validateNotifyField(notify) {
+        if (typeof notify !== 'string') {
+            return {
+                field: 'notify',
+                message: 'notify must be a string',
+                value: notify,
+            };
+        }
+        if (!isNotifyMethod(notify)) {
+            return {
+                field: 'notify',
+                message: 'Invalid notify method. Must be one of: none, terminal, webhook, slack',
+                value: notify,
+            };
+        }
+        return null;
+    }
+    validateWebhookUrlField(webhookUrl) {
+        if (typeof webhookUrl !== 'string') {
+            return {
+                field: 'webhookUrl',
+                message: 'webhookUrl must be a string',
+                value: webhookUrl,
+            };
+        }
+        const trimmed = webhookUrl.trim();
+        if (!trimmed) {
+            return {
+                field: 'webhookUrl',
+                message: 'webhookUrl cannot be empty',
+                value: webhookUrl,
+            };
+        }
+        if (trimmed.length > this.constraints.maxWebhookUrlLength) {
+            return {
+                field: 'webhookUrl',
+                message: `webhookUrl exceeds maximum length of ${this.constraints.maxWebhookUrlLength} characters`,
+                value: webhookUrl,
+            };
+        }
+        try {
+            const url = new URL(trimmed);
+            if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                return {
+                    field: 'webhookUrl',
+                    message: 'webhookUrl must use http or https protocol',
+                    value: webhookUrl,
+                };
+            }
+        }
+        catch {
+            return {
+                field: 'webhookUrl',
+                message: 'webhookUrl must be a valid URL',
+                value: webhookUrl,
+            };
+        }
+        return null;
+    }
+    validateConfig(config) {
+        const errors = this.collectConfigErrors(config);
+        if (errors.length > 0) {
+            const first = errors[0];
+            throw new ConfigError(first.field, first.message);
+        }
+    }
+    safeValidateConfig(config) {
+        const errors = this.collectConfigErrors(config);
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    collectConfigErrors(config) {
+        const errors = [];
+        if (config.defaultExpiration !== undefined) {
+            const msValue = parseDurationString(config.defaultExpiration);
+            if (msValue === undefined || typeof msValue !== 'number' || msValue <= 0) {
+                errors.push({
+                    field: 'defaultExpiration',
+                    message: 'Must be a valid positive duration (e.g., "3d", "1w")',
+                    value: config.defaultExpiration,
+                });
+            }
+        }
+        if (config.defaultOnError !== undefined && !isOnErrorAction(config.defaultOnError)) {
+            errors.push({
+                field: 'defaultOnError',
+                message: 'Must be one of: continue, pause, stop',
+                value: config.defaultOnError,
+            });
+        }
+        if (config.defaultNotify !== undefined && !isNotifyMethod(config.defaultNotify)) {
+            errors.push({
+                field: 'defaultNotify',
+                message: 'Must be one of: none, terminal, webhook, slack',
+                value: config.defaultNotify,
+            });
+        }
+        if (config.maxConcurrentLoops !== undefined) {
+            if (typeof config.maxConcurrentLoops !== 'number' ||
+                !Number.isInteger(config.maxConcurrentLoops) ||
+                config.maxConcurrentLoops < 1) {
+                errors.push({
+                    field: 'maxConcurrentLoops',
+                    message: 'Must be a positive integer',
+                    value: config.maxConcurrentLoops,
+                });
+            }
+        }
+        if (config.minInterval !== undefined) {
+            const msValue = parseDurationString(config.minInterval);
+            if (msValue === undefined || typeof msValue !== 'number' || msValue <= 0) {
+                errors.push({
+                    field: 'minInterval',
+                    message: 'Must be a valid positive duration (e.g., "1m", "30s")',
+                    value: config.minInterval,
+                });
+            }
+        }
+        if (config.maxRunDuration !== undefined) {
+            const msValue = parseDurationString(config.maxRunDuration);
+            if (msValue === undefined || typeof msValue !== 'number' || msValue <= 0) {
+                errors.push({
+                    field: 'maxRunDuration',
+                    message: 'Must be a valid positive duration (e.g., "30m", "1h")',
+                    value: config.maxRunDuration,
+                });
+            }
+        }
+        if (config.errorThreshold !== undefined) {
+            if (typeof config.errorThreshold !== 'number' ||
+                !Number.isInteger(config.errorThreshold) ||
+                config.errorThreshold < 1) {
+                errors.push({
+                    field: 'errorThreshold',
+                    message: 'Must be a positive integer',
+                    value: config.errorThreshold,
+                });
+            }
+        }
+        if (config.daemon !== undefined) {
+            if (config.daemon.port !== undefined) {
+                if (typeof config.daemon.port !== 'number' ||
+                    !Number.isInteger(config.daemon.port) ||
+                    config.daemon.port < 1 ||
+                    config.daemon.port > 65535) {
+                    errors.push({
+                        field: 'daemon.port',
+                        message: 'Must be a valid port number (1-65535)',
+                        value: config.daemon.port,
+                    });
+                }
+            }
+            if (config.daemon.logLevel !== undefined) {
+                const validLevels = ['debug', 'info', 'warn', 'error'];
+                if (!validLevels.includes(config.daemon.logLevel)) {
+                    errors.push({
+                        field: 'daemon.logLevel',
+                        message: `Must be one of: ${validLevels.join(', ')}`,
+                        value: config.daemon.logLevel,
+                    });
+                }
+            }
+            if (config.daemon.healthCheckInterval !== undefined) {
+                if (typeof config.daemon.healthCheckInterval !== 'number' ||
+                    config.daemon.healthCheckInterval < 1000) {
+                    errors.push({
+                        field: 'daemon.healthCheckInterval',
+                        message: 'Must be at least 1000 milliseconds',
+                        value: config.daemon.healthCheckInterval,
+                    });
+                }
+            }
+        }
+        if (config.webhooks !== undefined) {
+            if (config.webhooks.defaultUrl !== undefined && config.webhooks.defaultUrl !== null) {
+                const urlError = this.validateWebhookUrlField(config.webhooks.defaultUrl);
+                if (urlError) {
+                    errors.push({
+                        field: 'webhooks.defaultUrl',
+                        message: urlError.message,
+                        value: config.webhooks.defaultUrl,
+                    });
+                }
+            }
+            if (config.webhooks.timeout !== undefined) {
+                if (typeof config.webhooks.timeout !== 'number' ||
+                    config.webhooks.timeout < 1000) {
+                    errors.push({
+                        field: 'webhooks.timeout',
+                        message: 'Must be at least 1000 milliseconds',
+                        value: config.webhooks.timeout,
+                    });
+                }
+            }
+            if (config.webhooks.retries !== undefined) {
+                if (typeof config.webhooks.retries !== 'number' ||
+                    !Number.isInteger(config.webhooks.retries) ||
+                    config.webhooks.retries < 0) {
+                    errors.push({
+                        field: 'webhooks.retries',
+                        message: 'Must be a non-negative integer',
+                        value: config.webhooks.retries,
+                    });
+                }
+            }
+        }
+        return errors;
+    }
+    validateName(name) {
+        const error = this.validateNameField(name);
+        if (error) {
+            throw new InvalidNameError(name, error.message);
+        }
+    }
+    validatePrompt(prompt) {
+        const error = this.validatePromptField(prompt);
+        if (error) {
+            throw new InvalidPromptError(error.message);
+        }
+    }
+    validateInterval(interval) {
+        const error = this.validateIntervalField(interval);
+        if (error) {
+            throw new InvalidIntervalError(interval, error.message);
+        }
+    }
+    throwValidationError(issue) {
+        switch (issue.field) {
+            case 'prompt':
+                throw new InvalidPromptError(issue.message);
+            case 'name':
+                throw new InvalidNameError(String(issue.value ?? ''), issue.message);
+            case 'interval':
+                throw new InvalidIntervalError(String(issue.value ?? ''), issue.message);
+            case 'model':
+            case 'onError':
+            case 'notify':
+            case 'webhookUrl':
+            case 'maxRuns':
+            case 'expires':
+            case 'quiet':
+                throw new InvalidOptionsError(issue.field, issue.value, issue.message);
+            default:
+                throw new ValidationError(issue.field, issue.value, issue.message);
+        }
+    }
+}
+export function createLoopValidator(constraints, intervalParserOptions) {
+    return new LoopValidator(constraints, intervalParserOptions);
+}
+export function validateCreateInput(input) {
+    const validator = new LoopValidator();
+    validator.validateCreateInput(input);
+}
+export function validateUpdateInput(input) {
+    const validator = new LoopValidator();
+    validator.validateUpdateInput(input);
+}
+export function validateLoopName(name) {
+    const validator = new LoopValidator();
+    validator.validateName(name);
+}
+export function validatePrompt(prompt) {
+    const validator = new LoopValidator();
+    validator.validatePrompt(prompt);
+}