botforje 0.0.1

package/dist/commands/status.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.runStatus = runStatus;
+const http = __importStar(require("http"));
+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 apiGet(path, apiBase) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(path, apiBase);
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port,
+            path: urlObj.pathname,
+            method: 'GET',
+        };
+        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);
+            }
+        });
+        req.end();
+    });
+}
+function stateToSymbol(state) {
+    switch (state) {
+        case 'connected': return '\u{1F7E2}';
+        case 'qr_received': return '\u{1F7E0}';
+        case 'pending': return '\u{1F535}';
+        case 'disconnected': return '\u{1F534}';
+        case 'auth_failure': return '\u{1F534}';
+        default: return '\u26AA';
+    }
+}
+function stateLabel(state) {
+    switch (state) {
+        case 'connected': return 'connected';
+        case 'qr_received': return 'awaiting QR';
+        case 'pending': return 'pending';
+        case 'disconnected': return 'disconnected';
+        case 'auth_failure': return 'auth failed';
+        default: return 'unknown';
+    }
+}
+async function runStatus(configPath) {
+    try {
+        if (configPath)
+            (0, yaml_1.setConfigPath)(configPath);
+        const apiBase = await getApiBase(configPath);
+        const result = await apiGet('/api/status', apiBase);
+        if (result.status !== 200) {
+            console.error(`Error: ${result.data?.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+        const bots = result.data?.bots || [];
+        if (bots.length === 0) {
+            console.log('No bots configured.');
+            return;
+        }
+        console.log('\nBot Status:');
+        console.log('─'.repeat(60));
+        for (const bot of bots) {
+            const session = bot.session;
+            const state = session?.state || 'none';
+            const symbol = stateToSymbol(state);
+            const label = stateLabel(state);
+            const phone = bot.phone || session?.phone || '-';
+            const graph = bot.graph || '-';
+            console.log(`  ${symbol} ${bot.id}`);
+            console.log(`     State:  ${label}`);
+            console.log(`     Phone:  ${phone}`);
+            console.log(`     Graph:  ${graph}`);
+            console.log('');
+        }
+        console.log(`Total: ${bots.length} bot(s) configured`);
+        console.log('');
+    }
+    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/unlock.js

@@ -0,0 +1,88 @@
+"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.runUnlock = runUnlock;
+const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const service_1 = require("../auth/service");
+const yaml_1 = require("../config/yaml");
+const data_1 = require("../helpers/data");
+function promptHidden(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+async function runUnlock(key, configPath) {
+    try {
+        if (configPath)
+            (0, yaml_1.setConfigPath)(configPath);
+        await (0, yaml_1.loadConfig)(configPath);
+        const dataDir = (0, data_1.getDataDir)();
+        fs.mkdirSync(dataDir, { recursive: true });
+        const dbPath = path.join(dataDir, 'botforje.db');
+        const auth = new service_1.AuthService(dbPath);
+        if (!auth.isLocked()) {
+            console.log('Botforje is not locked. Nothing to do.');
+            process.exit(0);
+        }
+        const providedKey = key || await promptHidden('Enter current auth key: ');
+        if (!providedKey) {
+            console.error('Key is required.');
+            process.exit(1);
+        }
+        const success = auth.unlock(providedKey);
+        if (success) {
+            console.log('\nBotforje unlocked successfully. Auth is no longer required.');
+            console.log('All active sessions have been invalidated.\n');
+            process.exit(0);
+        }
+        else {
+            console.error('\nInvalid key. Unlock failed.\n');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`\nError: ${error.message || error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/validate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidate = runValidate;
+const validation_1 = require("../config/validation");
+const yaml_1 = require("../config/yaml");
+async function runValidate(configPath) {
+    if (configPath)
+        (0, yaml_1.setConfigPath)(configPath);
+    const result = await (0, validation_1.validateConfig)(configPath);
+    if (result.valid) {
+        console.log('Config OK');
+        return;
+    }
+    for (const err of result.errors) {
+        const location = err.line ? `${err.file}:${err.line}` : err.file;
+        console.log(`${location}: ${err.message}`);
+    }
+    process.exit(1);
+}

package/dist/config/mapper.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapActionCatalog = mapActionCatalog;
+exports.mapGraphCatalog = mapGraphCatalog;
+exports.mapBotsFromConfig = mapBotsFromConfig;
+exports.mapConfigToBot = mapConfigToBot;
+exports.mapSettings = mapSettings;
+const bot_1 = require("../bot");
+const validation_1 = require("./validation");
+function mapActionCatalog(config) {
+    const catalog = new Map();
+    for (const [id, actionConfig] of Object.entries(config)) {
+        catalog.set(id, mapAction(id, actionConfig));
+    }
+    return catalog;
+}
+function mapAction(id, config) {
+    const hasSteps = (config.steps?.length ?? 0) > 0;
+    const hasOnBlocked = (config.guards?.cooldown?.on_blocked?.length ?? 0) > 0;
+    if (!hasSteps && !hasOnBlocked) {
+        throw new Error(`Action "${id}" must define steps or a cooldown guard with on_blocked`);
+    }
+    return {
+        id,
+        guards: config.guards ? mapGuards(config.guards) : undefined,
+        steps: (config.steps ?? []).map(mapStep),
+    };
+}
+function mapStep(config) {
+    if (config.message)
+        return { message: mapMessage(config.message) };
+    if (config.request)
+        return { request: mapRequestStep(config.request) };
+    return { location: mapLocationAction(config.location) };
+}
+function mapMessage(config) {
+    return {
+        body: config.body,
+        to: config.to,
+    };
+}
+function mapGuards(config) {
+    const result = {};
+    if (config.cooldown) {
+        result.cooldown = {
+            duration: config.cooldown.duration,
+            onBlocked: config.cooldown.on_blocked?.map(mapStep),
+        };
+    }
+    return result;
+}
+function mapRequestStep(config) {
+    return {
+        name: config.name,
+        url: config.url,
+        method: config.method ?? 'POST',
+        headers: config.headers ?? {},
+        timeout: config.timeout ?? 5000,
+        retries: config.retry ?? 3,
+    };
+}
+function mapLocationAction(config) {
+    return {
+        latitude: config.latitude,
+        longitude: config.longitude,
+        name: config.name,
+        address: config.address,
+        url: config.url,
+        description: config.description,
+    };
+}
+function mapGraphCatalog(config) {
+    const catalog = new Map();
+    for (const [id, graphConfig] of Object.entries(config)) {
+        catalog.set(id, mapGraph(id, graphConfig));
+    }
+    return catalog;
+}
+function mapGraph(id, config) {
+    if (!config.nodes[config.root]) {
+        throw new Error(`Graph "${id}" root node "${config.root}" not found`);
+    }
+    const nodes = {};
+    for (const [nodeId, nodeConfig] of Object.entries(config.nodes)) {
+        nodes[nodeId] = mapNode(nodeConfig);
+    }
+    if (config.fallback && !nodes[config.fallback]) {
+        throw new Error(`Graph "${id}" fallback node "${config.fallback}" not found`);
+    }
+    return {
+        id,
+        root: config.root,
+        timeout: config.timeout,
+        fallbackNode: config.fallback,
+        nodes,
+    };
+}
+function mapNode(config) {
+    return {
+        action: config.action,
+        edges: (config.edges || []).map(mapEdge),
+    };
+}
+function mapEdge(config) {
+    return {
+        match: config.match ? mapMatch(config.match) : undefined,
+        fuzzyThreshold: config.fuzzy_threshold,
+        goto: config.goto,
+    };
+}
+function mapMatch(match) {
+    if (typeof match === 'string') {
+        return splitPhrases(match);
+    }
+    return match.flatMap(splitPhrases);
+}
+function splitPhrases(value) {
+    return value
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}
+function mapBotsFromConfig(configs) {
+    return Object.entries(configs).map(([id, config]) => mapConfigToBot(id, config));
+}
+function mapConfigToBot(id, config) {
+    (0, validation_1.validateId)(id, 'Bot');
+    const settings = config.settings ? mapSettings(config.settings) : (0, bot_1.createDefaultSettings)();
+    const graph = config.graph ?? '';
+    return (0, bot_1.createBot)({
+        id,
+        settings,
+        graph,
+    });
+}
+function mapSettings(config) {
+    if (config.typing_delay !== undefined) {
+        (0, validation_1.validateTypingDelay)(config.typing_delay);
+    }
+    if (config.queue_delay !== undefined) {
+        (0, validation_1.validateQueueDelay)(config.queue_delay);
+    }
+    return {
+        simulateTyping: config.simulate_typing ?? true,
+        typingDelay: config.typing_delay ?? 1000,
+        queueDelay: config.queue_delay ?? 1000,
+        readReceipts: config.read_receipts ?? true,
+        ignoreGroups: config.ignore_groups ?? true,
+        allowedSenders: (config.allowed_senders || []).map(String),
+        ignoredSenders: (config.ignored_senders || []).map(String),
+    };
+}

package/dist/config/schema.js

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