botforje 0.0.1

package/dist/auth/service.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const node_sqlite_1 = require("node:sqlite");
+const node_crypto_1 = require("node:crypto");
+class AuthService {
+    constructor(dbPath) {
+        this.db = new node_sqlite_1.DatabaseSync(dbPath);
+        this.setupSchema();
+    }
+    setupSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS key_hash (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        hash TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        token TEXT NOT NULL UNIQUE,
+        scope_bot_ids TEXT,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_token ON sessions(token);
+      CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at);
+    `);
+    }
+    isLocked() {
+        const row = this.db.prepare('SELECT 1 FROM key_hash WHERE id = 1').get();
+        return !!row;
+    }
+    lock(key) {
+        if (this.isLocked()) {
+            throw new Error('Botforje is already locked. Run `botforje unlock` first.');
+        }
+        const secret = key || (0, node_crypto_1.randomBytes)(32).toString('hex');
+        if (secret.length < 32) {
+            throw new Error('Key must be at least 32 characters long');
+        }
+        const hash = (0, node_crypto_1.createHash)('sha256').update(secret).digest('hex');
+        this.db.prepare('INSERT OR REPLACE INTO key_hash (id, hash) VALUES (1, ?)').run(hash);
+        this.invalidateAllSessions();
+        return secret;
+    }
+    unlock(providedKey) {
+        const stored = this.db.prepare('SELECT hash FROM key_hash WHERE id = 1').get();
+        if (!stored)
+            return false;
+        const inputHash = (0, node_crypto_1.createHash)('sha256').update(providedKey).digest('hex');
+        const match = (0, node_crypto_1.timingSafeEqual)(Buffer.from(inputHash), Buffer.from(stored.hash));
+        if (match) {
+            this.db.prepare('DELETE FROM key_hash WHERE id = 1').run();
+            this.invalidateAllSessions();
+        }
+        return match;
+    }
+    verifyKey(key) {
+        const stored = this.db.prepare('SELECT hash FROM key_hash WHERE id = 1').get();
+        if (!stored)
+            return false;
+        const inputHash = (0, node_crypto_1.createHash)('sha256').update(key).digest('hex');
+        return (0, node_crypto_1.timingSafeEqual)(Buffer.from(inputHash), Buffer.from(stored.hash));
+    }
+    createSession(scopeBotIds) {
+        const id = (0, node_crypto_1.randomBytes)(16).toString('hex');
+        const token = (0, node_crypto_1.randomBytes)(32).toString('hex');
+        const now = Math.floor(Date.now() / 1000);
+        const expiresAt = now + 86400;
+        const scopeJson = scopeBotIds ? JSON.stringify(scopeBotIds) : null;
+        this.db.prepare('INSERT INTO sessions (id, token, scope_bot_ids, created_at, expires_at) VALUES (?, ?, ?, ?, ?)').run(id, token, scopeJson, now, expiresAt);
+        return { token, expiresAt };
+    }
+    validateSession(token) {
+        const row = this.db.prepare('SELECT * FROM sessions WHERE token = ?').get(token);
+        if (!row)
+            return null;
+        const now = Math.floor(Date.now() / 1000);
+        if (now > row.expires_at) {
+            this.db.prepare('DELETE FROM sessions WHERE id = ?').run(row.id);
+            return null;
+        }
+        return {
+            id: row.id,
+            token: row.token,
+            scopeBotIds: row.scope_bot_ids ? JSON.parse(row.scope_bot_ids) : null,
+            createdAt: row.created_at,
+            expiresAt: row.expires_at,
+        };
+    }
+    invalidateSession(token) {
+        this.db.prepare('DELETE FROM sessions WHERE token = ?').run(token);
+    }
+    invalidateAllSessions() {
+        this.db.prepare('DELETE FROM sessions').run();
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.AuthService = AuthService;

package/dist/boot/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("../action/cooldown");
+const inbox_1 = require("../services/inbox");
+const state_1 = require("../flow/state");
+const 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 state_1.FlowStateService(flowStateDbPath);
+            const flowStateTimeout = configFile.global?.sessionTimeout ?? 300;
+            this.flowExecutor = new 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;

package/dist/bot/bot.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBot = createBot;
+exports.registerChannel = registerChannel;
+exports.createDefaultSettings = createDefaultSettings;
+const validation_1 = require("./validation");
+function createBot(props) {
+    (0, validation_1.validateBotId)(props.id);
+    return {
+        id: props.id,
+        phone: props.phone,
+        settings: props.settings,
+        flows: props.flows || [],
+    };
+}
+function registerChannel(bot, channel) {
+    bot.channel = channel;
+    return bot;
+}
+function createDefaultSettings() {
+    return {
+        simulateTyping: true,
+        typingDelay: 1000,
+        queueDelay: 1000,
+        readReceipts: true,
+        ignoreGroups: true,
+        ignoredSenders: [],
+        adminNumbers: [],
+    };
+}

package/dist/bot/fleet.js

@@ -0,0 +1,211 @@
+"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("./mapper");
+const catalog_1 = require("../action/catalog");
+const mapper_2 = require("../flow/mapper");
+const cooldown_1 = require("../action/cooldown");
+const inbox_1 = require("../services/inbox");
+const state_1 = require("../flow/state");
+const 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 state_1.FlowStateService(flowStateDbPath);
+            const flowStateTimeout = configFile.global?.sessionTimeout ?? 300;
+            this.flowExecutor = new executor_1.FlowExecutor(this.actionCatalog, this.flowCatalog, this.flowStateService, this.outboxService, flowStateTimeout, this.cooldownService);
+            this.inboxService = new inbox_1.InboxService(this.flowExecutor);
+            if (Object.keys(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.id} (${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.id}" initialized and ready`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to initialize bot "${bot.id}":`, error);
+            throw error;
+        }
+    }
+    setupBotEventHandlers(bot) {
+        if (!bot.channel) {
+            throw new Error(`Bot "${bot.id}" does not have a registered channel`);
+        }
+        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);
+        });
+    }
+    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.id,
+                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;

package/dist/bot/fuzzy.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchFuzzy = matchFuzzy;
+const fuse_js_1 = __importDefault(require("fuse.js"));
+function matchFuzzy(segments, message, threshold) {
+    if (segments.length === 0)
+        return null;
+    const fuse = new fuse_js_1.default(segments, {
+        includeScore: true,
+        threshold,
+    });
+    const results = fuse.search(message);
+    if (results.length > 0 && results[0].score !== undefined && results[0].score <= threshold) {
+        return segments[results[0].refIndex];
+    }
+    return null;
+}

package/dist/bot/mapper.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapConfigToBot = mapConfigToBot;
+exports.mapFlowRef = mapFlowRef;
+exports.mapSettings = mapSettings;
+exports.mapBotsFromConfig = mapBotsFromConfig;
+const bot_1 = require("./bot");
+const validation_1 = require("./validation");
+function mapConfigToBot(id, config) {
+    (0, validation_1.validateBotId)(id);
+    const settings = config.settings ? mapSettings(config.settings) : (0, bot_1.createDefaultSettings)();
+    const flows = (config.flows || []).map(mapFlowRef);
+    return (0, bot_1.createBot)({
+        id,
+        settings,
+        flows,
+    });
+}
+function mapFlowRef(config) {
+    if (config.priority !== undefined) {
+        (0, validation_1.validatePriority)(config.priority);
+    }
+    return {
+        id: config.id,
+        priority: config.priority ?? 1,
+    };
+}
+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,
+        ignoredSenders: config.ignored_senders || [],
+        adminNumbers: config.admin_numbers || [],
+    };
+}
+function mapBotsFromConfig(configs) {
+    return Object.entries(configs).map(([id, config]) => mapConfigToBot(id, config));
+}

package/dist/bot/types.js

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

package/dist/bot/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBotId = validateBotId;
+exports.validatePriority = validatePriority;
+exports.validateTypingDelay = validateTypingDelay;
+exports.validateQueueDelay = validateQueueDelay;
+function validateBotId(id) {
+    if (!id || id.length < 3) {
+        throw new Error('Bot ID must be at least 3 characters long');
+    }
+    if (!/^[a-z0-9-]+$/.test(id)) {
+        throw new Error('Bot ID can only contain lowercase letters, numbers and hyphens');
+    }
+    if (/^[-]/.test(id)) {
+        throw new Error('Bot ID cannot start with a hyphen');
+    }
+    if (/[-]$/.test(id)) {
+        throw new Error('Bot ID cannot end with a hyphen');
+    }
+    if (/--/.test(id)) {
+        throw new Error('Bot ID cannot contain consecutive hyphens');
+    }
+}
+function validatePriority(priority) {
+    if (priority < 0) {
+        throw new Error('Priority must be non-negative');
+    }
+}
+function validateTypingDelay(delay) {
+    if (delay < 0) {
+        throw new Error('Typing delay must be non-negative');
+    }
+}
+function validateQueueDelay(delay) {
+    if (delay < 0) {
+        throw new Error('Queue delay must be non-negative');
+    }
+}