@flowdot.ai/daemon 1.0.0

package/dist/loop/DaemonIPC.d.ts

@@ -0,0 +1,67 @@
+import { EventEmitter } from 'node:events';
+import type { Logger } from './types.js';
+export type RequestHandler = (method: string, params: Record<string, unknown>) => Promise<unknown>;
+export interface IPCServerOptions {
+    port?: number;
+    host?: string;
+    onRequest?: RequestHandler;
+    logger?: Logger;
+}
+export interface IPCClientOptions {
+    port?: number;
+    host?: string;
+    connectionTimeout?: number;
+    responseTimeout?: number;
+    logger?: Logger;
+}
+export declare class IPCServer extends EventEmitter {
+    private server;
+    private clients;
+    private readonly port;
+    private readonly host;
+    private readonly onRequest;
+    private readonly logger;
+    constructor(options?: IPCServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    broadcast(event: string, data: Record<string, unknown>): void;
+    getClientCount(): number;
+    isRunning(): boolean;
+    private handleConnection;
+    private handleMessage;
+    private defaultHandler;
+    private encodeMessage;
+}
+export declare class IPCClient extends EventEmitter {
+    private socket;
+    private readonly port;
+    private readonly host;
+    private readonly connectionTimeout;
+    private readonly responseTimeout;
+    private readonly logger;
+    private pendingRequests;
+    private requestIdCounter;
+    private buffer;
+    constructor(options?: IPCClientOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    private handleData;
+    private handleMessage;
+    private handleResponse;
+    private handleEvent;
+    private handleDisconnect;
+    private generateRequestId;
+}
+export declare function isDaemonRunning(options?: {
+    port?: number;
+    host?: string;
+}): Promise<boolean>;
+export declare function waitForDaemon(options?: {
+    port?: number;
+    host?: string;
+    timeout?: number;
+    interval?: number;
+}): Promise<void>;
+export declare function daemonRequest<T = unknown>(method: string, params?: Record<string, unknown>, options?: IPCClientOptions): Promise<T>;

package/dist/loop/DaemonIPC.js

@@ -0,0 +1,358 @@
+import { createServer, createConnection } from 'node:net';
+import { EventEmitter } from 'node:events';
+import { DaemonNotRunningError, DaemonCommunicationError, DaemonConnectionError, DaemonAlreadyRunningError, } from './errors.js';
+const MESSAGE_DELIMITER = '\n';
+const DEFAULT_PORT = 47691;
+const DEFAULT_HOST = '127.0.0.1';
+const CONNECTION_TIMEOUT_MS = 5000;
+const RESPONSE_TIMEOUT_MS = 30000;
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class IPCServer extends EventEmitter {
+    server = null;
+    clients = new Set();
+    port;
+    host;
+    onRequest;
+    logger;
+    constructor(options = {}) {
+        super();
+        this.port = options.port ?? DEFAULT_PORT;
+        this.host = options.host ?? DEFAULT_HOST;
+        this.onRequest = options.onRequest ?? this.defaultHandler.bind(this);
+        this.logger = options.logger ?? noopLogger;
+    }
+    async start() {
+        if (this.server) {
+            throw new DaemonAlreadyRunningError(this.port);
+        }
+        return new Promise((resolve, reject) => {
+            this.server = createServer((socket) => this.handleConnection(socket));
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new DaemonAlreadyRunningError(this.port));
+                }
+                else {
+                    reject(new DaemonCommunicationError('server', error.message));
+                }
+            });
+            this.server.listen(this.port, this.host, () => {
+                this.logger.info('LOOP', `IPC server listening on ${this.host}:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server) {
+            return;
+        }
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.server = null;
+                this.logger.info('LOOP', 'IPC server stopped');
+                resolve();
+            });
+        });
+    }
+    broadcast(event, data) {
+        const message = {
+            type: 'event',
+            id: `evt_${Date.now()}`,
+            event,
+            data,
+            timestamp: new Date().toISOString(),
+        };
+        const encoded = this.encodeMessage(message);
+        for (const client of this.clients) {
+            if (!client.destroyed) {
+                client.write(encoded);
+            }
+        }
+    }
+    getClientCount() {
+        return this.clients.size;
+    }
+    isRunning() {
+        return this.server !== null;
+    }
+    handleConnection(socket) {
+        this.logger.debug('LOOP', 'IPC client connected');
+        this.clients.add(socket);
+        let buffer = '';
+        socket.on('data', async (data) => {
+            buffer += data.toString();
+            const lines = buffer.split(MESSAGE_DELIMITER);
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        await this.handleMessage(socket, line);
+                    }
+                    catch (error) {
+                        this.logger.error('LOOP', 'Error handling IPC message', {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+        });
+        socket.on('close', () => {
+            this.logger.debug('LOOP', 'IPC client disconnected');
+            this.clients.delete(socket);
+        });
+        socket.on('error', (error) => {
+            this.logger.error('LOOP', 'IPC socket error', { error: error.message });
+            this.clients.delete(socket);
+        });
+    }
+    async handleMessage(socket, data) {
+        let message;
+        try {
+            message = JSON.parse(data);
+        }
+        catch {
+            this.logger.error('LOOP', 'Invalid IPC message (not JSON)', { data: data.substring(0, 100) });
+            return;
+        }
+        if (message.type !== 'request') {
+            return;
+        }
+        const request = message;
+        this.logger.debug('LOOP', `IPC request: ${request.method}`, { params: request.params });
+        try {
+            const result = await this.onRequest(request.method, request.params ?? {});
+            const response = {
+                type: 'response',
+                id: request.id,
+                requestId: request.id,
+                success: true,
+                payload: result,
+                timestamp: new Date().toISOString(),
+            };
+            socket.write(this.encodeMessage(response));
+        }
+        catch (error) {
+            const response = {
+                type: 'response',
+                id: request.id,
+                requestId: request.id,
+                success: false,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorCode: error instanceof Error && 'code' in error ? error.code : undefined,
+                timestamp: new Date().toISOString(),
+            };
+            socket.write(this.encodeMessage(response));
+        }
+    }
+    async defaultHandler(method, _params) {
+        throw new Error(`Unknown method: ${method}`);
+    }
+    encodeMessage(message) {
+        return JSON.stringify(message) + MESSAGE_DELIMITER;
+    }
+}
+export class IPCClient extends EventEmitter {
+    socket = null;
+    port;
+    host;
+    connectionTimeout;
+    responseTimeout;
+    logger;
+    pendingRequests = new Map();
+    requestIdCounter = 0;
+    buffer = '';
+    constructor(options = {}) {
+        super();
+        this.port = options.port ?? DEFAULT_PORT;
+        this.host = options.host ?? DEFAULT_HOST;
+        this.connectionTimeout = options.connectionTimeout ?? CONNECTION_TIMEOUT_MS;
+        this.responseTimeout = options.responseTimeout ?? RESPONSE_TIMEOUT_MS;
+        this.logger = options.logger ?? noopLogger;
+    }
+    async connect() {
+        if (this.socket) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (this.socket) {
+                    this.socket.destroy();
+                    this.socket = null;
+                }
+                reject(new DaemonConnectionError(this.host, this.port, 'Connection timeout'));
+            }, this.connectionTimeout);
+            this.socket = createConnection({ port: this.port, host: this.host }, () => {
+                clearTimeout(timeout);
+                this.logger.debug('LOOP', 'IPC client connected to daemon');
+                resolve();
+            });
+            this.socket.on('data', (data) => this.handleData(data));
+            this.socket.on('close', () => {
+                this.handleDisconnect();
+            });
+            this.socket.on('error', (error) => {
+                clearTimeout(timeout);
+                this.socket = null;
+                if (error.code === 'ECONNREFUSED') {
+                    reject(new DaemonNotRunningError());
+                }
+                else {
+                    reject(new DaemonConnectionError(this.host, this.port, error.message));
+                }
+            });
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new DaemonCommunicationError('client', 'Connection closed'));
+        }
+        this.pendingRequests.clear();
+    }
+    isConnected() {
+        return this.socket !== null && !this.socket.destroyed;
+    }
+    async request(method, params = {}) {
+        if (!this.socket || this.socket.destroyed) {
+            throw new DaemonNotRunningError();
+        }
+        const id = this.generateRequestId();
+        const request = {
+            type: 'request',
+            id,
+            method,
+            params,
+            timestamp: new Date().toISOString(),
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new DaemonCommunicationError('client', `Request timeout: ${method}`));
+            }, this.responseTimeout);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            const encoded = JSON.stringify(request) + MESSAGE_DELIMITER;
+            this.socket.write(encoded);
+        });
+    }
+    handleData(data) {
+        this.buffer += data.toString();
+        const lines = this.buffer.split(MESSAGE_DELIMITER);
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    this.handleMessage(line);
+                }
+                catch (error) {
+                    this.logger.error('LOOP', 'Error handling IPC message', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    handleMessage(data) {
+        let message;
+        try {
+            message = JSON.parse(data);
+        }
+        catch {
+            this.logger.error('LOOP', 'Invalid IPC message (not JSON)');
+            return;
+        }
+        if (message.type === 'response') {
+            this.handleResponse(message);
+        }
+        else if (message.type === 'event') {
+            this.handleEvent(message);
+        }
+    }
+    handleResponse(response) {
+        const pending = this.pendingRequests.get(response.requestId ?? response.id);
+        if (!pending) {
+            this.logger.warn('LOOP', `Received response for unknown request: ${response.id}`);
+            return;
+        }
+        this.pendingRequests.delete(response.requestId ?? response.id);
+        clearTimeout(pending.timeout);
+        if (response.success) {
+            pending.resolve(response.payload);
+        }
+        else {
+            const error = new DaemonCommunicationError('client', response.errorMessage ?? 'Unknown error');
+            if (response.errorCode) {
+                error.code = response.errorCode;
+            }
+            pending.reject(error);
+        }
+    }
+    handleEvent(event) {
+        this.emit(event.event, event.data);
+    }
+    handleDisconnect() {
+        this.socket = null;
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new DaemonCommunicationError('client', 'Connection closed'));
+        }
+        this.pendingRequests.clear();
+        this.emit('disconnect');
+    }
+    generateRequestId() {
+        return `req_${Date.now()}_${this.requestIdCounter++}`;
+    }
+}
+export async function isDaemonRunning(options) {
+    const client = new IPCClient({
+        port: options?.port ?? DEFAULT_PORT,
+        host: options?.host ?? DEFAULT_HOST,
+        connectionTimeout: 1000,
+    });
+    try {
+        await client.connect();
+        client.disconnect();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function waitForDaemon(options) {
+    const timeout = options?.timeout ?? 10000;
+    const interval = options?.interval ?? 500;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        if (await isDaemonRunning(options)) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new DaemonNotRunningError();
+}
+export async function daemonRequest(method, params = {}, options) {
+    const client = new IPCClient(options);
+    try {
+        await client.connect();
+        const result = await client.request(method, params);
+        return result;
+    }
+    finally {
+        client.disconnect();
+    }
+}

package/dist/loop/IntervalParser.d.ts

@@ -0,0 +1,39 @@
+import type { LoopInterval } from './types.js';
+export interface IntervalParserOptions {
+    minIntervalMs?: number;
+    timezone?: string;
+    currentDate?: Date;
+}
+export interface ParseResult {
+    success: boolean;
+    interval?: LoopInterval;
+    error?: string;
+}
+export declare class IntervalParser {
+    private readonly minIntervalMs;
+    private readonly timezone;
+    constructor(options?: IntervalParserOptions);
+    parse(input: string, currentDate?: Date): LoopInterval;
+    safeParse(input: string, currentDate?: Date): ParseResult;
+    validate(input: string): {
+        valid: boolean;
+        error?: string;
+    };
+    calculateNextRun(interval: LoopInterval, fromDate?: Date): Date;
+    describe(interval: LoopInterval): string;
+    private detectIntervalType;
+    private parseDuration;
+    private parseCron;
+    private getNextCronRun;
+    private estimateCronInterval;
+    private describeCron;
+    private describeDuration;
+}
+export declare function createIntervalParser(options?: IntervalParserOptions): IntervalParser;
+export declare function parseInterval(input: string, currentDate?: Date): LoopInterval;
+export declare function validateInterval(input: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare function isValidInterval(input: string): boolean;
+export declare function calculateNextRun(interval: LoopInterval, fromDate?: Date): Date;

package/dist/loop/IntervalParser.js

@@ -0,0 +1,217 @@
+import msPkg from 'ms';
+import cronParser from 'cron-parser';
+import { InvalidIntervalError, IntervalTooShortError, InvalidCronExpressionError, } from './errors.js';
+function parseDurationString(value) {
+    return msPkg(value);
+}
+const DEFAULT_MIN_INTERVAL_MS = 60 * 1000;
+const CRON_PATTERN = /^[\d*,\-/]+(\s+[\d*,\-/]+){4,5}$/;
+export class IntervalParser {
+    minIntervalMs;
+    timezone;
+    constructor(options = {}) {
+        this.minIntervalMs = options.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+        this.timezone = options.timezone;
+    }
+    parse(input, currentDate = new Date()) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            throw new InvalidIntervalError(input, 'Interval cannot be empty');
+        }
+        const type = this.detectIntervalType(trimmed);
+        if (type === 'cron') {
+            return this.parseCron(trimmed, currentDate);
+        }
+        return this.parseDuration(trimmed, currentDate);
+    }
+    safeParse(input, currentDate = new Date()) {
+        try {
+            const interval = this.parse(input, currentDate);
+            return { success: true, interval };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { success: false, error: message };
+        }
+    }
+    validate(input) {
+        const result = this.safeParse(input);
+        if (result.success) {
+            return { valid: true };
+        }
+        return { valid: false, error: result.error };
+    }
+    calculateNextRun(interval, fromDate = new Date()) {
+        if (interval.type === 'cron' && interval.cronExpression) {
+            return this.getNextCronRun(interval.cronExpression, fromDate);
+        }
+        return new Date(fromDate.getTime() + interval.milliseconds);
+    }
+    describe(interval) {
+        if (interval.type === 'cron') {
+            return this.describeCron(interval.cronExpression);
+        }
+        return this.describeDuration(interval.milliseconds);
+    }
+    detectIntervalType(input) {
+        if (CRON_PATTERN.test(input)) {
+            return 'cron';
+        }
+        if (input.includes(' ') && input.split(/\s+/).length >= 5) {
+            return 'cron';
+        }
+        return 'duration';
+    }
+    parseDuration(input, currentDate) {
+        const milliseconds = parseDurationString(input);
+        if (milliseconds === undefined) {
+            throw new InvalidIntervalError(input, 'Could not parse duration. Use formats like "5m", "1h", "3d", "1w"');
+        }
+        if (typeof milliseconds !== 'number' || isNaN(milliseconds)) {
+            throw new InvalidIntervalError(input, 'Duration parsing resulted in invalid value');
+        }
+        if (milliseconds <= 0) {
+            throw new InvalidIntervalError(input, 'Duration must be positive');
+        }
+        if (milliseconds < this.minIntervalMs) {
+            throw new IntervalTooShortError(input, milliseconds, this.minIntervalMs);
+        }
+        const nextRunAt = new Date(currentDate.getTime() + milliseconds);
+        return {
+            type: 'duration',
+            raw: input,
+            milliseconds,
+            cronExpression: null,
+            nextRunAt,
+        };
+    }
+    parseCron(input, currentDate) {
+        try {
+            const options = {
+                currentDate,
+            };
+            if (this.timezone) {
+                options.tz = this.timezone;
+            }
+            const parsed = cronParser.parseExpression(input, options);
+            const nextRunAt = parsed.next().toDate();
+            const milliseconds = this.estimateCronInterval(input, currentDate);
+            if (milliseconds < this.minIntervalMs) {
+                throw new IntervalTooShortError(input, milliseconds, this.minIntervalMs);
+            }
+            return {
+                type: 'cron',
+                raw: input,
+                milliseconds,
+                cronExpression: input,
+                nextRunAt,
+            };
+        }
+        catch (error) {
+            if (error instanceof IntervalTooShortError) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new InvalidCronExpressionError(input, message);
+        }
+    }
+    getNextCronRun(expression, fromDate) {
+        const options = {
+            currentDate: fromDate,
+        };
+        if (this.timezone) {
+            options.tz = this.timezone;
+        }
+        const parsed = cronParser.parseExpression(expression, options);
+        return parsed.next().toDate();
+    }
+    estimateCronInterval(expression, currentDate) {
+        try {
+            const options = {
+                currentDate,
+            };
+            if (this.timezone) {
+                options.tz = this.timezone;
+            }
+            const parsed = cronParser.parseExpression(expression, options);
+            const runs = [];
+            for (let i = 0; i < 5; i++) {
+                runs.push(parsed.next().toDate());
+            }
+            let totalInterval = 0;
+            for (let i = 1; i < runs.length; i++) {
+                totalInterval += runs[i].getTime() - runs[i - 1].getTime();
+            }
+            return Math.round(totalInterval / (runs.length - 1));
+        }
+        catch {
+            return 60 * 1000;
+        }
+    }
+    describeCron(expression) {
+        const parts = expression.split(/\s+/);
+        if (parts.length < 5) {
+            return `cron: ${expression}`;
+        }
+        const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+        if (minute === '0' && hour === '*' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+            return 'Every hour at minute 0';
+        }
+        if (minute !== '*' && hour === '*' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+            return `Every hour at minute ${minute}`;
+        }
+        if (minute !== '*' && hour !== '*' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+            return `Daily at ${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
+        }
+        if (dayOfWeek !== '*' && dayOfMonth === '*') {
+            const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+            const dayNum = parseInt(dayOfWeek, 10);
+            if (dayNum >= 0 && dayNum <= 6) {
+                return `Every ${days[dayNum]} at ${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
+            }
+        }
+        return `cron: ${expression}`;
+    }
+    describeDuration(milliseconds) {
+        const seconds = Math.floor(milliseconds / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        const weeks = Math.floor(days / 7);
+        if (weeks > 0 && days % 7 === 0) {
+            return weeks === 1 ? 'Every week' : `Every ${weeks} weeks`;
+        }
+        if (days > 0 && hours % 24 === 0) {
+            return days === 1 ? 'Every day' : `Every ${days} days`;
+        }
+        if (hours > 0 && minutes % 60 === 0) {
+            return hours === 1 ? 'Every hour' : `Every ${hours} hours`;
+        }
+        if (minutes > 0 && seconds % 60 === 0) {
+            return minutes === 1 ? 'Every minute' : `Every ${minutes} minutes`;
+        }
+        if (seconds > 0) {
+            return seconds === 1 ? 'Every second' : `Every ${seconds} seconds`;
+        }
+        return `Every ${milliseconds}ms`;
+    }
+}
+export function createIntervalParser(options) {
+    return new IntervalParser(options);
+}
+export function parseInterval(input, currentDate) {
+    const parser = new IntervalParser();
+    return parser.parse(input, currentDate);
+}
+export function validateInterval(input) {
+    const parser = new IntervalParser();
+    return parser.validate(input);
+}
+export function isValidInterval(input) {
+    const result = validateInterval(input);
+    return result.valid;
+}
+export function calculateNextRun(interval, fromDate = new Date()) {
+    const parser = new IntervalParser();
+    return parser.calculateNextRun(interval, fromDate);
+}