plazbot-cli 0.1.2 → 0.1.4

package/dist/commands/agent/tools.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolsCommand = void 0;
+const commander_1 = require("commander");
+const plazbot_1 = require("plazbot");
+const inquirer_1 = __importDefault(require("inquirer"));
+const credentials_1 = require("../../utils/credentials");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+exports.toolsCommand = new commander_1.Command('tools')
+    .description('Gestionar herramientas de Tool Calling del agente')
+    .argument('<agentId>', 'ID del agente')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (agentId, options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const agent = new plazbot_1.Agent({
+            workspaceId: credentials.workspace,
+            apiKey: credentials.apiKey,
+            zone: credentials.zone,
+            ...(options.dev && { customUrl: "http://localhost:5090" })
+        });
+        const spinner = (0, ui_1.createSpinner)('Cargando agente...');
+        spinner.start();
+        const agentData = await agent.getAgentById({ id: agentId });
+        spinner.stop();
+        console.log((0, ui_1.section)('Tool Calling - ' + (agentData.name || agentId)));
+        console.log((0, ui_1.kvPair)('Estado', agentData.useToolCalling ? ui_1.theme.success('Activado') : ui_1.theme.error('Desactivado')));
+        // Servicios
+        const services = agentData.services || [];
+        if (services.length > 0) {
+            console.log((0, ui_1.section)('Servicios (API calls)'));
+            const rows = services.map((s) => [
+                s.intent,
+                s.method || 'POST',
+                s.endpoint ? s.endpoint.substring(0, 40) + '...' : 'N/A',
+                (0, ui_1.statusBadge)(s.enabled !== false),
+            ]);
+            console.log((0, ui_1.createTable)(['Intent', 'Method', 'Endpoint', 'Estado'], rows));
+        }
+        else {
+            console.log(ui_1.theme.muted('\n  No hay servicios configurados'));
+        }
+        // Acciones
+        const actions = agentData.actions || [];
+        if (actions.length > 0) {
+            console.log((0, ui_1.section)('Acciones'));
+            const rows = actions.map((a) => [
+                a.intent,
+                (a.action || []).map((ac) => ac.type).join(', '),
+                (0, ui_1.statusBadge)(a.enabled !== false),
+            ]);
+            console.log((0, ui_1.createTable)(['Intent', 'Tipo', 'Estado'], rows));
+        }
+        else {
+            console.log(ui_1.theme.muted('\n  No hay acciones configuradas'));
+        }
+        // Menu de opciones
+        console.log();
+        const { action } = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'Que deseas hacer?',
+                choices: [
+                    { name: 'Agregar servicio (API call)', value: 'add-service' },
+                    { name: 'Agregar accion', value: 'add-action' },
+                    { name: agentData.useToolCalling ? 'Desactivar Tool Calling' : 'Activar Tool Calling', value: 'toggle' },
+                    { name: 'Salir', value: 'exit' },
+                ],
+            }]);
+        if (action === 'exit')
+            return;
+        if (action === 'toggle') {
+            const toggleSpinner = (0, ui_1.createSpinner)('Actualizando...');
+            toggleSpinner.start();
+            const updatedConfig = { ...agentData, useToolCalling: !agentData.useToolCalling };
+            delete updatedConfig.id;
+            delete updatedConfig._id;
+            await agent.updateAgent(agentId, updatedConfig);
+            toggleSpinner.succeed(`Tool Calling ${!agentData.useToolCalling ? 'activado' : 'desactivado'}`);
+            return;
+        }
+        if (action === 'add-service') {
+            const svc = await inquirer_1.default.prompt([
+                { type: 'input', name: 'intent', message: 'Nombre/intent del servicio:', validate: (v) => v.length > 0 || 'Requerido' },
+                { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
+                { type: 'list', name: 'method', message: 'Metodo HTTP:', choices: ['GET', 'POST'] },
+                { type: 'input', name: 'endpoint', message: 'URL del endpoint:', validate: (v) => v.length > 0 || 'Requerido' },
+                { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+            ]);
+            const newService = {
+                intent: svc.intent,
+                reference: svc.reference,
+                enabled: true,
+                method: svc.method,
+                endpoint: svc.endpoint,
+                requiredFields: [],
+                headers: {},
+                bodyTemplate: {},
+                responseMapping: {},
+                responseMessage: svc.responseMessage,
+                responseConditions: [],
+            };
+            const updatedServices = [...services, newService];
+            const updatedConfig = { ...agentData, services: updatedServices, useToolCalling: true };
+            delete updatedConfig.id;
+            delete updatedConfig._id;
+            const updateSpinner = (0, ui_1.createSpinner)('Guardando servicio...');
+            updateSpinner.start();
+            await agent.updateAgent(agentId, updatedConfig);
+            updateSpinner.succeed(`Servicio "${svc.intent}" agregado`);
+        }
+        if (action === 'add-action') {
+            const act = await inquirer_1.default.prompt([
+                { type: 'input', name: 'intent', message: 'Nombre/intent de la accion:', validate: (v) => v.length > 0 || 'Requerido' },
+                { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
+                {
+                    type: 'list', name: 'actionType', message: 'Tipo de accion:',
+                    choices: [
+                        { name: 'Agendar evento', value: 'action.event.add' },
+                        { name: 'Actualizar evento (reagendar)', value: 'action.event.update' },
+                        { name: 'Listar eventos', value: 'action.event.list' },
+                        { name: 'Eliminar evento (cancelar)', value: 'action.event.delete' },
+                        { name: 'Agregar tag', value: 'action.tag' },
+                        { name: 'Cambiar stage', value: 'action.stage' },
+                        { name: 'Derivar a agente humano', value: 'action.agentShutDown' },
+                        { name: 'Marcar como resuelto', value: 'action.solved' },
+                        { name: 'Asignar agente', value: 'action.asign' },
+                        { name: 'Segmentacion', value: 'action.segmentation' },
+                    ],
+                },
+                { type: 'input', name: 'actionValue', message: 'Valor (opcional):', default: '' },
+                { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+            ]);
+            const newAction = {
+                intent: act.intent,
+                reference: act.reference,
+                enabled: true,
+                requiredFields: [],
+                responseMessage: act.responseMessage,
+                action: [{ type: act.actionType, value: act.actionValue }],
+            };
+            const updatedActions = [...actions, newAction];
+            const updatedConfig = { ...agentData, actions: updatedActions, useToolCalling: true };
+            delete updatedConfig.id;
+            delete updatedConfig._id;
+            const updateSpinner = (0, ui_1.createSpinner)('Guardando accion...');
+            updateSpinner.start();
+            await agent.updateAgent(agentId, updatedConfig);
+            updateSpinner.succeed(`Accion "${act.intent}" agregada`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger_1.logger.error(message);
+        process.exit(1);
+    }
+});

package/dist/commands/agent/wizard.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentWizard = runAgentWizard;
+const inquirer_1 = __importDefault(require("inquirer"));
+const ui_1 = require("../../utils/ui");
+const MODELS = {
+    openai: ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'o1-preview', 'o1-mini'],
+    claude: ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
+    gemini: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+};
+const COLORS = ['blue', 'green', 'orange', 'gray', 'white'];
+async function runAgentWizard(zone) {
+    console.log((0, ui_1.section)('Crear nuevo agente de IA'));
+    console.log(ui_1.theme.muted('  Responde las siguientes preguntas para configurar tu agente.\n'));
+    // Paso 1: Informacion basica
+    console.log(ui_1.theme.bold('\n  Paso 1/8: Informacion basica'));
+    const basic = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Nombre del agente:',
+            validate: (v) => v.length > 0 || 'El nombre es requerido',
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Descripcion breve:',
+            default: '',
+        },
+        {
+            type: 'input',
+            name: 'prompt',
+            message: 'Prompt del sistema (instrucciones principales):',
+            default: 'Eres un asistente virtual amigable y profesional.',
+        },
+        {
+            type: 'number',
+            name: 'buffer',
+            message: 'Buffer de conversacion (3-20 mensajes):',
+            default: 5,
+            validate: (v) => (v >= 3 && v <= 20) || 'Debe ser entre 3 y 20',
+        },
+        {
+            type: 'list',
+            name: 'color',
+            message: 'Color del agente:',
+            choices: COLORS,
+            default: 'blue',
+        },
+    ]);
+    // Paso 2: Personalidad
+    console.log(ui_1.theme.bold('\n  Paso 2/8: Personalidad e instrucciones'));
+    const personality = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'tone',
+            message: 'Tono de comunicacion:',
+            choices: ['profesional', 'amigable', 'formal', 'casual', 'tecnico', 'empatico'],
+            default: 'profesional',
+        },
+        {
+            type: 'list',
+            name: 'style',
+            message: 'Estilo de respuesta:',
+            choices: ['conciso', 'detallado', 'conversacional', 'directo'],
+            default: 'conciso',
+        },
+        {
+            type: 'input',
+            name: 'personality',
+            message: 'Personalidad en una frase:',
+            default: 'Servicial y conocedor',
+        },
+        {
+            type: 'input',
+            name: 'objective',
+            message: 'Objetivo principal del agente:',
+            default: 'Ayudar a los usuarios con sus consultas',
+        },
+        {
+            type: 'list',
+            name: 'language',
+            message: 'Idioma principal:',
+            choices: ['Espanol', 'English', 'Portugues', 'Frances'],
+            default: 'Espanol',
+        },
+        {
+            type: 'confirm',
+            name: 'useEmojis',
+            message: 'Usar emojis en respuestas?',
+            default: true,
+        },
+    ]);
+    // Paso 3: Persona
+    console.log(ui_1.theme.bold('\n  Paso 3/8: Identidad del agente'));
+    const person = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Nombre del personaje (como se presenta):',
+            default: basic.name,
+        },
+        {
+            type: 'input',
+            name: 'role',
+            message: 'Rol (ej: Asistente de ventas, Soporte tecnico):',
+            default: 'Asistente virtual',
+        },
+        {
+            type: 'confirm',
+            name: 'firstPerson',
+            message: 'Hablar en primera persona?',
+            default: true,
+        },
+    ]);
+    // Paso 4: Fallbacks
+    console.log(ui_1.theme.bold('\n  Paso 4/8: Mensajes de fallback'));
+    const fallbacks = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'noAnswer',
+            message: 'Cuando no tiene respuesta:',
+            default: 'Lo siento, no tengo informacion sobre eso. Puedo ayudarte con otra consulta?',
+        },
+        {
+            type: 'input',
+            name: 'serviceError',
+            message: 'Cuando hay error de servicio:',
+            default: 'Disculpa, estamos experimentando dificultades tecnicas. Intenta de nuevo en unos momentos.',
+        },
+        {
+            type: 'input',
+            name: 'misunderstanding',
+            message: 'Cuando no entiende la pregunta:',
+            default: 'No estoy seguro de entender tu consulta. Podrias reformularla?',
+        },
+    ]);
+    // Paso 5: Tool Calling
+    console.log(ui_1.theme.bold('\n  Paso 5/8: Tool Calling'));
+    console.log(ui_1.theme.muted('  Tool Calling permite al agente ejecutar acciones automaticas\n'));
+    const { useToolCalling } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'useToolCalling',
+            message: 'Activar Tool Calling?',
+            default: true,
+        },
+    ]);
+    // Servicios (API calls)
+    const services = [];
+    if (useToolCalling) {
+        const { addServices } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'addServices',
+                message: 'Agregar servicios externos (API calls)?',
+                default: false,
+            }]);
+        if (addServices) {
+            let addMore = true;
+            while (addMore) {
+                console.log(ui_1.theme.muted('\n  Nuevo servicio:'));
+                const svc = await inquirer_1.default.prompt([
+                    { type: 'input', name: 'intent', message: 'Nombre/intent del servicio:', validate: (v) => v.length > 0 || 'Requerido' },
+                    { type: 'input', name: 'reference', message: 'Palabras clave de referencia:', default: '' },
+                    { type: 'list', name: 'method', message: 'Metodo HTTP:', choices: ['GET', 'POST'] },
+                    { type: 'input', name: 'endpoint', message: 'URL del endpoint:', validate: (v) => v.length > 0 || 'Requerido' },
+                    { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+                ]);
+                // Required fields
+                const fields = [];
+                const { addFields } = await inquirer_1.default.prompt([{
+                        type: 'confirm', name: 'addFields',
+                        message: 'Agregar campos requeridos?', default: false,
+                    }]);
+                if (addFields) {
+                    let moreFields = true;
+                    while (moreFields) {
+                        const field = await inquirer_1.default.prompt([
+                            { type: 'input', name: 'name', message: 'Nombre del campo:' },
+                            { type: 'list', name: 'type', message: 'Tipo:', choices: ['string', 'number', 'boolean', 'date'] },
+                            { type: 'input', name: 'description', message: 'Descripcion:' },
+                            { type: 'input', name: 'promptHint', message: 'Hint para el LLM:' },
+                        ]);
+                        fields.push(field);
+                        const { more } = await inquirer_1.default.prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro campo?', default: false }]);
+                        moreFields = more;
+                    }
+                }
+                services.push({
+                    intent: svc.intent,
+                    reference: svc.reference,
+                    enabled: true,
+                    method: svc.method,
+                    endpoint: svc.endpoint,
+                    requiredFields: fields,
+                    headers: {},
+                    bodyTemplate: {},
+                    responseMapping: {},
+                    responseMessage: svc.responseMessage,
+                    responseConditions: [],
+                });
+                const { more } = await inquirer_1.default.prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro servicio?', default: false }]);
+                addMore = more;
+            }
+        }
+    }
+    // Acciones
+    const actions = [];
+    if (useToolCalling) {
+        const { addActions } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'addActions',
+                message: 'Agregar acciones (tag, stage, asignar agente)?',
+                default: false,
+            }]);
+        if (addActions) {
+            let addMore = true;
+            while (addMore) {
+                console.log(ui_1.theme.muted('\n  Nueva accion:'));
+                const act = await inquirer_1.default.prompt([
+                    { type: 'input', name: 'intent', message: 'Nombre/intent de la accion:', validate: (v) => v.length > 0 || 'Requerido' },
+                    { type: 'input', name: 'reference', message: 'Palabras clave de referencia:', default: '' },
+                    {
+                        type: 'list', name: 'actionType', message: 'Tipo de accion:',
+                        choices: [
+                            { name: 'Agendar evento', value: 'action.event.add' },
+                            { name: 'Actualizar evento (reagendar)', value: 'action.event.update' },
+                            { name: 'Listar eventos', value: 'action.event.list' },
+                            { name: 'Eliminar evento (cancelar)', value: 'action.event.delete' },
+                            { name: 'Agregar tag', value: 'action.tag' },
+                            { name: 'Cambiar stage', value: 'action.stage' },
+                            { name: 'Derivar a agente humano', value: 'action.agentShutDown' },
+                            { name: 'Marcar como resuelto', value: 'action.solved' },
+                            { name: 'Asignar agente', value: 'action.asign' },
+                            { name: 'Segmentacion', value: 'action.segmentation' },
+                        ],
+                    },
+                    { type: 'input', name: 'actionValue', message: 'Valor de la accion:', default: '' },
+                    { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+                ]);
+                actions.push({
+                    intent: act.intent,
+                    reference: act.reference,
+                    enabled: true,
+                    requiredFields: [],
+                    responseMessage: act.responseMessage,
+                    action: [{ type: act.actionType, value: act.actionValue }],
+                });
+                const { more } = await inquirer_1.default.prompt([{ type: 'confirm', name: 'more', message: 'Agregar otra accion?', default: false }]);
+                addMore = more;
+            }
+        }
+    }
+    // Paso 6: AI Provider
+    console.log(ui_1.theme.bold('\n  Paso 6/8: Proveedor de IA'));
+    const { configureAI } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'configureAI',
+            message: 'Configurar proveedor de IA personalizado?',
+            default: false,
+        }]);
+    const aiProviders = [];
+    if (configureAI) {
+        const ai = await inquirer_1.default.prompt([
+            { type: 'list', name: 'provider', message: 'Proveedor:', choices: ['openai', 'claude', 'gemini'] },
+        ]);
+        const models = MODELS[ai.provider] || MODELS.openai;
+        const aiConfig = await inquirer_1.default.prompt([
+            { type: 'list', name: 'model', message: 'Modelo:', choices: models },
+            { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v) => v.length > 0 || 'Requerido' },
+            { type: 'number', name: 'temperature', message: 'Temperatura (0-2):', default: 0.7 },
+            { type: 'number', name: 'maxTokens', message: 'Max tokens (1024-16384):', default: 4096 },
+        ]);
+        aiProviders.push({
+            provider: ai.provider,
+            model: aiConfig.model,
+            apiToken: aiConfig.apiToken,
+            temperature: aiConfig.temperature,
+            maxTokens: aiConfig.maxTokens,
+            isDefault: true,
+        });
+    }
+    // Paso 7: Canal WhatsApp
+    console.log(ui_1.theme.bold('\n  Paso 7/8: Canal WhatsApp'));
+    const channels = [];
+    const { addWhatsApp } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'addWhatsApp',
+            message: 'Conectar a un numero de WhatsApp?',
+            default: false,
+        }]);
+    if (addWhatsApp) {
+        const wa = await inquirer_1.default.prompt([
+            { type: 'input', name: 'key', message: 'Numero de WhatsApp (con codigo de pais):', validate: (v) => v.length > 0 || 'Requerido' },
+            { type: 'confirm', name: 'multianswer', message: 'Permitir multiples respuestas?', default: false },
+        ]);
+        channels.push({ channel: 'whatsapp', key: wa.key, multianswer: wa.multianswer });
+    }
+    // Paso 8: Ejemplos
+    console.log(ui_1.theme.bold('\n  Paso 8/8: Ejemplos de conversacion'));
+    const examples = [];
+    const { addExamples } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'addExamples',
+            message: 'Agregar ejemplos de conversacion?',
+            default: false,
+        }]);
+    if (addExamples) {
+        let addMore = true;
+        while (addMore) {
+            const ex = await inquirer_1.default.prompt([
+                { type: 'input', name: 'user', message: 'Mensaje del usuario:' },
+                { type: 'input', name: 'agent', message: 'Respuesta del agente:' },
+            ]);
+            examples.push({ value: `Usuario: ${ex.user}\nAgente: ${ex.agent}`, color: 'blue' });
+            const { more } = await inquirer_1.default.prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro ejemplo?', default: false }]);
+            addMore = more;
+        }
+    }
+    // Armar config final (alineado con agent.config.schema.json del backend)
+    const config = {
+        name: basic.name,
+        description: basic.description || '',
+        prompt: basic.prompt,
+        buffer: basic.buffer,
+        zone,
+        color: basic.color,
+        useToolCalling,
+        customAIConfig: configureAI,
+        aiProviders,
+        instructions: {
+            tone: personality.tone,
+            style: personality.style,
+            personality: personality.personality,
+            objective: personality.objective,
+            language: personality.language,
+            emojis: personality.useEmojis,
+        },
+        person: {
+            name: person.name,
+            role: person.role,
+            speaksInFirstPerson: person.firstPerson,
+        },
+        fallbacks: {
+            noAnswer: fallbacks.noAnswer,
+            serviceError: fallbacks.serviceError,
+            doNotUnderstand: fallbacks.misunderstanding,
+        },
+        services,
+        actions,
+        channels,
+        examples,
+        tags: [],
+    };
+    // Preview
+    console.log((0, ui_1.section)('Vista previa de la configuracion'));
+    console.log((0, ui_1.kvPair)('Nombre', config.name));
+    console.log((0, ui_1.kvPair)('Prompt', config.prompt.substring(0, 80) + '...'));
+    console.log((0, ui_1.kvPair)('Tool Calling', config.useToolCalling ? 'Activado' : 'Desactivado'));
+    console.log((0, ui_1.kvPair)('Servicios', String(config.services.length)));
+    console.log((0, ui_1.kvPair)('Acciones', String(config.actions.length)));
+    console.log((0, ui_1.kvPair)('AI Provider', config.customAIConfig ? config.aiProviders[0]?.provider + ' / ' + config.aiProviders[0]?.model : 'Default (Plazbot)'));
+    console.log((0, ui_1.kvPair)('Canal WhatsApp', config.channels.length > 0 ? config.channels[0].key : 'No configurado'));
+    console.log();
+    return config;
+}

