botforje 0.0.1

package/dist/services/flow-executor.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowExecutor = void 0;
+const executor_1 = require("../action/executor");
+const template_1 = require("../action/template");
+const webhook_1 = require("../utils/webhook");
+const fuzzy_1 = require("../bot/fuzzy");
+const logger_1 = require("../utils/logger");
+class FlowExecutor {
+    constructor(actionCatalog, flowCatalog, flowStateService, outboxService, defaultTimeout = 300, cooldownService) {
+        this.actionCatalog = actionCatalog;
+        this.flowCatalog = flowCatalog;
+        this.flowStateService = flowStateService;
+        this.outboxService = outboxService;
+        this.defaultTimeout = defaultTimeout;
+        this.cooldownService = cooldownService;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    async handleMessage(bot, message) {
+        this.flowStateService.cleanupExpired();
+        const state = this.flowStateService.findActive(message.from, bot.id);
+        if (state) {
+            return this.handleActiveState(bot, message, state);
+        }
+        return this.handleNewMessage(bot, message);
+    }
+    async handleActiveState(bot, message, state) {
+        const flow = this.flowCatalog.get(state.flowId);
+        if (!flow) {
+            this.flowStateService.destroy(state.id);
+            return false;
+        }
+        const currentStep = flow.steps[state.stepId];
+        if (!currentStep) {
+            this.flowStateService.destroy(state.id);
+            return false;
+        }
+        const branch = this.findMatchingBranch(currentStep.branches, message.content);
+        if (!branch) {
+            if (flow.fallbackStep && flow.steps[flow.fallbackStep]) {
+                await this.transitionToStep(bot, message, state, flow, flow.fallbackStep);
+                return true;
+            }
+            this.logger.debug(`No branch matched for flow state ${state.id}, ignoring message`);
+            return true;
+        }
+        await this.transitionToStep(bot, message, state, flow, branch.goto);
+        return true;
+    }
+    async handleNewMessage(bot, message) {
+        const flowRefs = [...bot.flows].sort((a, b) => b.priority - a.priority);
+        for (const flowRef of flowRefs) {
+            const flow = this.flowCatalog.get(flowRef.id);
+            if (!flow) {
+                this.logger.warn(`Flow "${flowRef.id}" referenced by bot "${bot.name}" not found`);
+                continue;
+            }
+            const entryStep = flow.steps[flow.entry];
+            if (!entryStep) {
+                this.logger.warn(`Entry step "${flow.entry}" for flow "${flow.id}" not found`);
+                continue;
+            }
+            if (!this.matchesTriggers(entryStep, message.content)) {
+                continue;
+            }
+            const consumed = await this.executeStepAction(bot, message, entryStep, {});
+            if (!consumed) {
+                return false;
+            }
+            if (entryStep.branches.length === 0) {
+                this.flowStateService.destroyBySenderBot(message.from, bot.id);
+            }
+            else {
+                const timeout = flow.timeout ?? this.defaultTimeout;
+                this.flowStateService.create(message.from, bot.id, flow.id, flow.entry, timeout);
+            }
+            return true;
+        }
+        return false;
+    }
+    async transitionToStep(bot, message, state, flow, stepId) {
+        const step = flow.steps[stepId];
+        if (!step) {
+            this.logger.error(`Step "${stepId}" not found in flow "${flow.id}"`);
+            this.flowStateService.destroy(state.id);
+            return;
+        }
+        await this.executeStepAction(bot, message, step, state.variables);
+        if (step.branches.length === 0) {
+            this.flowStateService.destroy(state.id);
+        }
+        else {
+            this.flowStateService.updateStep(state.id, stepId, state.variables);
+        }
+    }
+    async executeStepAction(bot, message, step, variables) {
+        const context = {
+            botId: bot.id,
+            botName: bot.name,
+            sender: message.from,
+            message: message.content,
+            variables,
+        };
+        if (this.isActionOnCooldown(bot, step.action, message.from)) {
+            const action = (0, executor_1.getAction)(this.actionCatalog, step.action);
+            if (action.cooldownReply) {
+                const reply = (0, template_1.resolveVars)(action.cooldownReply, context);
+                this.outboxService.enqueue(bot.id, message.from, reply);
+                this.logger.info(`Cooldown reply sent for action "${step.action}" to ${message.from}`);
+                return true;
+            }
+            this.logger.warn(`Action "${step.action}" on cooldown, no cooldown_reply defined, skipping`);
+            return false;
+        }
+        const result = (0, executor_1.executeAction)(this.actionCatalog, step.action, context);
+        this.setActionCooldown(step.action, message.from);
+        if (result.reply) {
+            this.outboxService.enqueue(bot.id, message.from, result.reply);
+        }
+        if (result.webhook) {
+            try {
+                const payload = this.buildWebhookPayload(bot, message, result.webhook.name || 'unnamed');
+                await (0, webhook_1.sendWebhookRequest)({
+                    url: result.webhook.url,
+                    method: result.webhook.method,
+                    headers: result.webhook.headers,
+                    body: payload,
+                    timeout: result.webhook.timeout,
+                    retries: result.webhook.retries,
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to trigger webhook action for bot "${bot.name}":`, error);
+            }
+        }
+        return true;
+    }
+    isActionOnCooldown(bot, actionId, sender) {
+        if (!this.cooldownService) {
+            return false;
+        }
+        const action = (0, executor_1.getAction)(this.actionCatalog, actionId);
+        if (!action.cooldown || action.cooldown <= 0) {
+            return false;
+        }
+        const cooldownMs = action.cooldown * 1000;
+        const cooldownKey = `action:${actionId}`;
+        return this.cooldownService.isOnCooldown(sender, cooldownKey, cooldownMs);
+    }
+    setActionCooldown(actionId, sender) {
+        if (!this.cooldownService) {
+            return;
+        }
+        const action = (0, executor_1.getAction)(this.actionCatalog, actionId);
+        if (!action.cooldown || action.cooldown <= 0) {
+            return;
+        }
+        this.cooldownService.setCooldown(sender, `action:${actionId}`);
+    }
+    findMatchingBranch(branches, message) {
+        const defaultBranch = branches.find(branch => !branch.when || branch.when.length === 0);
+        const conditionalBranches = branches.filter(branch => branch.when && branch.when.length > 0);
+        for (const branch of conditionalBranches) {
+            const threshold = branch.fuzzyThreshold ?? 0.6;
+            if ((0, fuzzy_1.matchFuzzy)(branch.when, message, threshold)) {
+                return branch;
+            }
+        }
+        return defaultBranch || null;
+    }
+    matchesTriggers(step, message) {
+        if (!step.triggers || step.triggers.length === 0) {
+            return false;
+        }
+        return step.triggers.some(trigger => {
+            const threshold = trigger.fuzzyThreshold ?? 0.6;
+            return (0, fuzzy_1.matchFuzzy)(trigger.phrases, message, threshold) !== null;
+        });
+    }
+    buildWebhookPayload(bot, message, webhookName) {
+        return {
+            sender: message.from,
+            message: message.content,
+            timestamp: message.timestamp.toISOString(),
+            botId: bot.id,
+            botName: bot.name,
+            webhookName,
+            webhookPattern: '',
+            metadata: message.metadata || {},
+        };
+    }
+}
+exports.FlowExecutor = FlowExecutor;

package/dist/services/flow-state.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.FlowStateService = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class FlowStateService {
+    constructor(dbPath) {
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.setupSchema();
+    }
+    setupSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS flow_states (
+        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_flow_states_sender_bot ON flow_states(sender, bot_id);
+      CREATE INDEX IF NOT EXISTS idx_flow_states_last_activity ON flow_states(last_activity_at);
+    `);
+    }
+    findActive(sender, botId, now = Date.now()) {
+        const row = this.db
+            .prepare('SELECT * FROM flow_states WHERE sender = ? AND bot_id = ?')
+            .get(sender, botId);
+        if (!row) {
+            return null;
+        }
+        const state = this.rowToState(row);
+        if (this.isExpired(state, now)) {
+            this.destroy(state.id);
+            return null;
+        }
+        return state;
+    }
+    create(sender, botId, flowId, stepId, timeout, now = Date.now()) {
+        this.destroyBySenderBot(sender, botId);
+        const id = `${botId}-${sender}-${now}`;
+        const state = {
+            id,
+            sender,
+            botId,
+            flowId,
+            stepId,
+            variables: {},
+            startedAt: now,
+            lastActivityAt: now,
+            timeout,
+        };
+        this.db
+            .prepare('INSERT INTO flow_states (id, sender, bot_id, flow_id, step_id, variables, started_at, last_activity_at, timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(state.id, state.sender, state.botId, state.flowId, state.stepId, JSON.stringify(state.variables), state.startedAt, state.lastActivityAt, state.timeout);
+        return state;
+    }
+    updateStep(id, stepId, variables, now = Date.now()) {
+        const state = this.findById(id);
+        if (!state) {
+            return;
+        }
+        const mergedVariables = variables ? { ...state.variables, ...variables } : state.variables;
+        this.db
+            .prepare('UPDATE flow_states SET step_id = ?, variables = ?, last_activity_at = ? WHERE id = ?')
+            .run(stepId, JSON.stringify(mergedVariables), now, id);
+    }
+    destroy(id) {
+        this.db.prepare('DELETE FROM flow_states WHERE id = ?').run(id);
+    }
+    destroyBySenderBot(sender, botId) {
+        this.db.prepare('DELETE FROM flow_states WHERE sender = ? AND bot_id = ?').run(sender, botId);
+    }
+    cleanupExpired(now = Date.now()) {
+        const cutoff = now;
+        const result = this.db
+            .prepare('DELETE FROM flow_states WHERE (last_activity_at + (timeout * 1000)) < ?')
+            .run(cutoff);
+        return result.changes;
+    }
+    count() {
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM flow_states').get();
+        return row.count;
+    }
+    close() {
+        this.db.close();
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM flow_states WHERE id = ?').get(id);
+        return row ? this.rowToState(row) : null;
+    }
+    rowToState(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(state, now) {
+        if (state.timeout <= 0) {
+            return false;
+        }
+        return now > state.lastActivityAt + state.timeout * 1000;
+    }
+}
+exports.FlowStateService = FlowStateService;

package/dist/services/inbox.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboxService = void 0;
+const logger_1 = require("../utils/logger");
+class InboxService {
+    constructor(flowExecutor) {
+        this.flowExecutor = flowExecutor;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    registerBot(bot) {
+        if (!bot.channel) {
+            throw new Error(`Bot "${bot.id}" does not have a registered channel`);
+        }
+        bot.channel.onMessage((message) => {
+            this.handleIncomingMessage(bot, message);
+        });
+        bot.channel.onReady(() => {
+            this.logger.info(`Bot "${bot.id}" is ready and listening for messages`);
+        });
+    }
+    async handleIncomingMessage(bot, message) {
+        this.logger.info(`Message received for bot "${bot.id}": ${message.content.substring(0, 50)}...`);
+        try {
+            if (message.metadata?.fromMe) {
+                return;
+            }
+            if (this.isSenderIgnored(bot, message.from)) {
+                this.logger.debug(`Ignoring message from "${message.from}" for bot "${bot.id}" (sender in ignored list)`);
+                return;
+            }
+            if (bot.settings.ignoreGroups && this.isGroupMessage(message.from)) {
+                this.logger.debug(`Ignoring group message for bot "${bot.id}"`);
+                return;
+            }
+            await this.flowExecutor.handleMessage(bot, message);
+        }
+        catch (error) {
+            this.logger.error(`Error handling message for bot "${bot.id}":`, error);
+        }
+    }
+    isSenderIgnored(bot, sender) {
+        return bot.settings.ignoredSenders.includes(sender);
+    }
+    isGroupMessage(from) {
+        return from.includes('g.us');
+    }
+}
+exports.InboxService = InboxService;

package/dist/services/message-handler.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandlerService = void 0;
+const auto_response_1 = require("./auto-response");
+const webhook_1 = require("./webhook");
+const logger_1 = require("../utils/logger");
+class MessageHandlerService {
+    constructor(cooldownService) {
+        this.bots = new Map();
+        this.messageHandlers = new Map();
+        this.autoResponseService = new auto_response_1.AutoResponseService(cooldownService);
+        this.webhookService = new webhook_1.WebhookService(cooldownService);
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    registerBot(bot) {
+        if (!bot.channel) {
+            throw new Error(`Bot "${bot.name}" does not have a registered channel`);
+        }
+        this.bots.set(bot.id, bot);
+        bot.channel.onMessage((message) => {
+            this.handleIncomingMessage(bot, message);
+        });
+        bot.channel.onReady(() => {
+            this.logger.info(`🤖 Bot "${bot.name}" (${bot.id}) is ready and listening for messages`);
+        });
+    }
+    unregisterBot(botId) {
+        this.bots.delete(botId);
+        this.messageHandlers.delete(botId);
+    }
+    registerMessageHandler(botId, handler) {
+        this.messageHandlers.set(botId, handler);
+    }
+    async handleIncomingMessage(bot, message) {
+        this.logger.info(`📨 Message received for bot "${bot.name}": ${message.content.substring(0, 50)}...`);
+        try {
+            if (this.isSenderIgnored(bot, message.from)) {
+                this.logger.debug(`🚫 Ignoring message from "${message.from}" for bot "${bot.name}" (sender in ignored list)`);
+                return;
+            }
+            if (!this.autoResponseService.shouldProcessMessage(bot, message)) {
+                return;
+            }
+            const autoResponse = this.autoResponseService.processMessage(bot, message);
+            if (autoResponse) {
+                this.autoResponseService.sendAutoResponse({ enqueue: () => '' }, bot, message, autoResponse);
+            }
+            this.webhookService.processWebhooks(bot, message).catch(error => {
+                this.logger.error(`❌ Error processing webhooks for bot "${bot.name}":`, error);
+            });
+            const customHandler = this.messageHandlers.get(bot.id);
+            if (customHandler) {
+                customHandler(bot, message, autoResponse?.response);
+            }
+        }
+        catch (error) {
+            this.logger.error(`❌ Error handling message for bot "${bot.name}":`, error);
+        }
+    }
+    getRegisteredBots() {
+        return Array.from(this.bots.values());
+    }
+    isBotRegistered(botId) {
+        return this.bots.has(botId);
+    }
+    getBot(botId) {
+        return this.bots.get(botId);
+    }
+    isSenderIgnored(bot, sender) {
+        return bot.settings.ignoredSenders.includes(sender);
+    }
+    getAutoResponseService() {
+        return this.autoResponseService;
+    }
+}
+exports.MessageHandlerService = MessageHandlerService;

package/dist/services/message-queue.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueueService = void 0;
+const logger_1 = require("../utils/logger");
+class MessageQueueService {
+    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.name}" 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.name}": 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 message queue 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('✅ Message queue service shut down');
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.MessageQueueService = MessageQueueService;