botforje 0.0.1

package/dist/services/outbox.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboxService = void 0;
+const logger_1 = require("../utils/logger");
+class OutboxService {
+    constructor() {
+        this.queues = new Map();
+        this.processing = new Map();
+        this.delays = new Map();
+        this.sendCallbacks = new Map();
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    setBotDelay(botId, delayMs) {
+        this.delays.set(botId, delayMs);
+        this.logger.info(`Queue delay for bot "${botId}" set to ${delayMs}ms`);
+    }
+    setBotSendCallback(botId, callback) {
+        this.sendCallbacks.set(botId, callback);
+    }
+    setupBotQueue(bot) {
+        if (!bot.channel) {
+            throw new Error(`Bot "${bot.id}" does not have a registered channel`);
+        }
+        const botId = bot.id;
+        this.setBotDelay(botId, bot.settings.queueDelay);
+        this.setBotSendCallback(botId, async (botId, message) => {
+            await bot.channel.send(message);
+        });
+        this.logger.info(`Configured message queue for bot "${bot.id}": delay=${bot.settings.queueDelay}ms`);
+    }
+    enqueue(botId, to, content, metadata) {
+        const messageId = `${botId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        this.logger.debug(`Queueing message for bot "${botId}" with metadata:`, metadata);
+        const outgoingMessage = {
+            to,
+            content,
+            metadata,
+        };
+        const queuedMessage = {
+            id: messageId,
+            botId,
+            message: outgoingMessage,
+            timestamp: Date.now(),
+        };
+        if (!this.queues.has(botId)) {
+            this.queues.set(botId, []);
+        }
+        const botQueue = this.queues.get(botId);
+        botQueue.push(queuedMessage);
+        this.logger.info(`Message queued for bot "${botId}": ${messageId} (queue size: ${botQueue.length})`);
+        if (!this.processing.get(botId)) {
+            this.startProcessing(botId);
+        }
+        return messageId;
+    }
+    async startProcessing(botId) {
+        if (this.processing.get(botId)) {
+            return;
+        }
+        this.processing.set(botId, true);
+        this.logger.info(`Started processing queue for bot "${botId}"`);
+        const botQueue = this.queues.get(botId);
+        if (!botQueue) {
+            this.processing.set(botId, false);
+            return;
+        }
+        while (botQueue.length > 0) {
+            const messageData = botQueue.shift();
+            const delay = this.delays.get(botId) || 2000;
+            try {
+                this.logger.debug(`Waiting ${delay}ms before sending message ${messageData.id} from bot "${botId}"...`);
+                await this.delay(delay);
+                this.logger.info(`Processing queued message: ${messageData.id} from bot "${botId}"`);
+                const callback = this.sendCallbacks.get(botId);
+                if (callback) {
+                    await callback(botId, messageData.message);
+                    this.logger.info(`Queued message sent successfully: ${messageData.id}`);
+                }
+                else {
+                    this.logger.error(`No send callback configured for bot "${botId}"`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error sending queued message ${messageData.id} from bot "${botId}":`, error);
+            }
+        }
+        this.processing.set(botId, false);
+        this.logger.info(`Queue processing completed for bot "${botId}"`);
+    }
+    getBotQueueStatus(botId) {
+        const queue = this.queues.get(botId) || [];
+        const isProcessing = this.processing.get(botId) || false;
+        const delay = this.delays.get(botId) || 2000;
+        return {
+            botId,
+            queueSize: queue.length,
+            isProcessing,
+            delayMs: delay,
+            hasCallback: this.sendCallbacks.has(botId),
+            nextMessage: queue.length > 0 ? {
+                id: queue[0].id,
+                to: queue[0].message.to,
+                age: Date.now() - queue[0].timestamp,
+            } : null,
+        };
+    }
+    clearBotQueue(botId) {
+        this.queues.delete(botId);
+        this.logger.info(`Queue cleared for bot "${botId}"`);
+    }
+    getAllQueuesStatus() {
+        const allStatuses = [];
+        for (const [botId] of this.queues.entries()) {
+            const status = this.getBotQueueStatus(botId);
+            allStatuses.push(status);
+        }
+        return {
+            totalQueues: allStatuses.length,
+            queues: allStatuses,
+        };
+    }
+    async shutdown() {
+        this.logger.info('Shutting down outbox service...');
+        for (const [botId] of this.processing.entries()) {
+            this.processing.set(botId, false);
+        }
+        this.queues.clear();
+        this.delays.clear();
+        this.sendCallbacks.clear();
+        this.logger.info('Outbox service shut down');
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.OutboxService = OutboxService;

package/dist/services/session.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionService = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class SessionService {
+    constructor(dbPath) {
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.setupSchema();
+    }
+    setupSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        bot_id TEXT NOT NULL,
+        flow_id TEXT NOT NULL,
+        step_id TEXT NOT NULL,
+        variables TEXT NOT NULL DEFAULT '{}',
+        started_at INTEGER NOT NULL,
+        last_activity_at INTEGER NOT NULL,
+        timeout INTEGER NOT NULL
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_sender_bot ON sessions(sender, bot_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_last_activity ON sessions(last_activity_at);
+    `);
+    }
+    findActive(sender, botId, now = Date.now()) {
+        const row = this.db
+            .prepare('SELECT * FROM sessions WHERE sender = ? AND bot_id = ?')
+            .get(sender, botId);
+        if (!row) {
+            return null;
+        }
+        const session = this.rowToSession(row);
+        if (this.isExpired(session, now)) {
+            this.destroy(session.id);
+            return null;
+        }
+        return session;
+    }
+    create(sender, botId, flowId, stepId, timeout, now = Date.now()) {
+        this.destroyBySenderBot(sender, botId);
+        const id = `${botId}-${sender}-${now}`;
+        const session = {
+            id,
+            sender,
+            botId,
+            flowId,
+            stepId,
+            variables: {},
+            startedAt: now,
+            lastActivityAt: now,
+            timeout,
+        };
+        this.db
+            .prepare('INSERT INTO sessions (id, sender, bot_id, flow_id, step_id, variables, started_at, last_activity_at, timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(session.id, session.sender, session.botId, session.flowId, session.stepId, JSON.stringify(session.variables), session.startedAt, session.lastActivityAt, session.timeout);
+        return session;
+    }
+    updateStep(id, stepId, variables, now = Date.now()) {
+        const session = this.findById(id);
+        if (!session) {
+            return;
+        }
+        const mergedVariables = variables ? { ...session.variables, ...variables } : session.variables;
+        this.db
+            .prepare('UPDATE sessions SET step_id = ?, variables = ?, last_activity_at = ? WHERE id = ?')
+            .run(stepId, JSON.stringify(mergedVariables), now, id);
+    }
+    destroy(id) {
+        this.db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+    }
+    destroyBySenderBot(sender, botId) {
+        this.db.prepare('DELETE FROM sessions WHERE sender = ? AND bot_id = ?').run(sender, botId);
+    }
+    cleanupExpired(now = Date.now()) {
+        const cutoff = now;
+        const result = this.db
+            .prepare('DELETE FROM sessions WHERE (last_activity_at + (timeout * 1000)) < ?')
+            .run(cutoff);
+        return result.changes;
+    }
+    close() {
+        this.db.close();
+    }
+    count() {
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM sessions').get();
+        return row.count;
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+        return row ? this.rowToSession(row) : null;
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            sender: row.sender,
+            botId: row.bot_id,
+            flowId: row.flow_id,
+            stepId: row.step_id,
+            variables: JSON.parse(row.variables || '{}'),
+            startedAt: row.started_at,
+            lastActivityAt: row.last_activity_at,
+            timeout: row.timeout,
+        };
+    }
+    isExpired(session, now) {
+        if (session.timeout <= 0) {
+            return false;
+        }
+        return now > session.lastActivityAt + session.timeout * 1000;
+    }
+}
+exports.SessionService = SessionService;

package/dist/services/webhook.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookService = void 0;
+const fuzzy_1 = require("../bot/fuzzy");
+const logger_1 = require("../utils/logger");
+class WebhookService {
+    constructor(cooldownService) {
+        this.cooldownService = cooldownService;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    async processWebhooks(bot, message) {
+        if (message.metadata?.fromMe) {
+            return;
+        }
+        const sorted = [...bot.webhooks].sort((a, b) => b.priority - a.priority);
+        const matchingWebhooks = sorted.filter(webhook => (0, fuzzy_1.matchFuzzy)(webhook.fuzzySegments, message.content, webhook.fuzzyThreshold));
+        if (matchingWebhooks.length === 0) {
+            return;
+        }
+        for (const webhook of matchingWebhooks) {
+            try {
+                await this.triggerWebhook(bot, message, webhook);
+            }
+            catch (error) {
+                this.logger.error(`❌ Failed to trigger webhook "${webhook.name}" for bot "${bot.name}":`, error);
+            }
+        }
+    }
+    async triggerWebhook(bot, message, webhook) {
+        const cooldownMs = (webhook.cooldown || 0) * 1000;
+        const senderKey = message.from;
+        if (this.cooldownService.isOnCooldown(senderKey, webhook.name, cooldownMs)) {
+            this.logger.debug(`⏳ Webhook cooldown active for sender "${senderKey}" on webhook "${webhook.name}" in bot "${bot.name}"`);
+            return;
+        }
+        this.cooldownService.setCooldown(senderKey, webhook.name);
+        this.logger.info(`🔗 Triggering webhook "${webhook.name}" for bot "${bot.name}": ${webhook.method} ${webhook.url}`);
+        const payload = this.buildWebhookPayload(bot, message, webhook);
+        await this.makeHttpRequest(webhook, payload);
+    }
+    buildWebhookPayload(bot, message, webhook) {
+        return {
+            sender: message.from,
+            message: message.content,
+            timestamp: message.timestamp.toISOString(),
+            botId: bot.id,
+            botName: bot.name,
+            webhookName: webhook.name,
+            webhookPattern: webhook.patternString,
+            metadata: message.metadata || {},
+        };
+    }
+    async makeHttpRequest(webhook, payload) {
+        const maxRetries = webhook.retries || 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await fetch(webhook.url, {
+                    method: webhook.method || 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(webhook.headers || {}),
+                    },
+                    body: JSON.stringify(payload),
+                    signal: AbortSignal.timeout(webhook.timeout || 5000),
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                this.logger.info(`✅ Webhook request successful: ${webhook.url}`);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < maxRetries) {
+                    const backoffMs = Math.pow(2, attempt - 1) * 1000;
+                    this.logger.warn(`⚠️ Webhook request failed (attempt ${attempt}/${maxRetries}), retrying in ${backoffMs}ms:`, lastError.message);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                }
+            }
+        }
+        throw new Error(`Webhook request failed after ${maxRetries} attempts: ${lastError?.message}`);
+    }
+}
+exports.WebhookService = WebhookService;

package/dist/utils/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = void 0;
+exports.createLogger = createLogger;
+exports.getLogger = getLogger;
+exports.setGlobalLogger = setGlobalLogger;
+const pino_1 = __importDefault(require("pino"));
+function getCallerInfo() {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    if (!isDevelopment)
+        return undefined;
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+        const err = new Error();
+        Error.prepareStackTrace = (_, stack) => stack;
+        const stack = err.stack;
+        const caller = stack[2];
+        if (caller) {
+            const fileName = caller.getFileName() || 'unknown';
+            const lineNumber = caller.getLineNumber() || 0;
+            const functionName = caller.getFunctionName() || 'anonymous';
+            const shortFileName = fileName.split('/').pop() || fileName;
+            return {
+                file: shortFileName,
+                line: lineNumber,
+                func: functionName,
+            };
+        }
+    }
+    catch (e) {
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+    return undefined;
+}
+function createLogger(logLevel = 'info') {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    const logger = (0, pino_1.default)({
+        level: logLevel,
+        transport: isDevelopment
+            ? {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss',
+                    ignore: 'pid,hostname,caller',
+                    messageFormat: '{if caller}[{caller.file}:{caller.line}]{end} {msg}',
+                    singleLine: false,
+                    hideObject: true,
+                },
+            }
+            : undefined,
+        formatters: {
+            level: label => ({ level: label }),
+        },
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    });
+    return {
+        debug: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.debug({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        info: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.info({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        warn: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.warn({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        error: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.error({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+    };
+}
+let globalLogger = createLogger('info');
+function getLogger() {
+    return globalLogger;
+}
+function setGlobalLogger(config) {
+    const logLevel = config?.logLevel || 'info';
+    globalLogger = createLogger(logLevel);
+}
+exports.defaultLogger = createLogger('info');

package/dist/utils/webhook.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendWebhookRequest = sendWebhookRequest;
+const logger_1 = require("./logger");
+async function sendWebhookRequest(call) {
+    const logger = (0, logger_1.getLogger)();
+    const maxRetries = call.retries || 1;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(call.url, {
+                method: call.method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...call.headers,
+                },
+                body: call.body !== undefined ? JSON.stringify(call.body) : undefined,
+                signal: AbortSignal.timeout(call.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            logger.info(`Webhook request successful: ${call.url}`);
+            return;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxRetries) {
+                const backoffMs = Math.pow(2, attempt - 1) * 1000;
+                logger.warn(`Webhook request failed (attempt ${attempt}/${maxRetries}), retrying in ${backoffMs}ms:`, lastError.message);
+                await new Promise(resolve => setTimeout(resolve, backoffMs));
+            }
+        }
+    }
+    throw new Error(`Webhook request failed after ${maxRetries} attempts: ${lastError?.message}`);
+}