package/dist/commands/whatsapp/broadcast.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcastCommand = void 0;
+const commander_1 = require("commander");
+const plazbot_1 = require("plazbot");
+const credentials_1 = require("../../utils/credentials");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+const promises_1 = __importDefault(require("fs/promises"));
+exports.broadcastCommand = new commander_1.Command('broadcast')
+    .description('Envio masivo de mensajes de template WhatsApp')
+    .requiredOption('-t, --template <name>', 'Nombre del template')
+    .requiredOption('--phones <file>', 'Archivo CSV con numeros de telefono (uno por linea)')
+    .option('--var <vars...>', 'Variables del body (formato: name=valor)')
+    .option('--delay <ms>', 'Delay entre mensajes en ms', '1000')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const messageClient = new plazbot_1.Message({
+            workspaceId: credentials.workspace,
+            apiKey: credentials.apiKey,
+            zone: credentials.zone,
+            ...(options.dev && { customUrl: "http://localhost:5090" })
+        });
+        // Leer archivo de telefonos
+        let phones;
+        try {
+            const content = await promises_1.default.readFile(options.phones, 'utf-8');
+            phones = content.split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+        }
+        catch {
+            throw new Error(`No se pudo leer el archivo: ${options.phones}`);
+        }
+        if (phones.length === 0) {
+            throw new Error('El archivo no contiene numeros de telefono');
+        }
+        // Parsear variables
+        const variablesBody = parseVariables(options.var);
+        console.log((0, ui_1.section)('Broadcast WhatsApp'));
+        logger_1.logger.label('Template', options.template);
+        logger_1.logger.label('Destinatarios', String(phones.length));
+        logger_1.logger.label('Delay', `${options.delay}ms`);
+        if (variablesBody.length > 0) {
+            logger_1.logger.label('Variables', variablesBody.map(v => `${v.variable}=${v.value}`).join(', '));
+        }
+        console.log();
+        const delay = parseInt(options.delay) || 1000;
+        let sent = 0;
+        let failed = 0;
+        for (let i = 0; i < phones.length; i++) {
+            const phone = phones[i];
+            try {
+                const params = {
+                    to: phone,
+                    template: options.template,
+                };
+                if (variablesBody.length > 0)
+                    params.variablesBody = variablesBody;
+                await messageClient.onConversation(params);
+                sent++;
+            }
+            catch {
+                failed++;
+                console.log(ui_1.theme.error(`  ✖ Fallo: ${phone}`));
+            }
+            // Progress
+            console.log(`  ${(0, ui_1.progressBar)(i + 1, phones.length)}`);
+            // Rate limiting
+            if (i < phones.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        console.log((0, ui_1.section)('Resultado'));
+        logger_1.logger.label('Enviados', ui_1.theme.success(String(sent)));
+        logger_1.logger.label('Fallidos', failed > 0 ? ui_1.theme.error(String(failed)) : '0');
+        logger_1.logger.label('Total', String(phones.length));
+    }
+    catch (error) {
+        const message = error?.message || 'Error desconocido';
+        logger_1.logger.error(message);
+        process.exit(1);
+    }
+});
+function parseVariables(vars) {
+    if (!vars)
+        return [];
+    return vars.map(v => {
+        const [variable, ...rest] = v.split('=');
+        return { variable: variable.trim(), value: rest.join('=').trim() };
+    }).filter(v => v.variable && v.value);
+}