botforje 0.0.1

package/dist/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const fleet_1 = require("./bot/fleet");
+const outbox_1 = require("./services/outbox");
+const server_1 = require("./api/server");
+const yaml_1 = require("./config/yaml");
+const logger_1 = require("./utils/logger");
+const client_1 = require("./whatsapp/client");
+const create_bot_1 = require("./cli/create-bot");
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const program = new commander_1.Command();
+program
+    .name('botforge')
+    .description('CLI tool for creating and managing WhatsApp bots')
+    .version(packageJson.version)
+    .option('-c, --config <path>', 'Path to config file (default: ~/.config/wweb-botforge/config.yml)');
+program
+    .command('setup')
+    .description('Setup/repair systemd service')
+    .action(() => {
+    const setupScript = path.join(__dirname, '..', 'scripts', 'setup-systemd.js');
+    (0, child_process_1.execSync)(`node ${setupScript}`, { stdio: 'inherit' });
+});
+program
+    .command('create-bot')
+    .description('Create a new WhatsApp bot interactively')
+    .action(() => (0, create_bot_1.runCreateBot)(program.opts().config));
+program
+    .command('start')
+    .description('Start the WhatsApp bots')
+    .action(async () => {
+    await startBots(program.opts().config);
+});
+async function startBots(configPath) {
+    if (configPath)
+        (0, yaml_1.setConfigPath)(configPath);
+    const configFile = await (0, yaml_1.loadConfig)(configPath);
+    if (configFile.global) {
+        (0, logger_1.setGlobalLogger)(configFile.global);
+        (0, client_1.setGlobalConfig)(configFile.global);
+    }
+    const logger = (0, logger_1.getLogger)();
+    logger.info('WWeb BotForge - Starting bots...');
+    const outboxService = new outbox_1.OutboxService();
+    const fleet = new fleet_1.BotFleet(outboxService);
+    const bots = await fleet.start(configFile);
+    if (configFile.global?.apiEnabled) {
+        const apiPort = configFile.global.apiPort || 3000;
+        const apiServer = new server_1.ApiServer(outboxService, bots, apiPort);
+        await apiServer.start();
+    }
+}
+program.parse();

