botforje 0.0.1

package/dist/actions/cooldown.js

@@ -0,0 +1,66 @@
+"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);
+    }
+    removeCooldown(sender, key) {
+        const senderCooldowns = this.cooldowns.get(sender);
+        if (senderCooldowns) {
+            senderCooldowns.delete(key);
+        }
+    }
+}
+exports.CooldownService = CooldownService;

package/dist/actions/request.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRequest = sendRequest;
+const logger_1 = require("../helpers/logger");
+async function sendRequest(call) {
+    const logger = (0, logger_1.getLogger)();
+    const maxRetries = call.retries || 1;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), call.timeout);
+        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: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            logger.debug(`Request successful: ${call.url}`);
+            return;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxRetries) {
+                const backoffMs = Math.pow(2, attempt - 1) * 1000;
+                logger.warn(`Request failed (attempt ${attempt}/${maxRetries}), retrying in ${backoffMs}ms: ${lastError.message}`);
+                await new Promise(resolve => setTimeout(resolve, backoffMs));
+            }
+        }
+    }
+    throw new Error(`Request failed after ${maxRetries} attempts: ${lastError?.message}`);
+}

package/dist/api/routes/auth.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRouter = createAuthRouter;
+exports.findSessionToken = findSessionToken;
+const express_1 = require("express");
+function parseCookie(cookie, name) {
+    if (!cookie)
+        return null;
+    for (const part of cookie.split(';')) {
+        const trimmed = part.trim();
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        if (trimmed.slice(0, eqIdx) === name) {
+            return trimmed.slice(eqIdx + 1);
+        }
+    }
+    return null;
+}
+function createAuthRouter(authService) {
+    const router = (0, express_1.Router)();
+    router.post('/login', (req, res) => {
+        const { key } = req.body;
+        if (!key || typeof key !== 'string') {
+            res.status(400).json({ error: 'key is required' });
+            return;
+        }
+        if (!authService.isLocked()) {
+            res.status(400).json({ error: 'Auth is not enabled. Run `botforje lock` first.' });
+            return;
+        }
+        if (!authService.verifyKey(key)) {
+            res.status(401).json({ error: 'Invalid key' });
+            return;
+        }
+        const session = authService.createSession();
+        res.setHeader('Set-Cookie', `botforje_session=${session.token}; HttpOnly; SameSite=Strict; Path=/; Max-Age=86400`);
+        res.json({ success: true, expiresAt: session.expiresAt });
+    });
+    router.post('/logout', (req, res) => {
+        const token = parseCookie(req.headers.cookie, 'botforje_session');
+        if (token) {
+            authService.invalidateSession(token);
+        }
+        res.setHeader('Set-Cookie', 'botforje_session=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0');
+        res.json({ success: true });
+    });
+    return router;
+}
+function findSessionToken(authService, cookieHeader) {
+    const token = parseCookie(cookieHeader, 'botforje_session');
+    if (!token)
+        return null;
+    const session = authService.validateSession(token);
+    return session ? token : null;
+}

