botforje 0.0.1

package/dist/bot.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBot = createBot;
+exports.registerChannel = registerChannel;
+exports.createDefaultSettings = createDefaultSettings;
+const validation_1 = require("./config/validation");
+function createBot(props) {
+    (0, validation_1.validateId)(props.id, 'Bot');
+    return {
+        id: props.id,
+        phone: props.phone,
+        settings: props.settings,
+        graph: props.graph || '',
+    };
+}
+function registerChannel(bot, channel) {
+    bot.channel = channel;
+    return bot;
+}
+function createDefaultSettings() {
+    // TODO: simulateTyping, typingDelay, readReceipts are reserved for future implementation
+    return {
+        simulateTyping: true,
+        typingDelay: 1000,
+        queueDelay: 1000,
+        readReceipts: true,
+        ignoreGroups: true,
+        allowedSenders: [],
+        ignoredSenders: [],
+    };
+}

package/dist/cli/create-bot.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreateBot = runCreateBot;
+const inquirer_1 = __importDefault(require("inquirer"));
+const crypto_1 = require("crypto");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const client_1 = require("../whatsapp/client");
+const yaml_1 = require("../config/yaml");
+async function runCreateBot(configPath) {
+    if (configPath)
+        (0, yaml_1.setConfigPath)(configPath);
+    console.log('Welcome to WWeb BotForge!');
+    console.log('Let\'s create a new WhatsApp bot...\n');
+    try {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'botName',
+                message: 'What would you like to name your bot?',
+                validate: (input) => {
+                    if (input.trim().length === 0) {
+                        return 'Bot name cannot be empty';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        const botName = answers.botName.trim();
+        const botId = generateBotId(botName);
+        console.log(`\nGenerated bot ID: ${botId}`);
+        console.log(`Bot name: ${botName}`);
+        const initializer = new client_1.WhatsAppInitializer(botId);
+        let phoneNumber;
+        initializer.onQRCode((qr) => {
+            console.log('\nScan this QR code with WhatsApp to link your account:');
+            qrcode_terminal_1.default.generate(qr, { small: true });
+        });
+        initializer.onAuthSuccess((phone) => {
+            console.log('\nWhatsApp account linked successfully!');
+            console.log(`Connected to WhatsApp with phone: ${phone}`);
+            phoneNumber = phone;
+        });
+        initializer.onAuthFailure((error) => {
+            console.error('\nAuthentication failed:', error.message);
+            process.exit(1);
+        });
+        console.log('\nInitializing WhatsApp Web client...');
+        await initializer.initialize();
+        await new Promise((resolve) => {
+            const checkInterval = setInterval(() => {
+                if (phoneNumber) {
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 1000);
+        });
+        const botConfig = {
+            settings: {
+                queue_delay: 1000,
+                ignore_groups: true,
+                ignored_senders: ['status@broadcast'],
+            },
+        };
+        await (0, yaml_1.addBotConfig)(botId, botConfig, configPath);
+        console.log(`\nAdded new bot: ${botName} (${botId})`);
+        console.log(`Connected to WhatsApp with phone: ${phoneNumber}`);
+        console.log(`\nBot configuration saved to ${(0, yaml_1.getConfigPath)()}`);
+        console.log(`\nYour bot "${botName}" (${botId}) is now ready to use!`);
+        console.log('\nTo start using your bot, run: npm start');
+        await initializer.destroy();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('\nError creating bot:', error);
+        process.exit(1);
+    }
+}
+function generateBotId(name) {
+    const hash = (0, crypto_1.createHash)('md5').update(name.toLowerCase()).digest('hex');
+    return `bot-${hash.substring(0, 8)}`;
+}

package/dist/cli.js

@@ -0,0 +1,138 @@
+#!/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("./fleet");
+const outbox_1 = require("./messages/outbox");
+const server_1 = require("./api/server");
+const yaml_1 = require("./config/yaml");
+const watcher_1 = require("./config/watcher");
+const logger_1 = require("./helpers/logger");
+const client_1 = require("./whatsapp/client");
+const guide_1 = require("./commands/guide");
+const validate_1 = require("./commands/validate");
+const auth_1 = require("./commands/auth");
+const status_1 = require("./commands/status");
+const lock_1 = require("./commands/lock");
+const unlock_1 = require("./commands/unlock");
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const program = new commander_1.Command();
+program
+    .name('botforje')
+    .description('CLI tool for creating and managing WhatsApp bots')
+    .version(packageJson.version)
+    .option('-c, --config <path>', `Path to config file (default: ${(0, yaml_1.getDefaultConfigPath)()})`);
+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('guide')
+    .description('Show AI agent configuration guide')
+    .action(() => (0, guide_1.runGuide)());
+program
+    .command('validate')
+    .description('Validate bot configuration')
+    .action(() => (0, validate_1.runValidate)(program.opts().config));
+program
+    .command('daemon')
+    .alias('start')
+    .description('Start the WhatsApp bot daemon')
+    .action(async () => {
+    await runDaemon(program.opts().config);
+});
+program
+    .command('auth')
+    .description('Authenticate a bot session via QR code')
+    .argument('<botId>', 'Bot ID to authenticate')
+    .action(async (botId) => {
+    await (0, auth_1.runAuth)(botId, program.opts().config);
+});
+program
+    .command('lock')
+    .description('Enable API auth protection and generate a key')
+    .option('-k, --key <value>', 'Supply your own key (32+ characters)')
+    .action(async (options) => {
+    await (0, lock_1.runLock)(options.key, program.opts().config);
+});
+program
+    .command('unlock')
+    .description('Disable API auth protection')
+    .option('-k, --key <value>', 'Current auth key (will prompt if omitted)')
+    .action(async (options) => {
+    await (0, unlock_1.runUnlock)(options.key, program.opts().config);
+});
+program
+    .command('status')
+    .description('Show all bots and their session status')
+    .action(async () => {
+    await (0, status_1.runStatus)(program.opts().config);
+});
+async function runDaemon(configPath) {
+    if (configPath)
+        (0, yaml_1.setConfigPath)(configPath);
+    const configFile = await (0, yaml_1.loadConfig)(configPath);
+    if (configFile) {
+        (0, logger_1.setGlobalLogger)(configFile);
+        (0, client_1.setGlobalConfig)(configFile);
+    }
+    const logger = (0, logger_1.getLogger)();
+    logger.info('Botforje - Starting bots...');
+    const outboxService = new outbox_1.OutboxService();
+    const fleet = new fleet_1.BotFleet(outboxService);
+    const configWatcher = new watcher_1.ConfigWatcher(fleet);
+    configWatcher.start();
+    const bots = await fleet.start(configFile);
+    const address = configFile?.address || '127.0.0.1';
+    const authService = fleet.getAuthService();
+    if (address !== '127.0.0.1' && !authService.isLocked()) {
+        logger.warn('API is exposed on a non-local address. Run `botforje lock` to enable auth protection.');
+    }
+    if (configFile?.port) {
+        const apiPort = configFile.port;
+        const apiServer = new server_1.ApiServer(outboxService, bots, authService, apiPort, fleet, configWatcher, address);
+        await apiServer.start();
+    }
+    logger.info('Botforje Daemon is running');
+}
+program.parse();

package/dist/commands/auth.js

@@ -0,0 +1,200 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuth = runAuth;
+const http = __importStar(require("http"));
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const yaml_1 = require("../config/yaml");
+async function getApiBase(configPath) {
+    try {
+        if (configPath)
+            (0, yaml_1.setConfigPath)(configPath);
+        const config = await (0, yaml_1.loadConfig)(configPath);
+        const apiPort = config.port || 3000;
+        return `http://localhost:${apiPort}`;
+    }
+    catch {
+        return 'http://localhost:3000';
+    }
+}
+async function apiRequest(method, path, apiBase, body) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(path, apiBase);
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port,
+            path: urlObj.pathname,
+            method,
+            headers: { 'Content-Type': 'application/json' },
+        };
+        const req = http.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    resolve({ status: res.statusCode, data: JSON.parse(data) });
+                }
+                catch {
+                    resolve({ status: res.statusCode, data });
+                }
+            });
+        });
+        req.on('error', (err) => {
+            if (err.code === 'ECONNREFUSED') {
+                reject(new Error('Daemon is not running. Start it with: botforje daemon'));
+            }
+            else {
+                reject(err);
+            }
+        });
+        if (body)
+            req.write(JSON.stringify(body));
+        req.end();
+    });
+}
+function subscribeToSSE(urlStr, onEvent) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(urlStr);
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port,
+            path: urlObj.pathname,
+            method: 'GET',
+            headers: { Accept: 'text/event-stream' },
+        };
+        const req = http.request(options, (res) => {
+            if (res.statusCode !== 200) {
+                let data = '';
+                res.on('data', (chunk) => { data += chunk; });
+                res.on('end', () => reject(new Error(`SSE error ${res.statusCode}: ${data}`)));
+                return;
+            }
+            let buffer = '';
+            res.on('data', (chunk) => {
+                buffer += chunk.toString();
+                const parts = buffer.split('\n\n');
+                buffer = parts.pop() || '';
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    let eventType = 'message';
+                    let data = '';
+                    for (const line of lines) {
+                        if (line.startsWith('event: '))
+                            eventType = line.slice(7).trim();
+                        else if (line.startsWith('data: '))
+                            data = line.slice(6);
+                    }
+                    if (data) {
+                        try {
+                            onEvent(eventType, JSON.parse(data));
+                        }
+                        catch {
+                            onEvent(eventType, data);
+                        }
+                    }
+                }
+            });
+            res.on('end', resolve);
+            res.on('error', reject);
+        });
+        req.on('error', (err) => {
+            if (err.code === 'ECONNREFUSED') {
+                reject(new Error('Daemon is not running. Start it with: botforje daemon'));
+            }
+            else {
+                reject(err);
+            }
+        });
+        req.end();
+    });
+}
+async function runAuth(botId, configPath) {
+    try {
+        if (configPath)
+            (0, yaml_1.setConfigPath)(configPath);
+        const apiBase = await getApiBase(configPath);
+        console.log(`\nAuthenticating bot: ${botId}`);
+        console.log('Contacting daemon...\n');
+        const result = await apiRequest('POST', `/api/sessions/${botId}`, apiBase);
+        if (result.status === 409) {
+            console.log(`Bot "${botId}" is already authenticated.`);
+            return;
+        }
+        if (result.status !== 200) {
+            console.error(`Error: ${result.data?.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+        const state = result.data?.session?.state;
+        if (state === 'connected') {
+            console.log(`Bot "${botId}" is already connected!`);
+            return;
+        }
+        console.log('Waiting for QR code...');
+        console.log('(The QR code refreshes every 30 seconds if not scanned)\n');
+        let hasShownQR = false;
+        await subscribeToSSE(`${apiBase}/api/sessions/${botId}/events`, (eventType, data) => {
+            switch (eventType) {
+                case 'qr':
+                    if (!hasShownQR) {
+                        console.log('Scan this QR code with WhatsApp to link your account:\n');
+                        hasShownQR = true;
+                    }
+                    qrcode_terminal_1.default.generate(data, { small: true });
+                    break;
+                case 'ready':
+                    console.log('\nBot authenticated successfully!');
+                    process.exit(0);
+                case 'auth_failure':
+                    console.error(`\nAuthentication failed: ${data}`);
+                    process.exit(1);
+                case 'disconnected':
+                    console.log(`\nSession disconnected: ${data}`);
+                    break;
+            }
+        });
+    }
+    catch (error) {
+        if (error.message?.includes('Daemon is not running')) {
+            console.error(`\n${error.message}`);
+        }
+        else {
+            console.error(`\nError: ${error.message || error}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/create-bot.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreateBot = runCreateBot;
+const inquirer_1 = __importDefault(require("inquirer"));
+const yaml_1 = require("../config/yaml");
+const validation_1 = require("../helpers/validation");
+async function runCreateBot(configPath) {
+    if (configPath)
+        (0, yaml_1.setConfigPath)(configPath);
+    console.log('Welcome to WWeb BotForge!');
+    console.log('Let\'s create a new WhatsApp bot...\n');
+    try {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'botId',
+                message: 'Enter bot name identifier:',
+                validate: (input) => {
+                    const sanitized = input.trim().toLowerCase();
+                    if (sanitized.length === 0) {
+                        return 'Bot name cannot be empty';
+                    }
+                    try {
+                        (0, validation_1.validateId)(sanitized, 'Bot');
+                    }
+                    catch (e) {
+                        return e.message;
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'confirm',
+                name: 'authenticateNow',
+                message: 'Do you want to authenticate now? (daemon must be running)',
+                default: false,
+            },
+        ]);
+        const botId = answers.botId.trim().toLowerCase();
+        const botConfig = {
+            settings: {
+                queue_delay: 1000,
+                ignore_groups: true,
+                ignored_senders: ['status@broadcast'],
+            },
+        };
+        await (0, yaml_1.addBotConfig)(botId, botConfig, configPath);
+        console.log(`\nAdded bot: ${botId}`);
+        console.log(`Bot configuration saved.`);
+        if (answers.authenticateNow) {
+            console.log(`\nTo authenticate, run: botforge auth ${botId}`);
+            console.log('(Make sure the daemon is running first)');
+        }
+        console.log(`\nEdit ${(0, yaml_1.getConfigPath)()} to add flows and actions.`);
+        console.log('Then run: botforge daemon');
+    }
+    catch (error) {
+        console.error('\nError creating bot:', error);
+        process.exit(1);
+    }
+}