@builderbot/manager 1.0.0 → 1.3.14-alpha.148

package/dist/index.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var require$$1$5 = require('path');
 var require$$9 = require('console');
 var require$$0$9 = require('fs');
 var require$$11 = require('node:events');
@@ -13,6 +12,7 @@ var require$$17 = require('assert');
 var require$$18 = require('tty');
 var require$$1$6 = require('util');
 var require$$0$a = require('os');
+var require$$1$5 = require('path');
 var require$$2$3 = require('events');
 var require$$0$b = require('child_process');
 var require$$24 = require('net');
@@ -39540,15 +39540,15 @@ class BotManager {
                 enabled: config.autoReconnect?.enabled ?? true,
                 maxRetries: config.autoReconnect?.maxRetries ?? 5,
                 initialDelay: config.autoReconnect?.initialDelay ?? 1000,
-                maxDelay: config.autoReconnect?.maxDelay ?? 30000
-            }
+                maxDelay: config.autoReconnect?.maxDelay ?? 30000,
+            },
         };
     }
     /**
      * Create a new bot instance for a tenant
      */
     async createBot(tenantConfig) {
-        const { tenantId, name, flows, port, providerOptions = {}, databaseOptions = {}, providerClass, databaseClass } = tenantConfig;
+        const { tenantId, name, flows, port, providerOptions = {}, databaseOptions = {}, providerClass, databaseClass, } = tenantConfig;
         if (this.bots.has(tenantId)) {
             throw new Error(`Bot with tenantId "${tenantId}" already exists`);
         }
@@ -39566,13 +39566,13 @@ class BotManager {
         const adapterProvider = createProvider_1(ProviderToUse, {
             ...this.config.defaultProviderOptions,
             ...providerOptions,
-            name: sessionPath // This creates isolated session folder per tenant
+            name: sessionPath, // This creates isolated session folder per tenant
         });
         // Use tenant-specific or default database class
         const DatabaseToUse = databaseClass || this.config.defaultDatabaseClass || MemoryDB_1;
         const adapterDB = new DatabaseToUse({
             ...this.config.defaultDatabaseOptions,
-            ...databaseOptions
+            ...databaseOptions,
         });
         const { handleCtx, httpServer } = await createBot_1({
             flow: adapterFlow,
@@ -39591,7 +39591,7 @@ class BotManager {
             createdAt: new Date(),
             status: 'initializing',
             providerType: ProviderToUse.name,
-            databaseType: DatabaseToUse.name
+            databaseType: DatabaseToUse.name,
         };
         this.bots.set(tenantId, botInstance);
         // Initialize reconnect state
@@ -39599,7 +39599,7 @@ class BotManager {
             attempts: 0,
             lastAttempt: new Date(),
             nextDelay: this.config.autoReconnect.initialDelay,
-            isReconnecting: false
+            isReconnecting: false,
         });
         // Setup provider event listeners for real status tracking
         this.setupProviderEvents(tenantId, adapterProvider);
@@ -39612,7 +39612,7 @@ class BotManager {
             port,
             sessionPath,
             providerType: botInstance.providerType,
-            databaseType: botInstance.databaseType
+            databaseType: botInstance.databaseType,
         });
         return botInstance;
     }
@@ -39668,7 +39668,7 @@ class BotManager {
         const { maxRetries, maxDelay } = this.config.autoReconnect;
         if (reconnectState.attempts >= maxRetries) {
             this.emit('bot:error', tenantId, {
-                error: new Error(`Max reconnection attempts (${maxRetries}) reached`)
+                error: new Error(`Max reconnection attempts (${maxRetries}) reached`),
             });
             return;
         }
@@ -39678,7 +39678,7 @@ class BotManager {
         this.emit('bot:reconnecting', tenantId, {
             attempt: reconnectState.attempts,
             maxRetries,
-            nextDelay: reconnectState.nextDelay
+            nextDelay: reconnectState.nextDelay,
         });
         // Wait before reconnecting
         await this.delay(reconnectState.nextDelay);
@@ -39696,7 +39696,7 @@ class BotManager {
             reconnectState.nextDelay = Math.min(reconnectState.nextDelay * 2, maxDelay);
             this.emit('bot:error', tenantId, {
                 error,
-                reconnectAttempt: reconnectState.attempts
+                reconnectAttempt: reconnectState.attempts,
             });
             // Try again
             this.attemptReconnect(tenantId);
@@ -39706,7 +39706,7 @@ class BotManager {
      * Helper delay function
      */
     delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
     /**
      * Get a bot instance by tenant ID
@@ -39766,7 +39766,7 @@ class BotManager {
      */
     async shutdown() {
         const tenantIds = this.listBots();
-        await Promise.all(tenantIds.map(tenantId => this.removeBot(tenantId)));
+        await Promise.all(tenantIds.map((tenantId) => this.removeBot(tenantId)));
     }
     /**
      * Register an event handler
@@ -39792,7 +39792,7 @@ class BotManager {
     emit(event, tenantId, data) {
         const handlers = this.eventHandlers.get(event);
         if (handlers) {
-            handlers.forEach(handler => {
+            handlers.forEach((handler) => {
                 try {
                     handler(tenantId, data);
                 }
@@ -39836,7 +39836,7 @@ class BotManager {
             attempts: 0,
             lastAttempt: new Date(),
             nextDelay: this.config.autoReconnect.initialDelay,
-            isReconnecting: false
+            isReconnecting: false,
         });
         try {
             await this.removeBot(tenantId);
@@ -39861,7 +39861,7 @@ class BotManager {
             tenantId,
             name: existingBot?.name || tenantId,
             flows: [],
-            port: existingBot?.port
+            port: existingBot?.port,
         };
         // Remove existing bot
         await this.removeBot(tenantId);
@@ -39876,7 +39876,7 @@ class BotManager {
      * Get summary info of all bots (useful for dashboards)
      */
     getBotsInfo() {
-        return this.getAllBots().map(bot => ({
+        return this.getAllBots().map((bot) => ({
             tenantId: bot.tenantId,
             name: bot.name,
             status: bot.status,
@@ -39885,7 +39885,7 @@ class BotManager {
             uptime: Date.now() - bot.createdAt.getTime(),
             providerType: bot.providerType,
             databaseType: bot.databaseType,
-            reconnectState: this.reconnectStates.get(bot.tenantId)
+            reconnectState: this.reconnectStates.get(bot.tenantId),
         }));
     }
     /**
@@ -39898,7 +39898,7 @@ class BotManager {
             connected: 0,
             disconnected: 0,
             error: 0,
-            initializing: 0
+            initializing: 0,
         };
         for (const bot of bots) {
             statusCounts[bot.status]++;
@@ -39914,7 +39914,7 @@ class BotManager {
             status,
             bots: statusCounts,
             memory: process.memoryUsage(),
-            uptime: process.uptime()
+            uptime: process.uptime(),
         };
     }
     /**
@@ -39936,6 +39936,324 @@ class BotManager {
     }
 }
 
+/**
+ * FlowRegistry manages flow definitions that can be used when creating bots
+ */
+class FlowRegistry {
+    constructor() {
+        this.flows = new Map();
+    }
+    /**
+     * Register a programmatic flow (created with addKeyword)
+     */
+    register(id, name, flow) {
+        const definition = {
+            id,
+            name,
+            flow,
+            dynamic: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.flows.set(id, definition);
+        return definition;
+    }
+    /**
+     * Register a dynamic flow from JSON configuration
+     */
+    registerDynamic(config) {
+        const { id, name, keyword, steps } = config;
+        const flow = this.buildFlowFromSteps(keyword, steps);
+        const definition = {
+            id,
+            name,
+            flow,
+            dynamic: true,
+            config,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.flows.set(id, definition);
+        return definition;
+    }
+    /**
+     * Update a dynamic flow
+     */
+    update(id, updates) {
+        const existing = this.flows.get(id);
+        if (!existing || !existing.dynamic || !existing.config) {
+            return null;
+        }
+        // Merge updates with existing config
+        const newConfig = {
+            ...existing.config,
+            ...(updates.name && { name: updates.name }),
+            ...(updates.keyword && { keyword: updates.keyword }),
+            ...(updates.steps && { steps: updates.steps }),
+        };
+        // Rebuild flow
+        const flow = this.buildFlowFromSteps(newConfig.keyword, newConfig.steps);
+        const definition = {
+            id,
+            name: newConfig.name,
+            flow,
+            dynamic: true,
+            config: newConfig,
+            createdAt: existing.createdAt,
+            updatedAt: new Date(),
+        };
+        this.flows.set(id, definition);
+        return definition;
+    }
+    /**
+     * Remove a flow from registry
+     */
+    remove(id) {
+        return this.flows.delete(id);
+    }
+    /**
+     * Get a flow by ID
+     */
+    get(id) {
+        return this.flows.get(id);
+    }
+    /**
+     * Get all registered flows
+     */
+    getAll() {
+        return Array.from(this.flows.values());
+    }
+    /**
+     * Check if a flow exists
+     */
+    has(id) {
+        return this.flows.has(id);
+    }
+    /**
+     * Get all flow IDs
+     */
+    getIds() {
+        return Array.from(this.flows.keys());
+    }
+    /**
+     * Get count of registered flows
+     */
+    count() {
+        return this.flows.size;
+    }
+    /**
+     * Clear all flows
+     */
+    clear() {
+        this.flows.clear();
+    }
+    /**
+     * Get flows by type (dynamic or programmatic)
+     */
+    getByType(dynamic) {
+        return this.getAll().filter((f) => f.dynamic === dynamic);
+    }
+    /**
+     * Resolve multiple flow IDs to Flow objects
+     */
+    resolveFlows(flowIds) {
+        const flows = [];
+        const missing = [];
+        for (const id of flowIds) {
+            const definition = this.flows.get(id);
+            if (definition) {
+                flows.push(definition.flow);
+            }
+            else {
+                missing.push(id);
+            }
+        }
+        return { flows, missing };
+    }
+    /**
+     * Build a flow from steps configuration
+     */
+    buildFlowFromSteps(keyword, steps) {
+        const keywords = Array.isArray(keyword)
+            ? keyword
+            : keyword;
+        let flow = addKeyword_1(keywords);
+        for (const step of steps) {
+            const options = {};
+            if (step.delay)
+                options.delay = step.delay;
+            if (step.media)
+                options.media = step.media;
+            if (step.capture)
+                options.capture = step.capture;
+            flow = flow.addAnswer(step.answer, Object.keys(options).length > 0 ? options : undefined);
+        }
+        return flow;
+    }
+    /**
+     * Export all dynamic flows as serializable configs
+     */
+    exportDynamicFlows() {
+        return this.getByType(true)
+            .filter((f) => f.config)
+            .map((f) => f.config);
+    }
+    /**
+     * Import dynamic flows from configs
+     */
+    importDynamicFlows(configs) {
+        const failed = [];
+        let imported = 0;
+        for (const config of configs) {
+            try {
+                if (!this.has(config.id)) {
+                    this.registerDynamic(config);
+                    imported++;
+                }
+            }
+            catch {
+                failed.push(config.id);
+            }
+        }
+        return { imported, failed };
+    }
+}
+
+/**
+ * Simple in-memory rate limiter
+ */
+class RateLimiter {
+    constructor(config = {}) {
+        this.store = new Map();
+        this.cleanupInterval = null;
+        this.config = {
+            maxRequests: config.maxRequests ?? 100,
+            windowMs: config.windowMs ?? 60000, // 1 minute
+            message: config.message ?? 'Too many requests, please try again later',
+            skipPaths: config.skipPaths ?? ['/docs', '/api/health'],
+            keyExtractor: config.keyExtractor ?? this.defaultKeyExtractor,
+        };
+        // Cleanup expired entries every minute
+        this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+    }
+    /**
+     * Default key extractor - uses IP address
+     */
+    defaultKeyExtractor(req) {
+        const forwarded = req.headers['x-forwarded-for'];
+        if (forwarded) {
+            const ips = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(',')[0];
+            return ips.trim();
+        }
+        return req.socket?.remoteAddress || 'unknown';
+    }
+    /**
+     * Check if request should be rate limited
+     */
+    isRateLimited(req) {
+        const url = req.url || '/';
+        // Skip certain paths
+        if (this.config.skipPaths.some((path) => url.startsWith(path))) {
+            return { limited: false, remaining: this.config.maxRequests, resetTime: 0 };
+        }
+        const key = this.config.keyExtractor(req);
+        const now = Date.now();
+        let entry = this.store.get(key);
+        // If no entry or window expired, create new entry
+        if (!entry || now > entry.resetTime) {
+            entry = {
+                count: 1,
+                resetTime: now + this.config.windowMs,
+            };
+            this.store.set(key, entry);
+            return {
+                limited: false,
+                remaining: this.config.maxRequests - 1,
+                resetTime: entry.resetTime,
+            };
+        }
+        // Increment count
+        entry.count++;
+        // Check if over limit
+        if (entry.count > this.config.maxRequests) {
+            return {
+                limited: true,
+                remaining: 0,
+                resetTime: entry.resetTime,
+            };
+        }
+        return {
+            limited: false,
+            remaining: this.config.maxRequests - entry.count,
+            resetTime: entry.resetTime,
+        };
+    }
+    /**
+     * Create middleware function
+     */
+    middleware() {
+        return (req, res, next) => {
+            const result = this.isRateLimited(req);
+            // Set rate limit headers
+            res.setHeader('X-RateLimit-Limit', this.config.maxRequests.toString());
+            res.setHeader('X-RateLimit-Remaining', result.remaining.toString());
+            res.setHeader('X-RateLimit-Reset', result.resetTime.toString());
+            if (result.limited) {
+                res.setHeader('Retry-After', Math.ceil((result.resetTime - Date.now()) / 1000).toString());
+                res.writeHead(429, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: this.config.message,
+                    retryAfter: Math.ceil((result.resetTime - Date.now()) / 1000),
+                }));
+                return;
+            }
+            next();
+        };
+    }
+    /**
+     * Reset rate limit for a specific key
+     */
+    reset(key) {
+        this.store.delete(key);
+    }
+    /**
+     * Clear all rate limit data
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.store.entries()) {
+            if (now > entry.resetTime) {
+                this.store.delete(key);
+            }
+        }
+    }
+    /**
+     * Stop the cleanup interval
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.store.clear();
+    }
+    /**
+     * Get current stats
+     */
+    getStats() {
+        return {
+            activeKeys: this.store.size,
+            config: this.config,
+        };
+    }
+}
+
 /**
  * Reserved tenant IDs that cannot be used
  */
@@ -39954,31 +40272,21 @@ const tenantIdSchema = zod.z
  */
 const createBotSchema = zod.z.object({
     tenantId: tenantIdSchema,
-    name: zod.z
-        .string()
-        .min(1, 'name cannot be empty')
-        .max(100, 'name must be 100 characters or less')
-        .optional(),
-    flowIds: zod.z
-        .array(zod.z.string().min(1, 'flowId cannot be empty'))
-        .min(1, 'At least one flowId is required'),
+    name: zod.z.string().min(1, 'name cannot be empty').max(100, 'name must be 100 characters or less').optional(),
+    flowIds: zod.z.array(zod.z.string().min(1, 'flowId cannot be empty')).min(1, 'At least one flowId is required'),
     port: zod.z
         .number()
         .int('port must be an integer')
         .min(1024, 'port must be 1024 or higher')
         .max(65535, 'port must be 65535 or lower')
         .optional(),
-    providerOptions: zod.z.record(zod.z.any()).optional()
+    providerOptions: zod.z.record(zod.z.any()).optional(),
 });
 /**
  * Schema for updating a bot
  */
 const updateBotSchema = zod.z.object({
-    name: zod.z
-        .string()
-        .min(1, 'name cannot be empty')
-        .max(100, 'name must be 100 characters or less')
-        .optional()
+    name: zod.z.string().min(1, 'name cannot be empty').max(100, 'name must be 100 characters or less').optional(),
 });
 /**
  * Schema for sending a message
@@ -39989,33 +40297,21 @@ const sendMessageSchema = zod.z.object({
         .min(10, 'number must be at least 10 characters')
         .max(20, 'number must be 20 characters or less')
         .regex(/^[0-9+]+$/, 'number can only contain digits and + symbol'),
-    message: zod.z
-        .string()
-        .min(1, 'message cannot be empty')
-        .max(4096, 'message must be 4096 characters or less'),
-    media: zod.z
-        .string()
-        .url('media must be a valid URL')
-        .optional()
+    message: zod.z.string().min(1, 'message cannot be empty').max(4096, 'message must be 4096 characters or less'),
+    media: zod.z.string().url('media must be a valid URL').optional(),
 });
 /**
  * Schema for restarting a bot
  */
 const restartBotSchema = zod.z.object({
-    flowIds: zod.z
-        .array(zod.z.string().min(1))
-        .min(1, 'At least one flowId is required'),
+    flowIds: zod.z.array(zod.z.string().min(1)).min(1, 'At least one flowId is required'),
     port: zod.z
         .number()
         .int('port must be an integer')
         .min(1024, 'port must be 1024 or higher')
         .max(65535, 'port must be 65535 or lower')
         .optional(),
-    name: zod.z
-        .string()
-        .min(1)
-        .max(100)
-        .optional()
+    name: zod.z.string().min(1).max(100).optional(),
 });
 /**
  * Reserved flow IDs
@@ -40032,7 +40328,7 @@ const flowStepSchema = zod.z.object({
     /** Optional media URL to attach */
     media: zod.z.string().url().optional(),
     /** Whether to capture user response */
-    capture: zod.z.boolean().optional()
+    capture: zod.z.boolean().optional(),
 });
 /**
  * Schema for creating a dynamic flow
@@ -40048,23 +40344,17 @@ const createFlowSchema = zod.z.object({
     /** Display name for the flow */
     name: zod.z.string().min(1).max(100),
     /** Keywords that trigger this flow */
-    keyword: zod.z.union([
-        zod.z.string().min(1),
-        zod.z.array(zod.z.string().min(1)).min(1)
-    ]),
+    keyword: zod.z.union([zod.z.string().min(1), zod.z.array(zod.z.string().min(1)).min(1)]),
     /** Steps/answers in the flow */
-    steps: zod.z.array(flowStepSchema).min(1, 'At least one step is required')
+    steps: zod.z.array(flowStepSchema).min(1, 'At least one step is required'),
 });
 /**
  * Schema for updating a flow
  */
 const updateFlowSchema = zod.z.object({
     name: zod.z.string().min(1).max(100).optional(),
-    keyword: zod.z.union([
-        zod.z.string().min(1),
-        zod.z.array(zod.z.string().min(1)).min(1)
-    ]).optional(),
-    steps: zod.z.array(flowStepSchema).min(1).optional()
+    keyword: zod.z.union([zod.z.string().min(1), zod.z.array(zod.z.string().min(1)).min(1)]).optional(),
+    steps: zod.z.array(flowStepSchema).min(1).optional(),
 });
 /**
  * Validate data against a Zod schema
@@ -40074,17 +40364,17 @@ function validate(schema, data) {
     if (result.success) {
         return {
             success: true,
-            data: result.data
+            data: result.data,
         };
     }
     const errors = result.error.errors.map((err) => ({
         field: err.path.join('.') || 'root',
-        message: err.message
+        message: err.message,
     }));
     return {
         success: false,
         error: errors.map((e) => `${e.field}: ${e.message}`).join(', '),
-        errors
+        errors,
     };
 }
 
@@ -40098,19 +40388,19 @@ const openApiSpec = {
         description: 'Multi-tenant WhatsApp Bot Manager REST API. Manage bots, flows, and send messages.',
         version: '1.0.0',
         contact: {
-            name: 'BotManager'
-        }
+            name: 'BotManager',
+        },
     },
     servers: [
         {
             url: '/api',
-            description: 'API Server'
-        }
+            description: 'API Server',
+        },
     ],
     tags: [
         { name: 'Health', description: 'Health check endpoints' },
         { name: 'Flows', description: 'Flow management' },
-        { name: 'Bots', description: 'Bot management' }
+        { name: 'Bots', description: 'Bot management' },
     ],
     paths: {
         '/health': {
@@ -40128,14 +40418,14 @@ const openApiSpec = {
                                     properties: {
                                         status: { type: 'string', example: 'ok' },
                                         timestamp: { type: 'string', format: 'date-time' },
-                                        botsCount: { type: 'integer', example: 2 }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+                                        botsCount: { type: 'integer', example: 2 },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         },
         '/flows': {
             get: {
@@ -40153,14 +40443,14 @@ const openApiSpec = {
                                         count: { type: 'integer' },
                                         flows: {
                                             type: 'array',
-                                            items: { $ref: '#/components/schemas/FlowInfo' }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+                                            items: { $ref: '#/components/schemas/FlowInfo' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
             },
             post: {
                 tags: ['Flows'],
@@ -40180,9 +40470,9 @@ const openApiSpec = {
                                         keyword: ['hola', 'hello', 'hi'],
                                         steps: [
                                             { answer: '👋 ¡Hola! Bienvenido', delay: 500 },
-                                            { answer: '¿En qué puedo ayudarte?', capture: true }
-                                        ]
-                                    }
+                                            { answer: '¿En qué puedo ayudarte?', capture: true },
+                                        ],
+                                    },
                                 },
                                 support: {
                                     summary: 'Support flow',
@@ -40192,54 +40482,50 @@ const openApiSpec = {
                                         keyword: 'ayuda',
                                         steps: [
                                             { answer: '🆘 Soporte técnico' },
-                                            { answer: 'Por favor describe tu problema:', capture: true }
-                                        ]
-                                    }
-                                }
-                            }
-                        }
-                    }
+                                            { answer: 'Por favor describe tu problema:', capture: true },
+                                        ],
+                                    },
+                                },
+                            },
+                        },
+                    },
                 },
                 responses: {
                     '201': {
                         description: 'Flow created successfully',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/FlowResponse' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/FlowResponse' },
+                            },
+                        },
                     },
                     '400': { $ref: '#/components/responses/ValidationError' },
-                    '409': { $ref: '#/components/responses/Conflict' }
-                }
-            }
+                    '409': { $ref: '#/components/responses/Conflict' },
+                },
+            },
         },
         '/flows/{flowId}': {
             get: {
                 tags: ['Flows'],
                 summary: 'Get flow by ID',
-                parameters: [
-                    { $ref: '#/components/parameters/flowId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/flowId' }],
                 responses: {
                     '200': {
                         description: 'Flow details',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/FlowInfo' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/FlowInfo' },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
             },
             put: {
                 tags: ['Flows'],
                 summary: 'Update a dynamic flow',
                 description: 'Update an existing dynamic flow. Programmatic flows cannot be updated.',
-                parameters: [
-                    { $ref: '#/components/parameters/flowId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/flowId' }],
                 requestBody: {
                     required: true,
                     content: {
@@ -40247,33 +40533,29 @@ const openApiSpec = {
                             schema: { $ref: '#/components/schemas/UpdateFlow' },
                             example: {
                                 name: 'Updated Flow Name',
-                                steps: [
-                                    { answer: 'New message', delay: 1000 }
-                                ]
-                            }
-                        }
-                    }
+                                steps: [{ answer: 'New message', delay: 1000 }],
+                            },
+                        },
+                    },
                 },
                 responses: {
                     '200': {
                         description: 'Flow updated successfully',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/FlowResponse' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/FlowResponse' },
+                            },
+                        },
                     },
                     '400': { $ref: '#/components/responses/ValidationError' },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
             },
             delete: {
                 tags: ['Flows'],
                 summary: 'Delete a dynamic flow',
                 description: 'Delete a dynamic flow. Programmatic flows cannot be deleted.',
-                parameters: [
-                    { $ref: '#/components/parameters/flowId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/flowId' }],
                 responses: {
                     '200': {
                         description: 'Flow deleted successfully',
@@ -40283,16 +40565,16 @@ const openApiSpec = {
                                     type: 'object',
                                     properties: {
                                         message: { type: 'string' },
-                                        flowId: { type: 'string' }
-                                    }
-                                }
-                            }
-                        }
+                                        flowId: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
                     },
                     '400': { $ref: '#/components/responses/BadRequest' },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
-            }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
+            },
         },
         '/bots': {
             get: {
@@ -40309,14 +40591,14 @@ const openApiSpec = {
                                         count: { type: 'integer' },
                                         bots: {
                                             type: 'array',
-                                            items: { $ref: '#/components/schemas/BotInfo' }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+                                            items: { $ref: '#/components/schemas/BotInfo' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
             },
             post: {
                 tags: ['Bots'],
@@ -40334,33 +40616,33 @@ const openApiSpec = {
                                         tenantId: 'my-bot',
                                         name: 'My WhatsApp Bot',
                                         flowIds: ['greeting', 'support'],
-                                        port: 3008
-                                    }
+                                        port: 3008,
+                                    },
                                 },
                                 minimalBot: {
                                     summary: 'Minimal bot',
                                     value: {
                                         tenantId: 'bot-2',
-                                        flowIds: ['greeting']
-                                    }
-                                }
-                            }
-                        }
-                    }
+                                        flowIds: ['greeting'],
+                                    },
+                                },
+                            },
+                        },
+                    },
                 },
                 responses: {
                     '201': {
                         description: 'Bot created successfully',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/BotResponse' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/BotResponse' },
+                            },
+                        },
                     },
                     '400': { $ref: '#/components/responses/ValidationError' },
-                    '409': { $ref: '#/components/responses/Conflict' }
-                }
-            }
+                    '409': { $ref: '#/components/responses/Conflict' },
+                },
+            },
         },
         '/bots/active': {
             get: {
@@ -40377,70 +40659,64 @@ const openApiSpec = {
                                         count: { type: 'integer' },
                                         bots: {
                                             type: 'array',
-                                            items: { $ref: '#/components/schemas/BotInfo' }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+                                            items: { $ref: '#/components/schemas/BotInfo' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         },
         '/bots/{tenantId}': {
             get: {
                 tags: ['Bots'],
                 summary: 'Get bot by tenant ID',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 responses: {
                     '200': {
                         description: 'Bot details',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/BotInfo' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/BotInfo' },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
             },
             put: {
                 tags: ['Bots'],
                 summary: 'Update bot',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 requestBody: {
                     required: true,
                     content: {
                         'application/json': {
                             schema: { $ref: '#/components/schemas/UpdateBot' },
                             example: {
-                                name: 'Updated Bot Name'
-                            }
-                        }
-                    }
+                                name: 'Updated Bot Name',
+                            },
+                        },
+                    },
                 },
                 responses: {
                     '200': {
                         description: 'Bot updated',
                         content: {
                             'application/json': {
-                                schema: { $ref: '#/components/schemas/BotResponse' }
-                            }
-                        }
+                                schema: { $ref: '#/components/schemas/BotResponse' },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
             },
             delete: {
                 tags: ['Bots'],
                 summary: 'Delete bot',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 responses: {
                     '200': {
                         description: 'Bot deleted successfully',
@@ -40450,24 +40726,22 @@ const openApiSpec = {
                                     type: 'object',
                                     properties: {
                                         message: { type: 'string' },
-                                        tenantId: { type: 'string' }
-                                    }
-                                }
-                            }
-                        }
+                                        tenantId: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
-            }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
+            },
         },
         '/bots/{tenantId}/qr': {
             get: {
                 tags: ['Bots'],
                 summary: 'Get QR code for bot',
                 description: 'Get the QR code to connect WhatsApp. Returns null if already connected.',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 responses: {
                     '200': {
                         description: 'QR code data',
@@ -40476,10 +40750,13 @@ const openApiSpec = {
                                 schema: {
                                     type: 'object',
                                     properties: {
-                                        status: { type: 'string', enum: ['initializing', 'connected', 'disconnected', 'error'] },
+                                        status: {
+                                            type: 'string',
+                                            enum: ['initializing', 'connected', 'disconnected', 'error'],
+                                        },
                                         qr: { type: 'string', nullable: true },
-                                        message: { type: 'string' }
-                                    }
+                                        message: { type: 'string' },
+                                    },
                                 },
                                 examples: {
                                     pending: {
@@ -40487,31 +40764,29 @@ const openApiSpec = {
                                         value: {
                                             status: 'initializing',
                                             qr: '2@abc123...',
-                                            message: 'Scan QR to connect'
-                                        }
+                                            message: 'Scan QR to connect',
+                                        },
                                     },
                                     connected: {
                                         summary: 'Already connected',
                                         value: {
                                             status: 'connected',
-                                            qr: null
-                                        }
-                                    }
-                                }
-                            }
-                        }
+                                            qr: null,
+                                        },
+                                    },
+                                },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
-            }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
+            },
         },
         '/bots/{tenantId}/restart': {
             post: {
                 tags: ['Bots'],
                 summary: 'Restart bot',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 requestBody: {
                     required: true,
                     content: {
@@ -40519,10 +40794,10 @@ const openApiSpec = {
                             schema: { $ref: '#/components/schemas/RestartBot' },
                             example: {
                                 flowIds: ['greeting', 'support'],
-                                port: 3009
-                            }
-                        }
-                    }
+                                port: 3009,
+                            },
+                        },
+                    },
                 },
                 responses: {
                     '200': {
@@ -40533,25 +40808,23 @@ const openApiSpec = {
                                     type: 'object',
                                     properties: {
                                         message: { type: 'string' },
-                                        tenantId: { type: 'string' }
-                                    }
-                                }
-                            }
-                        }
+                                        tenantId: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
                     },
                     '400': { $ref: '#/components/responses/ValidationError' },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
-            }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
+            },
         },
         '/bots/{tenantId}/stop': {
             post: {
                 tags: ['Bots'],
                 summary: 'Stop bot',
                 description: 'Stop and remove the bot',
-                parameters: [
-                    { $ref: '#/components/parameters/tenantId' }
-                ],
+                parameters: [{ $ref: '#/components/parameters/tenantId' }],
                 responses: {
                     '200': {
                         description: 'Bot stopped',
@@ -40561,16 +40834,16 @@ const openApiSpec = {
                                     type: 'object',
                                     properties: {
                                         success: { type: 'boolean' },
-                                        message: { type: 'string' }
-                                    }
-                                }
-                            }
-                        }
+                                        message: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
                     },
-                    '404': { $ref: '#/components/responses/NotFound' }
-                }
-            }
-        }
+                    '404': { $ref: '#/components/responses/NotFound' },
+                },
+            },
+        },
     },
     components: {
         parameters: {
@@ -40580,7 +40853,7 @@ const openApiSpec = {
                 required: true,
                 description: 'Bot tenant identifier',
                 schema: { type: 'string' },
-                example: 'my-bot'
+                example: 'my-bot',
             },
             flowId: {
                 name: 'flowId',
@@ -40588,8 +40861,8 @@ const openApiSpec = {
                 required: true,
                 description: 'Flow identifier',
                 schema: { type: 'string' },
-                example: 'greeting'
-            }
+                example: 'greeting',
+            },
         },
         schemas: {
             FlowStep: {
@@ -40599,8 +40872,8 @@ const openApiSpec = {
                     answer: { type: 'string', description: 'Message to send', maxLength: 4096 },
                     delay: { type: 'integer', description: 'Delay in ms before sending', minimum: 0, maximum: 30000 },
                     media: { type: 'string', format: 'uri', description: 'Media URL to attach' },
-                    capture: { type: 'boolean', description: 'Whether to capture user response' }
-                }
+                    capture: { type: 'boolean', description: 'Whether to capture user response' },
+                },
             },
             CreateFlow: {
                 type: 'object',
@@ -40609,34 +40882,28 @@ const openApiSpec = {
                     id: { type: 'string', pattern: '^[a-zA-Z0-9-_]+$', maxLength: 50 },
                     name: { type: 'string', maxLength: 100 },
                     keyword: {
-                        oneOf: [
-                            { type: 'string' },
-                            { type: 'array', items: { type: 'string' }, minItems: 1 }
-                        ]
+                        oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }],
                     },
                     steps: {
                         type: 'array',
                         items: { $ref: '#/components/schemas/FlowStep' },
-                        minItems: 1
-                    }
-                }
+                        minItems: 1,
+                    },
+                },
             },
             UpdateFlow: {
                 type: 'object',
                 properties: {
                     name: { type: 'string', maxLength: 100 },
                     keyword: {
-                        oneOf: [
-                            { type: 'string' },
-                            { type: 'array', items: { type: 'string' }, minItems: 1 }
-                        ]
+                        oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }],
                     },
                     steps: {
                         type: 'array',
                         items: { $ref: '#/components/schemas/FlowStep' },
-                        minItems: 1
-                    }
-                }
+                        minItems: 1,
+                    },
+                },
             },
             FlowInfo: {
                 type: 'object',
@@ -40644,8 +40911,8 @@ const openApiSpec = {
                     id: { type: 'string' },
                     name: { type: 'string' },
                     dynamic: { type: 'boolean' },
-                    config: { $ref: '#/components/schemas/CreateFlow' }
-                }
+                    config: { $ref: '#/components/schemas/CreateFlow' },
+                },
             },
             FlowResponse: {
                 type: 'object',
@@ -40654,8 +40921,8 @@ const openApiSpec = {
                     id: { type: 'string' },
                     name: { type: 'string' },
                     dynamic: { type: 'boolean' },
-                    config: { $ref: '#/components/schemas/CreateFlow' }
-                }
+                    config: { $ref: '#/components/schemas/CreateFlow' },
+                },
             },
             CreateBot: {
                 type: 'object',
@@ -40663,16 +40930,21 @@ const openApiSpec = {
                 properties: {
                     tenantId: { type: 'string', pattern: '^[a-zA-Z0-9-_]+$', maxLength: 50 },
                     name: { type: 'string', maxLength: 100 },
-                    flowIds: { type: 'array', items: { type: 'string' }, minItems: 1, description: 'At least one flowId is required' },
+                    flowIds: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        minItems: 1,
+                        description: 'At least one flowId is required',
+                    },
                     port: { type: 'integer', minimum: 1024, maximum: 65535 },
-                    providerOptions: { type: 'object', additionalProperties: true }
-                }
+                    providerOptions: { type: 'object', additionalProperties: true },
+                },
             },
             UpdateBot: {
                 type: 'object',
                 properties: {
-                    name: { type: 'string', maxLength: 100 }
-                }
+                    name: { type: 'string', maxLength: 100 },
+                },
             },
             RestartBot: {
                 type: 'object',
@@ -40680,8 +40952,8 @@ const openApiSpec = {
                 properties: {
                     flowIds: { type: 'array', items: { type: 'string' }, minItems: 1 },
                     port: { type: 'integer', minimum: 1024, maximum: 65535 },
-                    name: { type: 'string', maxLength: 100 }
-                }
+                    name: { type: 'string', maxLength: 100 },
+                },
             },
             BotInfo: {
                 type: 'object',
@@ -40691,8 +40963,8 @@ const openApiSpec = {
                     status: { type: 'string', enum: ['initializing', 'connected', 'disconnected', 'error'] },
                     port: { type: 'integer' },
                     createdAt: { type: 'string', format: 'date-time' },
-                    uptime: { type: 'integer', description: 'Uptime in milliseconds' }
-                }
+                    uptime: { type: 'integer', description: 'Uptime in milliseconds' },
+                },
             },
             BotResponse: {
                 type: 'object',
@@ -40701,8 +40973,8 @@ const openApiSpec = {
                     tenantId: { type: 'string' },
                     name: { type: 'string' },
                     status: { type: 'string' },
-                    port: { type: 'integer' }
-                }
+                    port: { type: 'integer' },
+                },
             },
             Error: {
                 type: 'object',
@@ -40714,12 +40986,12 @@ const openApiSpec = {
                             type: 'object',
                             properties: {
                                 field: { type: 'string' },
-                                message: { type: 'string' }
-                            }
-                        }
-                    }
-                }
-            }
+                                message: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
         },
         responses: {
             NotFound: {
@@ -40727,9 +40999,9 @@ const openApiSpec = {
                 content: {
                     'application/json': {
                         schema: { $ref: '#/components/schemas/Error' },
-                        example: { error: 'Bot not found' }
-                    }
-                }
+                        example: { error: 'Bot not found' },
+                    },
+                },
             },
             ValidationError: {
                 description: 'Validation error',
@@ -40738,57 +41010,52 @@ const openApiSpec = {
                         schema: { $ref: '#/components/schemas/Error' },
                         example: {
                             error: 'Validation failed',
-                            details: [
-                                { field: 'tenantId', message: 'tenantId is required' }
-                            ]
-                        }
-                    }
-                }
+                            details: [{ field: 'tenantId', message: 'tenantId is required' }],
+                        },
+                    },
+                },
             },
             BadRequest: {
                 description: 'Bad request',
                 content: {
                     'application/json': {
                         schema: { $ref: '#/components/schemas/Error' },
-                        example: { error: 'Cannot delete programmatic flows' }
-                    }
-                }
+                        example: { error: 'Cannot delete programmatic flows' },
+                    },
+                },
             },
             Conflict: {
                 description: 'Resource already exists',
                 content: {
                     'application/json': {
                         schema: { $ref: '#/components/schemas/Error' },
-                        example: { error: 'Bot with this tenantId already exists' }
-                    }
-                }
+                        example: { error: 'Bot with this tenantId already exists' },
+                    },
+                },
             },
             Unauthorized: {
                 description: 'Unauthorized',
                 content: {
                     'application/json': {
                         schema: { $ref: '#/components/schemas/Error' },
-                        example: { error: 'Unauthorized' }
-                    }
-                }
-            }
+                        example: { error: 'Unauthorized' },
+                    },
+                },
+            },
         },
         securitySchemes: {
             ApiKeyAuth: {
                 type: 'apiKey',
                 in: 'header',
-                name: 'X-API-Key'
+                name: 'X-API-Key',
             },
             BearerAuth: {
                 type: 'http',
-                scheme: 'bearer'
-            }
-        }
+                scheme: 'bearer',
+            },
+        },
     },
-    security: [
-        { ApiKeyAuth: [] },
-        { BearerAuth: [] }
-    ]
+    security: [{ ApiKeyAuth: [] }, { BearerAuth: [] }],
 };
 /**
  * Generate Swagger UI HTML
@@ -40832,324 +41099,6 @@ function generateSwaggerHtml(specUrl) {
 </html>`;
 }
 
-/**
- * FlowRegistry manages flow definitions that can be used when creating bots
- */
-class FlowRegistry {
-    constructor() {
-        this.flows = new Map();
-    }
-    /**
-     * Register a programmatic flow (created with addKeyword)
-     */
-    register(id, name, flow) {
-        const definition = {
-            id,
-            name,
-            flow,
-            dynamic: false,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        };
-        this.flows.set(id, definition);
-        return definition;
-    }
-    /**
-     * Register a dynamic flow from JSON configuration
-     */
-    registerDynamic(config) {
-        const { id, name, keyword, steps } = config;
-        const flow = this.buildFlowFromSteps(keyword, steps);
-        const definition = {
-            id,
-            name,
-            flow,
-            dynamic: true,
-            config,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        };
-        this.flows.set(id, definition);
-        return definition;
-    }
-    /**
-     * Update a dynamic flow
-     */
-    update(id, updates) {
-        const existing = this.flows.get(id);
-        if (!existing || !existing.dynamic || !existing.config) {
-            return null;
-        }
-        // Merge updates with existing config
-        const newConfig = {
-            ...existing.config,
-            ...(updates.name && { name: updates.name }),
-            ...(updates.keyword && { keyword: updates.keyword }),
-            ...(updates.steps && { steps: updates.steps })
-        };
-        // Rebuild flow
-        const flow = this.buildFlowFromSteps(newConfig.keyword, newConfig.steps);
-        const definition = {
-            id,
-            name: newConfig.name,
-            flow,
-            dynamic: true,
-            config: newConfig,
-            createdAt: existing.createdAt,
-            updatedAt: new Date()
-        };
-        this.flows.set(id, definition);
-        return definition;
-    }
-    /**
-     * Remove a flow from registry
-     */
-    remove(id) {
-        return this.flows.delete(id);
-    }
-    /**
-     * Get a flow by ID
-     */
-    get(id) {
-        return this.flows.get(id);
-    }
-    /**
-     * Get all registered flows
-     */
-    getAll() {
-        return Array.from(this.flows.values());
-    }
-    /**
-     * Check if a flow exists
-     */
-    has(id) {
-        return this.flows.has(id);
-    }
-    /**
-     * Get all flow IDs
-     */
-    getIds() {
-        return Array.from(this.flows.keys());
-    }
-    /**
-     * Get count of registered flows
-     */
-    count() {
-        return this.flows.size;
-    }
-    /**
-     * Clear all flows
-     */
-    clear() {
-        this.flows.clear();
-    }
-    /**
-     * Get flows by type (dynamic or programmatic)
-     */
-    getByType(dynamic) {
-        return this.getAll().filter(f => f.dynamic === dynamic);
-    }
-    /**
-     * Resolve multiple flow IDs to Flow objects
-     */
-    resolveFlows(flowIds) {
-        const flows = [];
-        const missing = [];
-        for (const id of flowIds) {
-            const definition = this.flows.get(id);
-            if (definition) {
-                flows.push(definition.flow);
-            }
-            else {
-                missing.push(id);
-            }
-        }
-        return { flows, missing };
-    }
-    /**
-     * Build a flow from steps configuration
-     */
-    buildFlowFromSteps(keyword, steps) {
-        const keywords = Array.isArray(keyword)
-            ? keyword
-            : keyword;
-        let flow = addKeyword_1(keywords);
-        for (const step of steps) {
-            const options = {};
-            if (step.delay)
-                options.delay = step.delay;
-            if (step.media)
-                options.media = step.media;
-            if (step.capture)
-                options.capture = step.capture;
-            flow = flow.addAnswer(step.answer, Object.keys(options).length > 0 ? options : undefined);
-        }
-        return flow;
-    }
-    /**
-     * Export all dynamic flows as serializable configs
-     */
-    exportDynamicFlows() {
-        return this.getByType(true)
-            .filter(f => f.config)
-            .map(f => f.config);
-    }
-    /**
-     * Import dynamic flows from configs
-     */
-    importDynamicFlows(configs) {
-        const failed = [];
-        let imported = 0;
-        for (const config of configs) {
-            try {
-                if (!this.has(config.id)) {
-                    this.registerDynamic(config);
-                    imported++;
-                }
-            }
-            catch {
-                failed.push(config.id);
-            }
-        }
-        return { imported, failed };
-    }
-}
-
-/**
- * Simple in-memory rate limiter
- */
-class RateLimiter {
-    constructor(config = {}) {
-        this.store = new Map();
-        this.cleanupInterval = null;
-        this.config = {
-            maxRequests: config.maxRequests ?? 100,
-            windowMs: config.windowMs ?? 60000, // 1 minute
-            message: config.message ?? 'Too many requests, please try again later',
-            skipPaths: config.skipPaths ?? ['/docs', '/api/health'],
-            keyExtractor: config.keyExtractor ?? this.defaultKeyExtractor
-        };
-        // Cleanup expired entries every minute
-        this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
-    }
-    /**
-     * Default key extractor - uses IP address
-     */
-    defaultKeyExtractor(req) {
-        const forwarded = req.headers['x-forwarded-for'];
-        if (forwarded) {
-            const ips = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(',')[0];
-            return ips.trim();
-        }
-        return req.socket?.remoteAddress || 'unknown';
-    }
-    /**
-     * Check if request should be rate limited
-     */
-    isRateLimited(req) {
-        const url = req.url || '/';
-        // Skip certain paths
-        if (this.config.skipPaths.some(path => url.startsWith(path))) {
-            return { limited: false, remaining: this.config.maxRequests, resetTime: 0 };
-        }
-        const key = this.config.keyExtractor(req);
-        const now = Date.now();
-        let entry = this.store.get(key);
-        // If no entry or window expired, create new entry
-        if (!entry || now > entry.resetTime) {
-            entry = {
-                count: 1,
-                resetTime: now + this.config.windowMs
-            };
-            this.store.set(key, entry);
-            return {
-                limited: false,
-                remaining: this.config.maxRequests - 1,
-                resetTime: entry.resetTime
-            };
-        }
-        // Increment count
-        entry.count++;
-        // Check if over limit
-        if (entry.count > this.config.maxRequests) {
-            return {
-                limited: true,
-                remaining: 0,
-                resetTime: entry.resetTime
-            };
-        }
-        return {
-            limited: false,
-            remaining: this.config.maxRequests - entry.count,
-            resetTime: entry.resetTime
-        };
-    }
-    /**
-     * Create middleware function
-     */
-    middleware() {
-        return (req, res, next) => {
-            const result = this.isRateLimited(req);
-            // Set rate limit headers
-            res.setHeader('X-RateLimit-Limit', this.config.maxRequests.toString());
-            res.setHeader('X-RateLimit-Remaining', result.remaining.toString());
-            res.setHeader('X-RateLimit-Reset', result.resetTime.toString());
-            if (result.limited) {
-                res.setHeader('Retry-After', Math.ceil((result.resetTime - Date.now()) / 1000).toString());
-                res.writeHead(429, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    error: this.config.message,
-                    retryAfter: Math.ceil((result.resetTime - Date.now()) / 1000)
-                }));
-                return;
-            }
-            next();
-        };
-    }
-    /**
-     * Reset rate limit for a specific key
-     */
-    reset(key) {
-        this.store.delete(key);
-    }
-    /**
-     * Clear all rate limit data
-     */
-    clear() {
-        this.store.clear();
-    }
-    /**
-     * Cleanup expired entries
-     */
-    cleanup() {
-        const now = Date.now();
-        for (const [key, entry] of this.store.entries()) {
-            if (now > entry.resetTime) {
-                this.store.delete(key);
-            }
-        }
-    }
-    /**
-     * Stop the cleanup interval
-     */
-    destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        this.store.clear();
-    }
-    /**
-     * Get current stats
-     */
-    getStats() {
-        return {
-            activeKeys: this.store.size,
-            config: this.config
-        };
-    }
-}
-
 /**
  * REST API for managing bots via HTTP endpoints using Polka
  */
@@ -41271,15 +41220,12 @@ class BotManagerApi {
      * Start the API server
      */
     start() {
-        this.app = polka()
-            .use(this.cors());
+        this.app = polka().use(this.cors());
         // Add rate limiter if enabled
         if (this.rateLimiter) {
             this.app.use(this.rateLimiter.middleware());
         }
-        this.app
-            .use(this.jsonParser())
-            .use(this.auth());
+        this.app.use(this.jsonParser()).use(this.auth());
         // Swagger UI - no auth required
         this.app.get('/docs', (req, res) => {
             res.writeHead(200, { 'Content-Type': 'text/html' });
@@ -41296,23 +41242,23 @@ class BotManagerApi {
                 ...health,
                 timestamp: new Date().toISOString(),
                 flows: this.flowRegistry.count(),
-                rateLimiter: this.rateLimiter?.getStats() || null
+                rateLimiter: this.rateLimiter?.getStats() || null,
             });
         });
         // ============ FLOWS ============
         // Get all flows
         this.app.get('/api/flows', (req, res) => {
-            const flows = this.flowRegistry.getAll().map(f => ({
+            const flows = this.flowRegistry.getAll().map((f) => ({
                 id: f.id,
                 name: f.name,
                 dynamic: f.dynamic,
                 config: f.dynamic ? f.config : undefined,
                 createdAt: f.createdAt,
-                updatedAt: f.updatedAt
+                updatedAt: f.updatedAt,
             }));
             this.sendJson(res, 200, {
                 count: flows.length,
-                flows
+                flows,
             });
         });
         // Create a new dynamic flow
@@ -41332,7 +41278,7 @@ class BotManagerApi {
                 dynamic: flow.dynamic,
                 config: flow.dynamic ? flow.config : undefined,
                 createdAt: flow.createdAt,
-                updatedAt: flow.updatedAt
+                updatedAt: flow.updatedAt,
             });
         });
         // Update a dynamic flow
@@ -41348,7 +41294,7 @@ class BotManagerApi {
             }
             if (!flow.dynamic) {
                 return this.sendJson(res, 400, {
-                    error: 'Cannot delete programmatic flows. Only dynamic flows can be deleted.'
+                    error: 'Cannot delete programmatic flows. Only dynamic flows can be deleted.',
                 });
             }
             this.flowRegistry.remove(flowId);
@@ -41359,7 +41305,7 @@ class BotManagerApi {
         this.app.get('/api/bots', (req, res) => {
             this.sendJson(res, 200, {
                 count: this.manager.getBotCount(),
-                bots: this.manager.getBotsInfo()
+                bots: this.manager.getBotsInfo(),
             });
         });
         // Create bot
@@ -41382,7 +41328,7 @@ class BotManagerApi {
                 uptime: Date.now() - bot.createdAt.getTime(),
                 providerType: bot.providerType,
                 databaseType: bot.databaseType,
-                reconnectState: this.manager.getReconnectState(tenantId)
+                reconnectState: this.manager.getReconnectState(tenantId),
             });
         });
         // Update bot
@@ -41413,7 +41359,7 @@ class BotManagerApi {
             this.sendJson(res, 200, {
                 status: bot.status,
                 qr: qr || null,
-                message: qr ? 'Scan QR to connect' : 'QR not available yet'
+                message: qr ? 'Scan QR to connect' : 'QR not available yet',
             });
         });
         // Restart bot