package/dist/messages/contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/messages/inbox.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboxService = void 0;
+const logger_1 = require("../helpers/logger");
+class InboxService {
+    constructor(graphExecutor) {
+        this.graphExecutor = graphExecutor;
+    }
+    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.isSenderNotAllowed(bot, message.from)) {
+                this.logger.debug(`Ignoring message from "${message.from}" for bot "${bot.id}" (sender not in allowed list)`);
+                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.graphExecutor.handleMessage(bot, message);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Error handling message for bot "${bot.id}": ${msg}`);
+        }
+    }
+    isSenderNotAllowed(bot, sender) {
+        return bot.settings.allowedSenders.length > 0 && !bot.settings.allowedSenders.includes(sender);
+    }
+    isSenderIgnored(bot, sender) {
+        return bot.settings.ignoredSenders.includes(sender);
+    }
+    isGroupMessage(from) {
+        return from.includes('g.us');
+    }
+}
+exports.InboxService = InboxService;

package/dist/messages/outbox.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboxService = void 0;
+const logger_1 = require("../helpers/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) {
+        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: ${JSON.stringify(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) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Error sending queued message ${messageData.id} from bot "${botId}": ${msg}`);
+            }
+        }
+        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/auto-response.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoResponseService = void 0;
+const fuzzy_1 = require("../bot/fuzzy");
+const logger_1 = require("../utils/logger");
+class AutoResponseService {
+    constructor(cooldownService) {
+        this.cooldownService = cooldownService;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    processMessage(bot, message) {
+        this.cooldownService.cleanupExpiredCooldowns();
+        if (message.metadata?.fromMe) {
+            return null;
+        }
+        if (bot.settings.ignoreGroups && this.isGroupMessage(message.from)) {
+            this.logger.debug(`🚫 Ignoring group message for bot "${bot.name}"`);
+            return null;
+        }
+        const sorted = [...bot.autoResponses].sort((a, b) => b.priority - a.priority);
+        const matchingResponse = sorted.find(response => (0, fuzzy_1.matchFuzzy)(response.fuzzySegments, message.content, response.fuzzyThreshold));
+        if (matchingResponse) {
+            const cooldownMs = (matchingResponse.cooldown || 0) * 1000;
+            const patternKey = matchingResponse.patternString;
+            if (this.cooldownService.isOnCooldown(message.from, patternKey, cooldownMs)) {
+                this.logger.debug(`⏳ Cooldown active for sender "${message.from}" on pattern "${patternKey}" in bot "${bot.name}"`);
+                return null;
+            }
+            this.cooldownService.setCooldown(message.from, patternKey);
+            this.logger.info(`🤖 Auto-response triggered for bot "${bot.name}": "${patternKey}" → "${matchingResponse.response}"`);
+            return matchingResponse;
+        }
+        return null;
+    }
+    shouldProcessMessage(bot, message) {
+        if (message.metadata?.fromMe) {
+            return false;
+        }
+        if (bot.settings.ignoreGroups && this.isGroupMessage(message.from)) {
+            return false;
+        }
+        return true;
+    }
+    isGroupMessage(from) {
+        return from.includes('g.us');
+    }
+    sendAutoResponse(messageQueue, bot, originalMessage, autoResponse) {
+        try {
+            const metadata = autoResponse.responseOptions || {};
+            const messageId = messageQueue.enqueue(bot.id, originalMessage.from, autoResponse.response, metadata);
+            this.logger.info(`📤 Auto-response queued for bot "${bot.name}" with ID: ${messageId}`);
+            return messageId;
+        }
+        catch (error) {
+            this.logger.error(`❌ Error sending auto-response for bot "${bot.name}":`, error);
+            throw error;
+        }
+    }
+}
+exports.AutoResponseService = AutoResponseService;

package/dist/services/cooldown.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CooldownService = void 0;
+class CooldownService {
+    constructor() {
+        this.cooldowns = new Map();
+    }
+    isOnCooldown(sender, key, cooldownMs) {
+        if (cooldownMs <= 0)
+            return false;
+        const senderCooldowns = this.cooldowns.get(sender);
+        if (!senderCooldowns)
+            return false;
+        const lastTrigger = senderCooldowns.get(key);
+        if (!lastTrigger)
+            return false;
+        return Date.now() - lastTrigger < cooldownMs;
+    }
+    setCooldown(sender, key) {
+        let senderCooldowns = this.cooldowns.get(sender);
+        if (!senderCooldowns) {
+            senderCooldowns = new Map();
+            this.cooldowns.set(sender, senderCooldowns);
+        }
+        senderCooldowns.set(key, Date.now());
+    }
+    cleanupExpiredCooldowns() {
+        const now = Date.now();
+        const maxAge = 60 * 60 * 1000;
+        for (const [sender, keyMap] of this.cooldowns.entries()) {
+            for (const [key, timestamp] of keyMap.entries()) {
+                if (now - timestamp > maxAge) {
+                    keyMap.delete(key);
+                }
+            }
+            if (keyMap.size === 0) {
+                this.cooldowns.delete(sender);
+            }
+        }
+    }
+    getCooldownStatus(sender, key) {
+        const senderCooldowns = this.cooldowns.get(sender);
+        const lastTrigger = senderCooldowns?.get(key);
+        if (!lastTrigger) {
+            return { isOnCooldown: false, remainingMs: 0 };
+        }
+        const now = Date.now();
+        const elapsed = now - lastTrigger;
+        const isOnCooldown = elapsed < 30000;
+        const remainingMs = Math.max(0, 30000 - elapsed);
+        return { isOnCooldown, remainingMs, lastTrigger };
+    }
+    clearAllCooldowns() {
+        this.cooldowns.clear();
+    }
+    clearSenderCooldowns(sender) {
+        this.cooldowns.delete(sender);
+    }
+}
+exports.CooldownService = CooldownService;

package/dist/services/fleet.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotFleet = void 0;
+const path = __importStar(require("path"));
+const mapper_1 = require("../bot/mapper");
+const catalog_1 = require("../action/catalog");
+const mapper_2 = require("../flow/mapper");
+const cooldown_1 = require("./cooldown");
+const inbox_1 = require("./inbox");
+const flow_state_1 = require("./flow-state");
+const flow_executor_1 = require("./flow-executor");
+const session_1 = require("../whatsapp/session");
+const yaml_1 = require("../config/yaml");
+const logger_1 = require("../utils/logger");
+class BotFleet {
+    constructor(outboxService) {
+        this.bots = new Map();
+        this.actionCatalog = new Map();
+        this.flowCatalog = new Map();
+        this.isRunning = false;
+        this.sessionManager = session_1.SessionManager.getInstance();
+        this.outboxService = outboxService;
+        this.cooldownService = new cooldown_1.CooldownService();
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    async start(configFile) {
+        if (this.isRunning) {
+            this.logger.info('Bot Fleet Launcher is already running');
+            return this.bots;
+        }
+        try {
+            this.actionCatalog = (0, catalog_1.mapActionCatalog)(configFile.actions || {});
+            this.flowCatalog = (0, mapper_2.mapFlowCatalog)(configFile.flows || {});
+            const configDir = path.dirname((0, yaml_1.getConfigPath)());
+            const flowStateDbPath = path.join(configDir, 'flows.db');
+            this.flowStateService = new flow_state_1.FlowStateService(flowStateDbPath);
+            const flowStateTimeout = configFile.global?.sessionTimeout ?? 300;
+            this.flowExecutor = new flow_executor_1.FlowExecutor(this.actionCatalog, this.flowCatalog, this.flowStateService, this.outboxService, flowStateTimeout, this.cooldownService);
+            this.inboxService = new inbox_1.InboxService(this.flowExecutor);
+            if (configFile.bots.length === 0) {
+                this.logger.warn('No bots configured.');
+                return this.bots;
+            }
+            const loadedBots = (0, mapper_1.mapBotsFromConfig)(configFile.bots);
+            for (const bot of loadedBots) {
+                await this.initializeBot(bot);
+                if (loadedBots.length > 1) {
+                    this.logger.info('Waiting 3 seconds before initializing next bot...');
+                    await this.delay(3000);
+                }
+            }
+            this.isRunning = true;
+            this.logger.info(`WWeb BotForge started successfully with ${this.bots.size} bot(s)!`);
+            this.logger.info('Bots are now listening for messages...');
+            this.setupGracefulShutdown();
+            return this.bots;
+        }
+        catch (error) {
+            this.logger.error('Failed to start Bot Fleet Launcher:', error);
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.logger.info('Stopping WWeb BotForge...');
+        try {
+            await this.outboxService.shutdown();
+            await this.sessionManager.removeAllChannels();
+            this.flowStateService?.close();
+            this.bots.clear();
+            this.isRunning = false;
+            this.logger.info('WWeb BotForge stopped successfully');
+        }
+        catch (error) {
+            this.logger.error('Error stopping Bot Fleet:', error);
+            throw error;
+        }
+    }
+    async initializeBot(bot) {
+        try {
+            this.logger.info(`Initializing bot: ${bot.name} (${bot.id})`);
+            this.bots.set(bot.id, bot);
+            const channel = this.sessionManager.createChannel(bot.id);
+            bot.channel = channel;
+            this.outboxService.setupBotQueue(bot);
+            this.inboxService.registerBot(bot);
+            this.setupBotEventHandlers(bot);
+            await bot.channel.connect();
+            this.logger.info(`Bot "${bot.name}" initialized and ready`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to initialize bot "${bot.name}":`, error);
+            throw error;
+        }
+    }
+    setupBotEventHandlers(bot) {
+        if (!bot.channel) {
+            throw new Error(`Bot "${bot.name}" does not have a registered channel`);
+        }
+        bot.channel.onReady(() => {
+            this.logger.info(`Bot "${bot.name}" is ready!`);
+        });
+        bot.channel.onDisconnected((reason) => {
+            this.logger.warn(`Bot "${bot.name}" disconnected:`, reason);
+        });
+        bot.channel.onAuthFailure((error) => {
+            this.logger.error(`Bot "${bot.name}" authentication failed:`, error.message);
+        });
+        bot.channel.onConnectionError((error) => {
+            this.logger.error(`Bot "${bot.name}" connection error:`, error.message);
+        });
+        bot.channel.onStateChange((state) => {
+            this.logger.info(`Bot "${bot.name}" state changed to:`, state);
+        });
+    }
+    setupGracefulShutdown() {
+        const shutdown = async () => {
+            this.logger.info('\nReceived shutdown signal...');
+            await this.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        process.on('SIGUSR2', shutdown);
+        process.on('uncaughtException', (error) => {
+            this.logger.error('Uncaught Exception:', error);
+            this.stop().finally(() => process.exit(1));
+        });
+        process.on('unhandledRejection', (reason, promise) => {
+            this.logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+            this.stop().finally(() => process.exit(1));
+        });
+    }
+    getStatus() {
+        const botStatuses = Array.from(this.bots.values()).map(bot => {
+            const queueStatus = this.outboxService.getBotQueueStatus(bot.id);
+            return {
+                id: bot.id,
+                name: bot.name,
+                flowsCount: bot.flows.length,
+                queue: {
+                    size: queueStatus.queueSize,
+                    delayMs: queueStatus.delayMs,
+                    isProcessing: queueStatus.isProcessing,
+                    hasCallback: queueStatus.hasCallback,
+                },
+            };
+        });
+        const queueStatus = this.outboxService.getAllQueuesStatus();
+        return {
+            isRunning: this.isRunning,
+            bots: botStatuses,
+            totalBots: botStatuses.length,
+            queues: queueStatus,
+        };
+    }
+    isRunningStatus() {
+        return this.isRunning;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    getOutboxService() {
+        return this.outboxService;
+    }
+    getBots() {
+        return this.bots;
+    }
+}
+exports.BotFleet = BotFleet;