@flowdot.ai/daemon 1.0.0

package/dist/loop/notifications/SlackNotifier.js

@@ -0,0 +1,203 @@
+import { BaseNotifier } from './Notifier.js';
+import { SlackError } from '../errors.js';
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_RETRIES = 2;
+const RETRY_DELAY_MS = 1000;
+const MAX_BLOCK_TEXT_LENGTH = 3000;
+export class SlackNotifier extends BaseNotifier {
+    type = 'slack';
+    webhookUrl;
+    timeout;
+    retries;
+    channel;
+    username;
+    iconEmoji;
+    constructor(options) {
+        super({ logger: options.logger });
+        if (!options.webhookUrl) {
+            throw new SlackError('Slack webhook URL is required');
+        }
+        try {
+            const url = new URL(options.webhookUrl);
+            if (!url.hostname.includes('slack.com') && !url.hostname.includes('hooks.slack.com')) {
+                this.logger.warn('LOOP', 'Slack webhook URL does not appear to be a Slack domain', {
+                    hostname: url.hostname,
+                });
+            }
+        }
+        catch {
+            throw new SlackError('Invalid Slack webhook URL format');
+        }
+        this.webhookUrl = options.webhookUrl;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.retries = options.retries ?? DEFAULT_RETRIES;
+        this.channel = options.channel;
+        this.username = options.username ?? 'FlowDot Loop';
+        this.iconEmoji = options.iconEmoji ?? ':robot_face:';
+    }
+    async send(payload) {
+        const slackPayload = this.buildPayload(payload);
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.retries; attempt++) {
+            try {
+                await this.sendRequest(slackPayload);
+                this.logNotification(payload, true);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.retries) {
+                    this.logger.debug('LOOP', `Slack attempt ${attempt + 1} failed, retrying...`, {
+                        error: lastError.message,
+                    });
+                    await this.delay(RETRY_DELAY_MS);
+                }
+            }
+        }
+        this.handleError(lastError ?? new Error('Unknown Slack error'), payload);
+    }
+    buildPayload(notification) {
+        const title = this.formatTitle(notification);
+        const blocks = [
+            {
+                type: 'header',
+                text: {
+                    type: 'plain_text',
+                    text: title,
+                    emoji: true,
+                },
+            },
+        ];
+        if (notification.message) {
+            const truncatedMessage = this.truncateForSlack(notification.message);
+            blocks.push({
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: truncatedMessage,
+                },
+            });
+        }
+        if (notification.error) {
+            blocks.push({
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `:warning: *Error:*\n\`\`\`${this.truncateForSlack(notification.error, 500)}\`\`\``,
+                },
+            });
+        }
+        const contextFields = [
+            {
+                type: 'mrkdwn',
+                text: `*Loop:* ${notification.loopName ?? notification.loopId.substring(0, 8)}`,
+            },
+            {
+                type: 'mrkdwn',
+                text: `*Time:* ${notification.timestamp.toLocaleString()}`,
+            },
+        ];
+        if (notification.runId) {
+            contextFields.push({
+                type: 'mrkdwn',
+                text: `*Run:* ${notification.runId.substring(0, 8)}`,
+            });
+        }
+        if (notification.status) {
+            const statusEmoji = this.getStatusEmoji(notification.status);
+            contextFields.push({
+                type: 'mrkdwn',
+                text: `*Status:* ${statusEmoji} ${notification.status}`,
+            });
+        }
+        blocks.push({
+            type: 'section',
+            fields: contextFields,
+        });
+        blocks.push({ type: 'divider' });
+        const payload = {
+            text: title,
+            blocks,
+            username: this.username,
+            icon_emoji: this.iconEmoji,
+        };
+        if (this.channel) {
+            payload.channel = this.channel;
+        }
+        return payload;
+    }
+    async sendRequest(payload) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(this.webhookUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            const responseText = await response.text();
+            if (!response.ok) {
+                throw new SlackError(`HTTP ${response.status}: ${responseText || response.statusText}`);
+            }
+            if (responseText !== 'ok' && responseText.startsWith('{')) {
+                let errorResponse = null;
+                try {
+                    errorResponse = JSON.parse(responseText);
+                }
+                catch {
+                }
+                if (errorResponse?.error) {
+                    throw new SlackError(`Slack API error: ${errorResponse.error}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof SlackError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new SlackError(`Request timeout after ${this.timeout}ms`);
+            }
+            throw new SlackError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    getStatusColor(status) {
+        switch (status) {
+            case 'success':
+                return '#36a64f';
+            case 'error':
+                return '#e01e5a';
+            case 'running':
+                return '#2eb886';
+            default:
+                return '#439fe0';
+        }
+    }
+    getStatusEmoji(status) {
+        switch (status) {
+            case 'success':
+                return ':white_check_mark:';
+            case 'error':
+                return ':x:';
+            case 'running':
+                return ':arrows_counterclockwise:';
+            default:
+                return ':information_source:';
+        }
+    }
+    truncateForSlack(text, maxLength = MAX_BLOCK_TEXT_LENGTH) {
+        if (text.length <= maxLength) {
+            return text;
+        }
+        return text.substring(0, maxLength - 3) + '...';
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/loop/notifications/TerminalNotifier.d.ts

@@ -0,0 +1,18 @@
+import type { NotifyMethod, NotificationPayload, Logger } from '../types.js';
+import { BaseNotifier } from './Notifier.js';
+export interface TerminalNotifierOptions {
+    sound?: boolean;
+    timeout?: number;
+    logger?: Logger;
+}
+export declare class TerminalNotifier extends BaseNotifier {
+    readonly type: NotifyMethod;
+    private notifier;
+    private readonly sound;
+    private readonly timeout;
+    constructor(options?: TerminalNotifierOptions);
+    send(payload: NotificationPayload): Promise<void>;
+    private getNotifier;
+    private sendNotification;
+    protected formatMessage(payload: NotificationPayload): string;
+}

package/dist/loop/notifications/TerminalNotifier.js

@@ -0,0 +1,72 @@
+import { BaseNotifier } from './Notifier.js';
+export class TerminalNotifier extends BaseNotifier {
+    type = 'terminal';
+    notifier = null;
+    sound;
+    timeout;
+    constructor(options = {}) {
+        super({ logger: options.logger });
+        this.sound = options.sound ?? true;
+        this.timeout = options.timeout ?? 10;
+    }
+    async send(payload) {
+        try {
+            const notifier = await this.getNotifier();
+            const title = this.formatTitle(payload);
+            const message = this.formatMessage(payload);
+            await this.sendNotification(notifier, {
+                title,
+                message,
+                sound: this.sound,
+                timeout: this.timeout,
+                wait: false,
+            });
+            this.logNotification(payload, true);
+        }
+        catch (error) {
+            this.handleError(error, payload);
+        }
+    }
+    async getNotifier() {
+        if (this.notifier) {
+            return this.notifier;
+        }
+        try {
+            const nodeNotifier = await import('node-notifier');
+            this.notifier = nodeNotifier.default || nodeNotifier;
+            return this.notifier;
+        }
+        catch {
+            throw new Error('node-notifier is required for terminal notifications. ' +
+                'Install it with: npm install node-notifier');
+        }
+    }
+    sendNotification(notifier, options) {
+        return new Promise((resolve, reject) => {
+            notifier.notify(options, (err, _response) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    formatMessage(payload) {
+        const parts = [];
+        if (payload.message) {
+            const maxLength = 200;
+            if (payload.message.length > maxLength) {
+                parts.push(payload.message.substring(0, maxLength - 3) + '...');
+            }
+            else {
+                parts.push(payload.message);
+            }
+        }
+        if (payload.error) {
+            parts.push(`\nError occurred`);
+        }
+        return parts.join('');
+    }
+}

package/dist/loop/notifications/WebhookNotifier.d.ts

@@ -0,0 +1,24 @@
+import type { NotifyMethod, NotificationPayload, LoopWebhookConfig, Logger } from '../types.js';
+import { BaseNotifier } from './Notifier.js';
+export interface WebhookNotifierOptions {
+    url: string;
+    timeout?: number;
+    retries?: number;
+    headers?: Record<string, string>;
+    includeErrorDetails?: boolean;
+    logger?: Logger;
+}
+export declare class WebhookNotifier extends BaseNotifier {
+    readonly type: NotifyMethod;
+    private readonly url;
+    private readonly timeout;
+    private readonly retries;
+    private readonly headers;
+    private readonly includeErrorDetails;
+    constructor(options: WebhookNotifierOptions);
+    static fromConfig(config: LoopWebhookConfig, urlOverride?: string | null, logger?: Logger): WebhookNotifier | null;
+    send(payload: NotificationPayload): Promise<void>;
+    private buildPayload;
+    private sendRequest;
+    private delay;
+}

package/dist/loop/notifications/WebhookNotifier.js

@@ -0,0 +1,123 @@
+import { BaseNotifier } from './Notifier.js';
+import { WebhookError } from '../errors.js';
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_RETRIES = 2;
+const RETRY_DELAY_MS = 1000;
+export class WebhookNotifier extends BaseNotifier {
+    type = 'webhook';
+    url;
+    timeout;
+    retries;
+    headers;
+    includeErrorDetails;
+    constructor(options) {
+        super({ logger: options.logger });
+        if (!options.url) {
+            throw new WebhookError('', null, 'Webhook URL is required');
+        }
+        try {
+            new URL(options.url);
+        }
+        catch {
+            throw new WebhookError(options.url, null, 'Invalid webhook URL format');
+        }
+        this.url = options.url;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.retries = options.retries ?? DEFAULT_RETRIES;
+        this.headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'FlowDot-Daemon/1.0',
+            ...options.headers,
+        };
+        this.includeErrorDetails = options.includeErrorDetails ?? true;
+    }
+    static fromConfig(config, urlOverride, logger) {
+        const url = urlOverride ?? config.defaultUrl;
+        if (!url) {
+            return null;
+        }
+        return new WebhookNotifier({
+            url,
+            timeout: config.timeout,
+            retries: config.retries,
+            logger,
+        });
+    }
+    async send(payload) {
+        const webhookPayload = this.buildPayload(payload);
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.retries; attempt++) {
+            try {
+                await this.sendRequest(webhookPayload);
+                this.logNotification(payload, true);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.retries) {
+                    this.logger.debug('LOOP', `Webhook attempt ${attempt + 1} failed, retrying...`, {
+                        url: this.url,
+                        error: lastError.message,
+                    });
+                    await this.delay(RETRY_DELAY_MS);
+                }
+            }
+        }
+        this.handleError(lastError ?? new Error('Unknown webhook error'), payload);
+    }
+    buildPayload(notification) {
+        const payload = {
+            event: 'loop_notification',
+            timestamp: notification.timestamp.toISOString(),
+            loop: {
+                id: notification.loopId,
+                name: notification.loopName,
+            },
+            notification: {
+                title: this.formatTitle(notification),
+                message: notification.message,
+                status: notification.status,
+            },
+        };
+        if (notification.runId) {
+            payload.run = {
+                id: notification.runId,
+                status: notification.status,
+            };
+        }
+        if (this.includeErrorDetails && notification.error) {
+            payload.notification.error = notification.error;
+        }
+        return payload;
+    }
+    async sendRequest(payload) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new WebhookError(this.url, response.status, `HTTP ${response.status}: ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof WebhookError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new WebhookError(this.url, null, `Request timeout after ${this.timeout}ms`);
+            }
+            throw new WebhookError(this.url, null, error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/loop/notifications/index.d.ts

@@ -0,0 +1,24 @@
+import type { NotifyMethod, Notifier, LoopWebhookConfig, Logger } from '../types.js';
+import { BaseNotifier, NullNotifier, MAX_MESSAGE_LENGTH, MAX_TITLE_LENGTH, type NotifierConfig } from './Notifier.js';
+import { TerminalNotifier, type TerminalNotifierOptions } from './TerminalNotifier.js';
+import { WebhookNotifier, type WebhookNotifierOptions } from './WebhookNotifier.js';
+import { SlackNotifier, type SlackNotifierOptions } from './SlackNotifier.js';
+export { BaseNotifier, NullNotifier, MAX_MESSAGE_LENGTH, MAX_TITLE_LENGTH, type NotifierConfig, };
+export { TerminalNotifier, type TerminalNotifierOptions };
+export { WebhookNotifier, type WebhookNotifierOptions, };
+export { SlackNotifier, type SlackNotifierOptions, };
+export interface NotifierFactoryConfig {
+    webhooks?: LoopWebhookConfig;
+    webhookUrl?: string | null;
+    slackWebhookUrl?: string | null;
+    terminal?: {
+        sound?: boolean;
+        timeout?: number;
+    };
+    logger?: Logger;
+}
+export declare function createNotifier(method: NotifyMethod, config?: NotifierFactoryConfig): Promise<Notifier>;
+export declare function createNotifierSync(method: Exclude<NotifyMethod, 'terminal'>, config?: NotifierFactoryConfig): Notifier;
+export declare function createNotifiers(methods: NotifyMethod[], config?: NotifierFactoryConfig): Promise<Notifier[]>;
+export declare function isValidNotifyMethod(method: string): method is NotifyMethod;
+export declare function getAvailableNotifyMethods(): NotifyMethod[];

package/dist/loop/notifications/index.js

@@ -0,0 +1,109 @@
+import { BaseNotifier, NullNotifier, MAX_MESSAGE_LENGTH, MAX_TITLE_LENGTH, } from './Notifier.js';
+import { TerminalNotifier } from './TerminalNotifier.js';
+import { WebhookNotifier, } from './WebhookNotifier.js';
+import { SlackNotifier, } from './SlackNotifier.js';
+export { BaseNotifier, NullNotifier, MAX_MESSAGE_LENGTH, MAX_TITLE_LENGTH, };
+export { TerminalNotifier };
+export { WebhookNotifier, };
+export { SlackNotifier, };
+let TerminalNotifierClass = null;
+async function getTerminalNotifierClass() {
+    if (TerminalNotifierClass) {
+        return TerminalNotifierClass;
+    }
+    const module = await import('./TerminalNotifier.js');
+    TerminalNotifierClass = module.TerminalNotifier;
+    return TerminalNotifierClass;
+}
+export async function createNotifier(method, config = {}) {
+    const { NullNotifier } = await import('./Notifier.js');
+    switch (method) {
+        case 'none':
+            return new NullNotifier();
+        case 'terminal': {
+            const TerminalNotifier = await getTerminalNotifierClass();
+            return new TerminalNotifier({
+                ...config.terminal,
+                logger: config.logger,
+            });
+        }
+        case 'webhook': {
+            const { WebhookNotifier } = await import('./WebhookNotifier.js');
+            const url = config.webhookUrl ?? config.webhooks?.defaultUrl;
+            if (!url) {
+                throw new Error('Webhook URL is required for webhook notifications. ' +
+                    'Set --webhook-url or configure loops.webhooks.defaultUrl');
+            }
+            return new WebhookNotifier({
+                url,
+                timeout: config.webhooks?.timeout,
+                retries: config.webhooks?.retries,
+                logger: config.logger,
+            });
+        }
+        case 'slack': {
+            const { SlackNotifier } = await import('./SlackNotifier.js');
+            if (!config.slackWebhookUrl) {
+                throw new Error('Slack webhook URL is required for Slack notifications. ' +
+                    'Configure loops.slack.webhookUrl or set --slack-webhook-url');
+            }
+            return new SlackNotifier({
+                webhookUrl: config.slackWebhookUrl,
+                timeout: config.webhooks?.timeout,
+                retries: config.webhooks?.retries,
+                logger: config.logger,
+            });
+        }
+        default: {
+            const _exhaustive = method;
+            throw new Error(`Unknown notification method: ${method}`);
+        }
+    }
+}
+export function createNotifierSync(method, config = {}) {
+    switch (method) {
+        case 'none':
+            return new NullNotifier();
+        case 'webhook': {
+            const url = config.webhookUrl ?? config.webhooks?.defaultUrl;
+            if (!url) {
+                throw new Error('Webhook URL is required for webhook notifications.');
+            }
+            return new WebhookNotifier({
+                url,
+                timeout: config.webhooks?.timeout,
+                retries: config.webhooks?.retries,
+                logger: config.logger,
+            });
+        }
+        case 'slack': {
+            if (!config.slackWebhookUrl) {
+                throw new Error('Slack webhook URL is required for Slack notifications.');
+            }
+            return new SlackNotifier({
+                webhookUrl: config.slackWebhookUrl,
+                timeout: config.webhooks?.timeout,
+                retries: config.webhooks?.retries,
+                logger: config.logger,
+            });
+        }
+        default: {
+            const _exhaustive = method;
+            throw new Error(`Unknown notification method: ${method}`);
+        }
+    }
+}
+export async function createNotifiers(methods, config = {}) {
+    const uniqueMethods = [...new Set(methods.filter((m) => m !== 'none'))];
+    if (uniqueMethods.length === 0) {
+        const { NullNotifier } = await import('./Notifier.js');
+        return [new NullNotifier()];
+    }
+    return Promise.all(uniqueMethods.map((method) => createNotifier(method, config)));
+}
+export function isValidNotifyMethod(method) {
+    return ['none', 'terminal', 'webhook', 'slack'].includes(method);
+}
+export function getAvailableNotifyMethods() {
+    return ['none', 'terminal', 'webhook', 'slack'];
+}