botforje 0.0.1

package/dist/config/watcher.js

@@ -0,0 +1,145 @@
+"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.ConfigWatcher = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("./yaml");
+const mapper_1 = require("./mapper");
+const logger_1 = require("../helpers/logger");
+class ConfigWatcher {
+    constructor(fleet, configPath) {
+        this.watcher = null;
+        this.debounceTimer = null;
+        this.watching = false;
+        this.fleet = fleet;
+        this.configPath = configPath || (0, yaml_1.getConfigPath)();
+        this.configDir = path.dirname(this.configPath);
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    start() {
+        if (this.watching)
+            return;
+        try {
+            this.watcher = fs.watch(this.configDir, { recursive: true }, (eventType, filename) => {
+                if (!filename)
+                    return;
+                const ext = path.extname(filename);
+                if (ext !== '.yml' && ext !== '.yaml')
+                    return;
+                if (this.debounceTimer)
+                    clearTimeout(this.debounceTimer);
+                this.debounceTimer = setTimeout(() => {
+                    this.reload().catch(err => {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        this.logger.error(`Config reload error: ${msg}`);
+                    });
+                }, 500);
+            });
+            this.watching = true;
+            this.logger.info(`Config watcher started on ${this.configDir}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`Failed to start config watcher: ${msg}`);
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.watching = false;
+    }
+    isWatching() {
+        return this.watching;
+    }
+    async reload() {
+        try {
+            this.logger.info('Reloading configuration...');
+            const configFile = await (0, yaml_1.loadConfig)(this.configPath);
+            const newActionCatalog = (0, mapper_1.mapActionCatalog)(configFile.actions || {});
+            const newGraphCatalog = (0, mapper_1.mapGraphCatalog)(configFile.graphs || {});
+            const loadedBots = (0, mapper_1.mapBotsFromConfig)(configFile.bots);
+            this.fleet.reloadCatalogs(newActionCatalog, newGraphCatalog);
+            const existingBots = this.fleet.getBots();
+            const existingIds = new Set(existingBots.keys());
+            const newIds = new Set(loadedBots.map(b => b.id));
+            for (const bot of loadedBots) {
+                if (!existingIds.has(bot.id)) {
+                    existingBots.set(bot.id, bot);
+                    this.fleet.getOutboxService().setupBotQueue(bot);
+                    this.logger.info(`New bot added via reload: ${bot.id}`);
+                    this.logger.debug(`  allowed_senders=[${bot.settings.allowedSenders.join(', ')}]`);
+                }
+                else {
+                    const existing = existingBots.get(bot.id);
+                    if (existing) {
+                        const graphChanged = existing.graph !== bot.graph;
+                        existing.settings = bot.settings;
+                        existing.graph = bot.graph;
+                        if (graphChanged) {
+                            this.fleet.getGraphExecutor()?.clearBotSessions(bot.id);
+                            this.logger.info(`Graph changed for bot "${bot.id}" — active sessions cleared`);
+                        }
+                        this.logger.info(`Bot updated via reload: ${bot.id}`);
+                        this.logger.debug(`  allowed_senders=[${bot.settings.allowedSenders.join(', ')}]`);
+                    }
+                }
+            }
+            for (const id of existingIds) {
+                if (!newIds.has(id)) {
+                    const bot = existingBots.get(id);
+                    if (bot) {
+                        existingBots.delete(id);
+                        this.logger.info(`Bot removed via reload: ${id}`);
+                    }
+                }
+            }
+            this.logger.info('Configuration reloaded successfully');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to reload configuration: ${msg}`);
+        }
+    }
+}
+exports.ConfigWatcher = ConfigWatcher;

package/dist/config/yaml.js

@@ -0,0 +1,197 @@
+"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.getDefaultConfigPath = getDefaultConfigPath;
+exports.getConfigPath = getConfigPath;
+exports.setConfigPath = setConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.addBotConfig = addBotConfig;
+const yaml = __importStar(require("js-yaml"));
+const fs = __importStar(require("fs/promises"));
+const fsSync = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("../helpers/logger");
+let configPath;
+function getDefaultConfigPath() {
+    const home = process.env.HOME || os.homedir();
+    return path.join(home, '.config', 'botforje', 'config.yml');
+}
+function getConfigPath() {
+    return configPath || getDefaultConfigPath();
+}
+function setConfigPath(newPath) {
+    configPath = newPath;
+}
+async function processIncludes(content, baseDir) {
+    const lines = content.split('\n');
+    const processedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const includeMatch = line.match(/^\s*-\s*!include\s+(.+)$/);
+        if (includeMatch) {
+            const includePath = path.resolve(baseDir, includeMatch[1]);
+            const includedContent = await fs.readFile(includePath, 'utf8');
+            const indent = line.match(/^\s*/)?.[0] || '';
+            const indentedContent = includedContent
+                .split('\n')
+                .map((line, index) => index === 0 ? indent + '- ' + line : indent + '  ' + line)
+                .join('\n');
+            processedLines.push(indentedContent);
+        }
+        else {
+            processedLines.push(line);
+        }
+    }
+    return processedLines.join('\n');
+}
+async function loadActionsFromDir(dirPath) {
+    const actions = {};
+    if (!fsSync.existsSync(dirPath)) {
+        return actions;
+    }
+    const entries = await fs.readdir(dirPath);
+    const files = entries.filter(file => file.endsWith('.yml') || file.endsWith('.yaml'));
+    for (const file of files) {
+        const id = path.basename(file, path.extname(file));
+        const filePath = path.join(dirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const parsed = yaml.load(content);
+        if (parsed && typeof parsed === 'object') {
+            actions[id] = parsed;
+        }
+    }
+    return actions;
+}
+async function loadGraphsFromDir(dirPath) {
+    const graphs = {};
+    if (!fsSync.existsSync(dirPath)) {
+        return graphs;
+    }
+    const entries = await fs.readdir(dirPath);
+    const files = entries.filter(file => file.endsWith('.yml') || file.endsWith('.yaml'));
+    for (const file of files) {
+        const id = path.basename(file, path.extname(file));
+        const filePath = path.join(dirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const parsed = yaml.load(content);
+        if (parsed && typeof parsed === 'object' && parsed.nodes) {
+            graphs[id] = parsed;
+        }
+    }
+    return graphs;
+}
+async function loadBotsFromDir(dirPath) {
+    const bots = {};
+    if (!fsSync.existsSync(dirPath)) {
+        return bots;
+    }
+    const entries = await fs.readdir(dirPath);
+    const files = entries.filter(file => file.endsWith('.yml') || file.endsWith('.yaml'));
+    for (const file of files) {
+        const id = path.basename(file, path.extname(file));
+        const filePath = path.join(dirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const parsed = yaml.load(content);
+        if (parsed && typeof parsed === 'object') {
+            bots[id] = parsed;
+        }
+    }
+    return bots;
+}
+async function loadConfig(customPath) {
+    const targetPath = customPath || getConfigPath();
+    const logger = (0, logger_1.getLogger)();
+    try {
+        const rawContent = await fs.readFile(targetPath, 'utf-8');
+        const processedContent = await processIncludes(rawContent, path.dirname(targetPath));
+        const config = yaml.load(processedContent);
+        if (config.bots !== undefined && config.bots !== null) {
+            if (typeof config.bots !== 'object' || Array.isArray(config.bots)) {
+                throw new Error('Configuration must contain a "bots" object');
+            }
+        }
+        const baseDir = path.dirname(targetPath);
+        const actionsFromDir = await loadActionsFromDir(path.join(baseDir, 'actions'));
+        const graphsFromDir = await loadGraphsFromDir(path.join(baseDir, 'graphs'));
+        const botsFromDir = await loadBotsFromDir(path.join(baseDir, 'bots'));
+        config.actions = { ...actionsFromDir, ...config.actions };
+        config.graphs = { ...graphsFromDir, ...config.graphs };
+        config.bots = { ...botsFromDir, ...config.bots };
+        if (!config.bots || typeof config.bots !== 'object' || Object.keys(config.bots).length === 0) {
+            throw new Error('Configuration must contain a "bots" object with at least one bot');
+        }
+        return config;
+    }
+    catch (error) {
+        throw new Error(`Failed to read configuration from ${targetPath}: ${error}`);
+    }
+}
+async function saveConfig(config, customPath) {
+    const targetPath = customPath || getConfigPath();
+    try {
+        const configDir = path.dirname(targetPath);
+        if (!fsSync.existsSync(configDir)) {
+            await fs.mkdir(configDir, { recursive: true });
+        }
+        const yamlContent = yaml.dump(config, {
+            indent: 2,
+            lineWidth: -1,
+            noRefs: true,
+        });
+        await fs.writeFile(targetPath, yamlContent, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write configuration to ${targetPath}: ${error}`);
+    }
+}
+async function addBotConfig(id, botConfig, customPath) {
+    const configDir = path.dirname(customPath || getConfigPath());
+    const botsDir = path.join(configDir, 'bots');
+    const botFilePath = path.join(botsDir, `${id}.yml`);
+    if (!fsSync.existsSync(botsDir)) {
+        await fs.mkdir(botsDir, { recursive: true });
+    }
+    if (fsSync.existsSync(botFilePath)) {
+        throw new Error(`Bot with ID "${id}" already exists at ${botFilePath}`);
+    }
+    const yamlContent = yaml.dump(botConfig, { indent: 2, lineWidth: -1, noRefs: true });
+    await fs.writeFile(botFilePath, yamlContent, 'utf-8');
+    const mainConfigPath = customPath || getConfigPath();
+    if (!fsSync.existsSync(mainConfigPath)) {
+        await saveConfig({ bots: {} }, mainConfigPath);
+    }
+}

package/dist/fleet.js

@@ -0,0 +1,247 @@
+"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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mapper_1 = require("./config/mapper");
+const cooldown_1 = require("./actions/cooldown");
+const inbox_1 = require("./messages/inbox");
+const state_1 = require("./graph/state");
+const executor_1 = require("./graph/executor");
+const session_1 = require("./whatsapp/session");
+const service_1 = require("./auth/service");
+const logger_1 = require("./helpers/logger");
+const data_1 = require("./helpers/data");
+class BotFleet {
+    constructor(outboxService) {
+        this.bots = new Map();
+        this.actionCatalog = new Map();
+        this.graphCatalog = 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, mapper_1.mapActionCatalog)(configFile.actions || {});
+            this.graphCatalog = (0, mapper_1.mapGraphCatalog)(configFile.graphs || {});
+            const dataDir = (0, data_1.getDataDir)();
+            fs.mkdirSync(dataDir, { recursive: true });
+            const dbPath = path.join(dataDir, 'botforje.db');
+            this.graphStateService = new state_1.GraphStateService(dbPath);
+            this.authService = new service_1.AuthService(dbPath);
+            const graphStateTimeout = configFile.default_timeout ?? 300;
+            this.graphExecutor = new executor_1.GraphExecutor(this.actionCatalog, this.graphCatalog, this.graphStateService, this.outboxService, graphStateTimeout, this.cooldownService);
+            this.inboxService = new inbox_1.InboxService(this.graphExecutor);
+            if (Object.keys(configFile.bots).length === 0) {
+                this.logger.warn('No bots configured.');
+                return this.bots;
+            }
+            const loadedBots = (0, mapper_1.mapBotsFromConfig)(configFile.bots);
+            this.logger.debug(`Initializing ${loadedBots.length} bot(s)...`);
+            for (const bot of loadedBots) {
+                this.logger.debug(`Bot "${bot.id}" settings: allowed_senders=[${bot.settings.allowedSenders.join(', ')}]`);
+                this.registerBot(bot);
+            }
+            this.isRunning = true;
+            this.logger.info('Waiting for bot connections...');
+            this.setupGracefulShutdown();
+            return this.bots;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to start Bot Fleet Launcher: ${msg}`);
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.logger.info('Stopping Botforje...');
+        try {
+            await this.outboxService.shutdown();
+            await this.sessionManager.removeAllChannels();
+            this.graphStateService?.close();
+            this.authService?.close();
+            this.bots.clear();
+            this.isRunning = false;
+            this.logger.info('Botforje stopped successfully');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Error stopping Bot Fleet: ${msg}`);
+            throw error;
+        }
+    }
+    registerBot(bot) {
+        this.logger.info(`Registering bot: ${bot.id}`);
+        this.bots.set(bot.id, bot);
+        this.outboxService.setupBotQueue(bot);
+        this.sessionManager.onSessionReady(bot.id, (channel) => {
+            this.linkSessionToBot(bot, channel);
+        });
+        this.sessionManager.registerSession(bot.id).catch((err) => {
+            this.logger.warn(`Bot "${bot.id}" session registration failed: ${err.message}`);
+        });
+    }
+    linkSessionToBot(bot, channel) {
+        bot.channel = channel;
+        this.inboxService.registerBot(bot);
+        this.setupBotEventHandlers(bot);
+        const phone = channel.getPhone();
+        if (phone) {
+            bot.phone = phone;
+        }
+        this.logger.info(`Bot "${bot.id}" linked to session`);
+    }
+    setupBotEventHandlers(bot) {
+        if (!bot.channel)
+            return;
+        bot.channel.onReady(() => {
+            this.logger.info(`Bot "${bot.id}" is ready!`);
+            const phone = bot.channel.getPhone();
+            if (phone) {
+                bot.phone = phone;
+            }
+        });
+        bot.channel.onDisconnected((reason) => {
+            this.logger.warn(`Bot "${bot.id}" disconnected: ${reason}`);
+        });
+        bot.channel.onAuthFailure((error) => {
+            this.logger.error(`Bot "${bot.id}" authentication failed: ${error.message}`);
+        });
+        bot.channel.onConnectionError((error) => {
+            this.logger.error(`Bot "${bot.id}" connection error: ${error.message}`);
+        });
+        bot.channel.onStateChange((state) => {
+            this.logger.info(`Bot "${bot.id}" state changed to: ${state}`);
+        });
+        bot.channel.onAuthRequired?.((info) => {
+            this.logger.info(`QR auth required for bot "${bot.id}"`);
+        });
+    }
+    linkExistingSession(botId) {
+        const bot = this.bots.get(botId);
+        if (!bot) {
+            this.logger.warn(`Cannot link session: bot "${botId}" not found`);
+            return;
+        }
+        const channel = this.sessionManager.getChannel(botId);
+        if (!channel) {
+            this.logger.warn(`Cannot link session: no session for "${botId}"`);
+            return;
+        }
+        this.linkSessionToBot(bot, channel);
+    }
+    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) => {
+            const msg = error instanceof Error ? error.stack || error.message : String(error);
+            this.logger.error(`Uncaught Exception: ${msg}`);
+            this.stop().finally(() => process.exit(1));
+        });
+        process.on('unhandledRejection', (reason) => {
+            const msg = reason instanceof Error ? reason.stack || reason.message : String(reason);
+            this.logger.error(`Unhandled Rejection: ${msg}`);
+            this.stop().finally(() => process.exit(1));
+        });
+    }
+    getStatus() {
+        const botStatuses = Array.from(this.bots.values()).map(bot => {
+            const queueStatus = this.outboxService.getBotQueueStatus(bot.id);
+            const sessionInfo = this.sessionManager.getSessionInfo(bot.id);
+            return {
+                id: bot.id,
+                graph: bot.graph,
+                session: sessionInfo ? {
+                    state: sessionInfo.state,
+                    phone: sessionInfo.phone,
+                } : null,
+                queue: {
+                    size: queueStatus.queueSize,
+                    delayMs: queueStatus.delayMs,
+                    isProcessing: queueStatus.isProcessing,
+                    hasCallback: queueStatus.hasCallback,
+                },
+            };
+        });
+        return {
+            isRunning: this.isRunning,
+            bots: botStatuses,
+            totalBots: botStatuses.length,
+        };
+    }
+    isRunningStatus() {
+        return this.isRunning;
+    }
+    getOutboxService() {
+        return this.outboxService;
+    }
+    getBots() {
+        return this.bots;
+    }
+    reloadCatalogs(actionCatalog, graphCatalog) {
+        this.actionCatalog = actionCatalog;
+        this.graphCatalog = graphCatalog;
+        this.graphExecutor?.updateCatalogs(actionCatalog, graphCatalog);
+    }
+    getGraphExecutor() {
+        return this.graphExecutor;
+    }
+    getAuthService() {
+        if (!this.authService) {
+            throw new Error('AuthService not initialized. Call start() first.');
+        }
+        return this.authService;
+    }
+}
+exports.BotFleet = BotFleet;