package/dist/api/routes/bots.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBotsRouter = createBotsRouter;
+const express_1 = require("express");
+function createBotsRouter(bots) {
+    const router = (0, express_1.Router)();
+    router.get('/', (req, res) => {
+        try {
+            const botList = Array.from(bots.values()).map(bot => ({
+                id: bot.id,
+                phone: bot.phone,
+                graph: bot.graph,
+                settings: bot.settings,
+            }));
+            res.json({
+                bots: botList,
+                total: botList.length,
+            });
+        }
+        catch (error) {
+            console.error('Error getting bots:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+            });
+        }
+    });
+    router.get('/:botId', (req, res) => {
+        try {
+            const { botId } = req.params;
+            if (!bots.has(botId)) {
+                return res.status(404).json({
+                    error: `Bot with id '${botId}' not found`,
+                });
+            }
+            const bot = bots.get(botId);
+            res.json({
+                id: bot.id,
+                phone: bot.phone,
+                graph: bot.graph,
+                settings: bot.settings,
+            });
+        }
+        catch (error) {
+            console.error('Error getting bot:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+            });
+        }
+    });
+    return router;
+}

package/dist/api/routes/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigRouter = createConfigRouter;
+const express_1 = require("express");
+const logger_1 = require("../../helpers/logger");
+function createConfigRouter(fleet, configWatcher) {
+    const router = (0, express_1.Router)();
+    router.post('/reload', async (req, res) => {
+        try {
+            await configWatcher.reload();
+            res.json({ success: true, message: 'Configuration reloaded' });
+        }
+        catch (error) {
+            (0, logger_1.getLogger)().error('Config reload error:', error);
+            res.status(500).json({ error: error.message || 'Reload failed' });
+        }
+    });
+    router.get('/status', (req, res) => {
+        res.json({
+            watching: configWatcher.isWatching(),
+        });
+    });
+    return router;
+}

package/dist/api/routes/health.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHealthRouter = createHealthRouter;
+const express_1 = require("express");
+function createHealthRouter() {
+    const router = (0, express_1.Router)();
+    router.get('/', (req, res) => {
+        res.json({
+            status: 'ok',
+            timestamp: new Date().toISOString(),
+            service: 'Botforje API',
+        });
+    });
+    return router;
+}

package/dist/api/routes/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiRoutes = createApiRoutes;
+const express_1 = require("express");
+const health_1 = require("./health");
+const messages_1 = require("./messages");
+const bots_1 = require("./bots");
+function createApiRoutes(outboxService, bots) {
+    const router = (0, express_1.Router)();
+    router.use('/health', (0, health_1.createHealthRouter)());
+    router.use('/messages', (0, messages_1.createMessagesRouter)(outboxService, bots));
+    router.use('/bots', (0, bots_1.createBotsRouter)(bots));
+    return router;
+}

package/dist/api/routes/messages.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagesRouter = createMessagesRouter;
+const express_1 = require("express");
+function createMessagesRouter(outboxService, bots) {
+    const router = (0, express_1.Router)();
+    router.post('/send', (req, res) => {
+        try {
+            const { botId, to, content, metadata } = req.body;
+            if (!botId || !to || !content) {
+                return res.status(400).json({
+                    error: 'Missing required fields: botId, to, content',
+                });
+            }
+            if (!bots.has(botId)) {
+                return res.status(404).json({
+                    error: `Bot with id '${botId}' not found`,
+                });
+            }
+            const messageId = outboxService.enqueue(botId, to, content, metadata);
+            res.json({
+                success: true,
+                messageId,
+                botId,
+                queued: true,
+            });
+        }
+        catch (error) {
+            console.error('Error sending message:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+            });
+        }
+    });
+    router.get('/queue/:botId', (req, res) => {
+        try {
+            const { botId } = req.params;
+            if (!bots.has(botId)) {
+                return res.status(404).json({
+                    error: `Bot with id '${botId}' not found`,
+                });
+            }
+            const queueStatus = outboxService.getBotQueueStatus(botId);
+            res.json({
+                botId,
+                queue: queueStatus,
+            });
+        }
+        catch (error) {
+            console.error('Error getting queue status:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+            });
+        }
+    });
+    router.get('/queue', (req, res) => {
+        try {
+            const queueStatus = outboxService.getAllQueuesStatus();
+            res.json(queueStatus);
+        }
+        catch (error) {
+            console.error('Error getting all queues status:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+            });
+        }
+    });
+    return router;
+}

package/dist/api/routes/sessions.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionsRouter = createSessionsRouter;
+const express_1 = require("express");
+const session_1 = require("../../whatsapp/session");
+const logger_1 = require("../../helpers/logger");
+function createSessionsRouter() {
+    const router = (0, express_1.Router)();
+    const sessionManager = session_1.SessionManager.getInstance();
+    const logger = (0, logger_1.getLogger)();
+    router.post('/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const existingInfo = sessionManager.getSessionInfo(id);
+            if (existingInfo?.state === 'connected') {
+                return res.status(409).json({
+                    error: `Session "${id}" is already authenticated`,
+                    session: existingInfo,
+                });
+            }
+            if (existingInfo && (existingInfo.state === 'qr_received' || existingInfo.state === 'pending')) {
+                return res.json({
+                    success: true,
+                    id,
+                    session: existingInfo,
+                    note: 'Session already pending, subscribe to events',
+                });
+            }
+            await sessionManager.registerSession(id);
+            const info = sessionManager.getSessionInfo(id);
+            res.json({
+                success: true,
+                id,
+                session: info,
+            });
+        }
+        catch (error) {
+            logger.error(`Error registering session: ${error.message || String(error)}`);
+            res.status(500).json({ error: error.message || 'Internal server error' });
+        }
+    });
+    router.get('/:id', (req, res) => {
+        const { id } = req.params;
+        const info = sessionManager.getSessionInfo(id);
+        if (!info) {
+            return res.status(404).json({ error: `Session "${id}" not found` });
+        }
+        res.json({ id, session: info });
+    });
+    router.delete('/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            if (!sessionManager.hasChannel(id)) {
+                return res.status(404).json({ error: `Session "${id}" not found` });
+            }
+            await sessionManager.removeChannel(id);
+            res.json({ success: true, id });
+        }
+        catch (error) {
+            logger.error(`Error removing session: ${error.message || String(error)}`);
+            res.status(500).json({ error: error.message || 'Internal server error' });
+        }
+    });
+    router.get('/:id/events', (req, res) => {
+        const { id } = req.params;
+        if (!sessionManager.hasChannel(id)) {
+            return res.status(404).json({ error: `Session "${id}" not found` });
+        }
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        const handler = (event) => {
+            try {
+                res.write(`event: ${event.type}\n`);
+                res.write(`data: ${JSON.stringify(event.data ?? {})}\n\n`);
+            }
+            catch {
+                // connection closed
+            }
+        };
+        sessionManager.onSessionEvent(id, handler);
+        req.on('close', () => {
+            sessionManager.removeSessionEventListener(id, handler);
+        });
+    });
+    router.get('/', (req, res) => {
+        const sessions = Array.from(sessionManager.getAllSessions().entries()).map(([id, info]) => ({
+            id,
+            ...info,
+        }));
+        res.json({ sessions, total: sessions.length });
+    });
+    return router;
+}