@@ -41426,7 +41372,7 @@ class BotManagerApi {
             const success = await this.manager.reconnectBot(tenantId);
             this.sendJson(res, success ? 200 : 404, {
                 success,
-                message: success ? 'Bot reconnection initiated' : 'Bot not found or no stored config'
+                message: success ? 'Bot reconnection initiated' : 'Bot not found or no stored config',
             });
         });
         // Stop bot
@@ -41435,7 +41381,7 @@ class BotManagerApi {
             const removed = await this.manager.removeBot(tenantId);
             this.sendJson(res, removed ? 200 : 404, {
                 success: removed,
-                message: removed ? 'Bot stopped' : 'Bot not found'
+                message: removed ? 'Bot stopped' : 'Bot not found',
             });
         });
         // Start server
@@ -41465,7 +41411,7 @@ class BotManagerApi {
         if (!validation.success || !validation.data) {
             return this.sendJson(res, 400, {
                 error: 'Validation failed',
-                details: validation.errors
+                details: validation.errors,
             });
         }
         const { tenantId, name, flowIds, port, providerOptions } = validation.data;
@@ -41474,7 +41420,7 @@ class BotManagerApi {
         if (missing.length > 0) {
             return this.sendJson(res, 400, {
                 error: `Flows not found: ${missing.join(', ')}`,
-                availableFlows: this.flowRegistry.getIds()
+                availableFlows: this.flowRegistry.getIds(),
             });
         }
         if (this.manager.hasBot(tenantId)) {
@@ -41486,7 +41432,7 @@ class BotManagerApi {
                 name,
                 flows,
                 port,
-                providerOptions
+                providerOptions,
             });
             this.sendJson(res, 201, {
                 message: 'Bot created successfully',
@@ -41496,7 +41442,7 @@ class BotManagerApi {
                 port: bot.port,
                 flowsUsed: flowIds,
                 providerType: bot.providerType,
-                databaseType: bot.databaseType
+                databaseType: bot.databaseType,
             });
         }
         catch (error) {
@@ -41509,7 +41455,7 @@ class BotManagerApi {
         if (!validation.success) {
             return this.sendJson(res, 400, {
                 error: 'Validation failed',
-                details: validation.errors
+                details: validation.errors,
             });
         }
         const bot = this.manager.getBot(tenantId);
@@ -41522,7 +41468,7 @@ class BotManagerApi {
         this.sendJson(res, 200, {
             message: 'Bot updated',
             tenantId: bot.tenantId,
-            name: bot.name
+            name: bot.name,
         });
     }
     async handleRestartBot(req, res) {
@@ -41531,16 +41477,14 @@ class BotManagerApi {
         if (!validation.success || !validation.data) {
             return this.sendJson(res, 400, {
                 error: 'Validation failed',
-                details: validation.errors
+                details: validation.errors,
             });
         }
         const { flowIds, port, name } = validation.data;
         const { flows, missing } = this.flowRegistry.resolveFlows(flowIds);
         if (flows.length === 0) {
             return this.sendJson(res, 400, {
-                error: missing.length > 0
-                    ? `Flows not found: ${missing.join(', ')}`
-                    : 'No valid flows found in registry'
+                error: missing.length > 0 ? `Flows not found: ${missing.join(', ')}` : 'No valid flows found in registry',
             });
         }
         try {
@@ -41551,7 +41495,7 @@ class BotManagerApi {
             this.sendJson(res, 200, {
                 message: 'Bot restarted',
                 tenantId,
-                status: newBot.status
+                status: newBot.status,
             });
         }
         catch (error) {
@@ -41564,7 +41508,7 @@ class BotManagerApi {
         if (!validation.success || !validation.data) {
             return this.sendJson(res, 400, {
                 error: 'Validation failed',
-                details: validation.errors
+                details: validation.errors,
             });
         }
         const { id } = validation.data;
@@ -41579,7 +41523,7 @@ class BotManagerApi {
                 name: flowDef.name,
                 dynamic: true,
                 config: flowDef.config,
-                createdAt: flowDef.createdAt
+                createdAt: flowDef.createdAt,
             });
         }
         catch (error) {
@@ -41594,14 +41538,14 @@ class BotManagerApi {
         }
         if (!existing.dynamic) {
             return this.sendJson(res, 400, {
-                error: 'Cannot update programmatic flows. Only dynamic flows can be updated.'
+                error: 'Cannot update programmatic flows. Only dynamic flows can be updated.',
             });
         }
         const validation = validate(updateFlowSchema, req.body);
         if (!validation.success) {
             return this.sendJson(res, 400, {
                 error: 'Validation failed',
-                details: validation.errors
+                details: validation.errors,
             });
         }
         try {
@@ -41615,7 +41559,7 @@ class BotManagerApi {
                 name: flowDef.name,
                 dynamic: true,
                 config: flowDef.config,
-                updatedAt: flowDef.updatedAt
+                updatedAt: flowDef.updatedAt,
             });
         }
         catch (error) {
@@ -41633,7 +41577,7 @@ class PersistenceManager {
         this.config = {
             persistenceDir: config.persistenceDir ?? './data',
             fileName: config.fileName ?? 'bots.json',
-            autoSave: config.autoSave ?? true
+            autoSave: config.autoSave ?? true,
         };
         this.filePath = require$$1$5.join(this.config.persistenceDir, this.config.fileName);
         this.load();
@@ -41651,7 +41595,7 @@ class PersistenceManager {
             databaseOptions: config.databaseOptions,
             providerClassName,
             databaseClassName,
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
         };
         this.data.set(tenantId, serializableConfig);
         if (this.config.autoSave) {
@@ -41713,7 +41657,7 @@ class PersistenceManager {
             const dataToSave = {
                 version: 1,
                 updatedAt: new Date().toISOString(),
-                bots: Array.from(this.data.entries())
+                bots: Array.from(this.data.entries()),
             };
             require$$0$9.writeFileSync(this.filePath, JSON.stringify(dataToSave, null, 2), 'utf-8');
         }