package/dist/api/routes/status.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatusRouter = createStatusRouter;
+const express_1 = require("express");
+const session_1 = require("../../whatsapp/session");
+const logger_1 = require("../../helpers/logger");
+function createStatusRouter(bots) {
+    const router = (0, express_1.Router)();
+    const sessionManager = session_1.SessionManager.getInstance();
+    router.get('/', (req, res) => {
+        try {
+            const logger = (0, logger_1.getLogger)();
+            const botStatuses = Array.from(bots.entries()).map(([id, bot]) => {
+                const sessionInfo = sessionManager.getSessionInfo(id);
+                return {
+                    id,
+                    graph: bot.graph,
+                    phone: sessionInfo?.phone || bot.phone || null,
+                    session: sessionInfo ? {
+                        state: sessionInfo.state,
+                        lastQR: sessionInfo.lastQR ? true : false,
+                        error: sessionInfo.error || null,
+                    } : null,
+                };
+            });
+            res.json({
+                running: true,
+                bots: botStatuses,
+                total: botStatuses.length,
+            });
+        }
+        catch (error) {
+            (0, logger_1.getLogger)().error('Error getting status:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    return router;
+}

package/dist/api/server.js

@@ -0,0 +1,153 @@
+"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.ApiServer = void 0;
+const express_1 = __importStar(require("express"));
+const health_1 = require("./routes/health");
+const bots_1 = require("./routes/bots");
+const messages_1 = require("./routes/messages");
+const sessions_1 = require("./routes/sessions");
+const status_1 = require("./routes/status");
+const config_1 = require("./routes/config");
+const auth_1 = require("./routes/auth");
+const logger_1 = require("../helpers/logger");
+class ApiServer {
+    constructor(outboxService, bots, authService, port = 3000, fleet, configWatcher, address = '127.0.0.1') {
+        this.app = (0, express_1.default)();
+        this.port = port;
+        this.address = address;
+        this.authService = authService;
+        this.outboxService = outboxService;
+        this.bots = bots;
+        this.fleet = fleet;
+        this.configWatcher = configWatcher;
+        this.setupMiddleware();
+        this.setupAuth();
+        this.setupRoutes();
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    setupMiddleware() {
+        this.app.use(express_1.default.json());
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+    }
+    setupAuth() {
+        this.app.use('/api', (req, res, next) => {
+            if (req.path === '/health')
+                return next();
+            if (!this.authService.isLocked())
+                return next();
+            const sessionToken = (0, auth_1.findSessionToken)(this.authService, req.headers.cookie);
+            if (sessionToken)
+                return next();
+            const auth = req.headers.authorization;
+            if (auth && auth.startsWith('Bearer ')) {
+                const key = auth.slice(7);
+                if (this.authService.verifyKey(key))
+                    return next();
+            }
+            res.status(401).json({ error: 'Unauthorized' });
+        });
+    }
+    setupRoutes() {
+        const api = (0, express_1.Router)();
+        api.use('/health', (0, health_1.createHealthRouter)());
+        api.use('/auth', (0, auth_1.createAuthRouter)(this.authService));
+        api.use('/bots', (0, bots_1.createBotsRouter)(this.bots));
+        api.use('/messages', (0, messages_1.createMessagesRouter)(this.outboxService, this.bots));
+        api.use('/sessions', (0, sessions_1.createSessionsRouter)());
+        api.use('/status', (0, status_1.createStatusRouter)(this.bots));
+        if (this.fleet && this.configWatcher) {
+            api.use('/config', (0, config_1.createConfigRouter)(this.fleet, this.configWatcher));
+        }
+        this.app.use('/api', api);
+        this.app.get('/', (req, res) => {
+            const endpoints = {
+                health: '/api/health',
+                auth: '/api/auth',
+                messages: '/api/messages',
+                bots: '/api/bots',
+                sessions: '/api/sessions',
+                status: '/api/status',
+            };
+            if (this.fleet && this.configWatcher) {
+                endpoints.config = '/api/config';
+            }
+            res.json({
+                service: 'Botforje API',
+                endpoints,
+            });
+        });
+        this.app.use((req, res) => {
+            res.status(404).json({
+                error: 'Endpoint not found',
+            });
+        });
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = this.app.listen(this.port, this.address, () => {
+                this.logger.info(`API Server started on ${this.address}:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.logger.info('API Server stopped');
+                    resolve();
+                });
+            }
+            else {
+                this.logger.info('API Server stopped');
+                resolve();
+            }
+        });
+    }
+}
+exports.ApiServer = ApiServer;