plazbot-cli 0.2.20 → 0.2.21

package/dist/cli.js

@@ -6,6 +6,7 @@ const portal_1 = require("./commands/portal");
 const auth_1 = require("./commands/auth");
 const agent_1 = require("./commands/agent");
 const whatsapp_1 = require("./commands/whatsapp");
+const workers_1 = require("./commands/workers");
 const banner_1 = require("./utils/banner");
 // Configuracion basica del CLI
 commander_1.program
@@ -20,6 +21,8 @@ commander_1.program.addCommand(agent_1.agentCommands);
 commander_1.program.addCommand(portal_1.portalCommands);
 // Registrar todos los comandos de WhatsApp
 commander_1.program.addCommand(whatsapp_1.whatsappCommands);
+// Registrar todos los comandos de Workers
+commander_1.program.addCommand(workers_1.workersCommands);
 // Si no se pasan argumentos, mostrar banner
 if (process.argv.length <= 2) {
     (0, banner_1.showBanner)().then(() => {

package/dist/commands/workers/deploy.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = void 0;
+const commander_1 = require("commander");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+exports.deployCommand = new commander_1.Command('deploy')
+    .description('Despliega un worker al workspace de Plazbot')
+    .argument('[file]', 'Archivo TypeScript del worker (ej: ./workers/mi-tool.ts)')
+    .option('-n, --name <name>', 'Nombre del worker (sobreescribe el del archivo)')
+    .option('-d, --description <desc>', 'Descripcion del worker')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (file, options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        // Buscar archivos de workers
+        const files = await resolveWorkerFiles(file);
+        if (files.length === 0) {
+            logger_1.logger.error('No se encontraron archivos de workers para desplegar');
+            logger_1.logger.dim('Uso: plazbot workers deploy ./workers/mi-tool.ts');
+            logger_1.logger.dim('  o: plazbot workers deploy (busca en ./workers/ automaticamente)');
+            process.exit(1);
+        }
+        const api = (0, api_1.createApiClient)({
+            apiKey: credentials.apiKey,
+            workspace: credentials.workspace,
+            zone: credentials.zone,
+            dev: options.dev,
+        });
+        logger_1.logger.title(`Desplegando ${files.length} worker${files.length > 1 ? 's' : ''}`);
+        console.log();
+        const results = [];
+        for (const filePath of files) {
+            const fileName = path_1.default.basename(filePath);
+            const spinner = (0, ui_1.createSpinner)(`Desplegando ${fileName}...`);
+            spinner.start();
+            try {
+                // Leer archivo fuente
+                const sourceCode = await promises_1.default.readFile(filePath, 'utf-8');
+                // Enviar al API
+                const response = await api.post('/api/workers/deploy', {
+                    sourceCode,
+                    fileName,
+                    name: files.length === 1 ? options.name : undefined,
+                    description: files.length === 1 ? options.description : undefined,
+                });
+                const data = response.data;
+                spinner.succeed(`${fileName} → ${data.name} (${data.type})`);
+                results.push({ file: fileName, result: data });
+            }
+            catch (error) {
+                const msg = error.response?.data?.message || error.message || 'Error desconocido';
+                spinner.fail(`${fileName}: ${msg}`);
+                results.push({ file: fileName, error: msg });
+            }
+        }
+        // Resumen
+        console.log();
+        const success = results.filter(r => r.result);
+        const failed = results.filter(r => r.error);
+        if (success.length > 0) {
+            logger_1.logger.success(`${success.length} worker${success.length > 1 ? 's' : ''} desplegado${success.length > 1 ? 's' : ''}`);
+            const rows = success.map(r => [
+                r.result.name,
+                r.result.type,
+                r.result.status,
+                r.result.webhookUrl || r.result.cronExpression || '—',
+            ]);
+            console.log((0, ui_1.createTable)(['Nombre', 'Tipo', 'Estado', 'URL/Cron'], rows));
+        }
+        if (failed.length > 0) {
+            logger_1.logger.warning(`${failed.length} worker${failed.length > 1 ? 's' : ''} fallaron`);
+            failed.forEach(f => logger_1.logger.dim(`  ${f.file}: ${f.error}`));
+        }
+        // Mostrar webhook URLs si hay
+        const webhooks = success.filter(r => r.result.webhookUrl);
+        if (webhooks.length > 0) {
+            console.log();
+            logger_1.logger.title('Webhook URLs');
+            webhooks.forEach(w => {
+                logger_1.logger.label(w.result.name, ui_1.theme.secondary(w.result.webhookUrl));
+            });
+        }
+        console.log();
+        if (options.dev) {
+            logger_1.logger.warning('Ambiente: desarrollo');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger_1.logger.error(message);
+        process.exit(1);
+    }
+});
+// Resuelve los archivos a desplegar
+async function resolveWorkerFiles(file) {
+    if (file) {
+        // Archivo especifico
+        const resolved = path_1.default.resolve(file);
+        try {
+            await promises_1.default.access(resolved);
+            return [resolved];
+        }
+        catch {
+            throw new Error(`Archivo no encontrado: ${file}`);
+        }
+    }
+    // Buscar en ./workers/ automaticamente
+    const workersDir = path_1.default.resolve('workers');
+    try {
+        const entries = await promises_1.default.readdir(workersDir);
+        const tsFiles = entries
+            .filter(e => e.endsWith('.ts') && !e.endsWith('.d.ts'))
+            .map(e => path_1.default.join(workersDir, e));
+        return tsFiles;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/workers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workersCommands = void 0;
+const commander_1 = require("commander");
+const deploy_1 = require("./deploy");
+const list_1 = require("./list");
+const logs_1 = require("./logs");
+const remove_1 = require("./remove");
+const secret_1 = require("./secret");
+const test_1 = require("./test");
+exports.workersCommands = new commander_1.Command('workers')
+    .description('Comandos para gestionar workers (tools, syncs, schedules, webhooks)')
+    .addCommand(deploy_1.deployCommand)
+    .addCommand(list_1.listCommand)
+    .addCommand(logs_1.logsCommand)
+    .addCommand(remove_1.removeCommand)
+    .addCommand(secret_1.secretCommand)
+    .addCommand(test_1.testCommand);

package/dist/commands/workers/list.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = void 0;
+const commander_1 = require("commander");
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+exports.listCommand = new commander_1.Command('list')
+    .description('Lista todos los workers del workspace')
+    .option('-t, --type <type>', 'Filtrar por tipo (tool, worker, sync, schedule, webhook)')
+    .option('-s, --status <status>', 'Filtrar por estado (active, inactive, error)')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const api = (0, api_1.createApiClient)({
+            apiKey: credentials.apiKey,
+            workspace: credentials.workspace,
+            zone: credentials.zone,
+            dev: options.dev,
+        });
+        const spinner = (0, ui_1.createSpinner)('Obteniendo workers...');
+        spinner.start();
+        const params = {};
+        if (options.type)
+            params.type = options.type;
+        if (options.status)
+            params.status = options.status;
+        const response = await api.get('/api/workers', { params });
+        const workers = response.data;
+        spinner.stop();
+        if (!workers || workers.length === 0) {
+            logger_1.logger.info('\n  No se encontraron workers en este workspace');
+            logger_1.logger.dim('  Despliega tu primer worker: plazbot workers deploy ./workers/mi-tool.ts');
+            console.log();
+            return;
+        }
+        logger_1.logger.title(`Workers (${workers.length})`);
+        const rows = workers.map(w => [
+            w.name,
+            typeLabel(w.type),
+            w.status === 'active' ? ui_1.theme.success('activo')
+                : w.status === 'error' ? ui_1.theme.error('error')
+                    : ui_1.theme.muted('inactivo'),
+            `${w.executionCount}`,
+            w.errorCount > 0 ? ui_1.theme.error(`${w.errorCount}`) : ui_1.theme.muted('0'),
+            w.avgDurationMs > 0 ? `${w.avgDurationMs}ms` : '—',
+            w.lastExecutedAt ? (0, ui_1.formatDate)(w.lastExecutedAt) : '—',
+        ]);
+        console.log((0, ui_1.createTable)(['Nombre', 'Tipo', 'Estado', 'Ejecuciones', 'Errores', 'Duracion', 'Ultima ejecucion'], rows));
+        // Mostrar workers con error
+        const errored = workers.filter(w => w.status === 'error');
+        if (errored.length > 0) {
+            console.log();
+            logger_1.logger.warning('Workers con error:');
+            errored.forEach(w => {
+                logger_1.logger.dim(`  ${w.name}: ${w.lastError || 'sin detalles'}`);
+            });
+        }
+        console.log();
+        if (options.dev) {
+            logger_1.logger.warning('Ambiente: desarrollo');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger_1.logger.error(message);
+        process.exit(1);
+    }
+});
+function typeLabel(type) {
+    const labels = {
+        tool: ui_1.theme.secondary('tool'),
+        worker: ui_1.theme.primary('worker'),
+        sync: ui_1.theme.accent('sync'),
+        schedule: ui_1.theme.muted('schedule'),
+        webhook: ui_1.theme.warning('webhook'),
+    };
+    return labels[type] || type;
+}

package/dist/commands/workers/logs.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logsCommand = void 0;
+const commander_1 = require("commander");
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+exports.logsCommand = new commander_1.Command('logs')
+    .description('Ver logs de ejecucion de un worker')
+    .argument('<name>', 'Nombre del worker')
+    .option('-l, --limit <number>', 'Numero de logs a mostrar', '20')
+    .option('-s, --status <status>', 'Filtrar por estado (success, error, timeout)')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (name, options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const api = (0, api_1.createApiClient)({
+            apiKey: credentials.apiKey,
+            workspace: credentials.workspace,
+            zone: credentials.zone,
+            dev: options.dev,
+        });
+        const spinner = (0, ui_1.createSpinner)(`Obteniendo logs de "${name}"...`);
+        spinner.start();
+        const params = {
+            limit: String(options.limit || 20),
+        };
+        if (options.status)
+            params.status = options.status;
+        const response = await api.get(`/api/workers/${encodeURIComponent(name)}/logs`, { params });
+        const logs = response.data;
+        spinner.stop();
+        if (!logs || logs.length === 0) {
+            logger_1.logger.info(`\n  No se encontraron logs para "${name}"`);
+            console.log();
+            return;
+        }
+        logger_1.logger.title(`Logs de "${name}" (${logs.length})`);
+        const rows = logs.map(log => [
+            (0, ui_1.formatDate)(log.createdAt),
+            log.status === 'success' ? ui_1.theme.success('ok')
+                : log.status === 'error' ? ui_1.theme.error('error')
+                    : ui_1.theme.warning('timeout'),
+            `${log.durationMs}ms`,
+            log.triggerSource || '—',
+            log.error ? ui_1.theme.error(truncate(log.error, 40)) : '—',
+        ]);
+        console.log((0, ui_1.createTable)(['Fecha', 'Estado', 'Duracion', 'Origen', 'Error'], rows));
+        // Resumen
+        const successCount = logs.filter(l => l.status === 'success').length;
+        const errorCount = logs.filter(l => l.status === 'error').length;
+        const avgDuration = Math.round(logs.reduce((sum, l) => sum + l.durationMs, 0) / logs.length);
+        console.log();
+        logger_1.logger.label('Exitosos', ui_1.theme.success(`${successCount}`));
+        logger_1.logger.label('Errores', errorCount > 0 ? ui_1.theme.error(`${errorCount}`) : ui_1.theme.muted('0'));
+        logger_1.logger.label('Duracion promedio', `${avgDuration}ms`);
+        console.log();
+        if (options.dev) {
+            logger_1.logger.warning('Ambiente: desarrollo');
+        }
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            logger_1.logger.error(`Worker "${name}" no encontrado`);
+        }
+        else {
+            const message = error instanceof Error ? error.message : 'Error desconocido';
+            logger_1.logger.error(message);
+        }
+        process.exit(1);
+    }
+});
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.substring(0, max - 3) + '...';
+}

package/dist/commands/workers/remove.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCommand = void 0;
+const commander_1 = require("commander");
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+const readline_1 = __importDefault(require("readline"));
+exports.removeCommand = new commander_1.Command('remove')
+    .description('Elimina un worker del workspace')
+    .argument('<name>', 'Nombre del worker a eliminar')
+    .option('-f, --force', 'Eliminar sin confirmacion', false)
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (name, options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const api = (0, api_1.createApiClient)({
+            apiKey: credentials.apiKey,
+            workspace: credentials.workspace,
+            zone: credentials.zone,
+            dev: options.dev,
+        });
+        // Verificar que el worker existe
+        const spinner = (0, ui_1.createSpinner)(`Buscando worker "${name}"...`);
+        spinner.start();
+        let workerInfo;
+        try {
+            const response = await api.get(`/api/workers/${encodeURIComponent(name)}`);
+            workerInfo = response.data;
+            spinner.stop();
+        }
+        catch (error) {
+            spinner.stop();
+            if (error.response?.status === 404) {
+                logger_1.logger.error(`Worker "${name}" no encontrado`);
+            }
+            else {
+                logger_1.logger.error(error.response?.data?.message || error.message);
+            }
+            process.exit(1);
+        }
+        // Mostrar info del worker
+        logger_1.logger.warning(`\n  Vas a eliminar el siguiente worker:`);
+        logger_1.logger.divider();
+        logger_1.logger.label('Nombre', workerInfo.name);
+        logger_1.logger.label('Tipo', workerInfo.type);
+        logger_1.logger.label('Estado', workerInfo.status);
+        logger_1.logger.label('Ejecuciones', `${workerInfo.executionCount || 0}`);
+        logger_1.logger.divider();
+        // Confirmacion
+        if (!options.force) {
+            const confirmed = await askConfirmation(`Eliminar worker "${name}"? Esta accion no se puede deshacer (y/N): `);
+            if (!confirmed) {
+                logger_1.logger.info('\n  Operacion cancelada');
+                process.exit(0);
+            }
+        }
+        const deleteSpinner = (0, ui_1.createSpinner)(`Eliminando "${name}"...`);
+        deleteSpinner.start();
+        await api.delete(`/api/workers/${encodeURIComponent(name)}`);
+        deleteSpinner.succeed(`Worker "${name}" eliminado`);
+        console.log();
+        if (options.dev) {
+            logger_1.logger.warning('Ambiente: desarrollo');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger_1.logger.error(message);
+        process.exit(1);
+    }
+});
+function askConfirmation(question) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}

package/dist/commands/workers/secret.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretCommand = void 0;
+const commander_1 = require("commander");
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+const readline_1 = __importDefault(require("readline"));
+// ── Comando padre: secret ───────────────────────────────────────────────────
+exports.secretCommand = new commander_1.Command('secret')
+    .description('Gestionar secrets (variables de entorno) de los workers')
+    .addCommand(secretSetCommand())
+    .addCommand(secretListCommand())
+    .addCommand(secretRemoveCommand());
+// ── secret set ──────────────────────────────────────────────────────────────
+function secretSetCommand() {
+    return new commander_1.Command('set')
+        .description('Crear o actualizar un secret')
+        .argument('<key>', 'Nombre del secret (ej: STRIPE_API_KEY)')
+        .argument('<value>', 'Valor del secret')
+        .option('--dev', 'Usar ambiente de desarrollo', false)
+        .action(async (key, value, options) => {
+        try {
+            const credentials = await (0, credentials_1.getStoredCredentials)();
+            const api = (0, api_1.createApiClient)({
+                apiKey: credentials.apiKey,
+                workspace: credentials.workspace,
+                zone: credentials.zone,
+                dev: options.dev,
+            });
+            const spinner = (0, ui_1.createSpinner)(`Guardando secret "${key}"...`);
+            spinner.start();
+            await api.put('/api/workers/secrets', { key, value });
+            spinner.succeed(`Secret "${key}" guardado`);
+            logger_1.logger.dim(`  Disponible en tus workers como plz.env.${key}`);
+            console.log();
+            if (options.dev) {
+                logger_1.logger.warning('Ambiente: desarrollo');
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Error desconocido';
+            logger_1.logger.error(message);
+            process.exit(1);
+        }
+    });
+}
+// ── secret list ─────────────────────────────────────────────────────────────
+function secretListCommand() {
+    return new commander_1.Command('list')
+        .description('Lista todos los secrets del workspace (sin mostrar valores)')
+        .option('--dev', 'Usar ambiente de desarrollo', false)
+        .action(async (options) => {
+        try {
+            const credentials = await (0, credentials_1.getStoredCredentials)();
+            const api = (0, api_1.createApiClient)({
+                apiKey: credentials.apiKey,
+                workspace: credentials.workspace,
+                zone: credentials.zone,
+                dev: options.dev,
+            });
+            const spinner = (0, ui_1.createSpinner)('Obteniendo secrets...');
+            spinner.start();
+            const response = await api.get('/api/workers/secrets');
+            const secrets = response.data;
+            spinner.stop();
+            if (!secrets || secrets.length === 0) {
+                logger_1.logger.info('\n  No hay secrets configurados');
+                logger_1.logger.dim('  Agrega uno: plazbot workers secret set MI_KEY mi_valor');
+                console.log();
+                return;
+            }
+            logger_1.logger.title(`Secrets (${secrets.length})`);
+            const rows = secrets.map(s => [
+                s.key,
+                ui_1.theme.muted('••••••••'),
+                (0, ui_1.formatDate)(s.updatedAt),
+            ]);
+            console.log((0, ui_1.createTable)(['Key', 'Valor', 'Actualizado'], rows));
+            console.log();
+            if (options.dev) {
+                logger_1.logger.warning('Ambiente: desarrollo');
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Error desconocido';
+            logger_1.logger.error(message);
+            process.exit(1);
+        }
+    });
+}
+// ── secret remove ───────────────────────────────────────────────────────────
+function secretRemoveCommand() {
+    return new commander_1.Command('remove')
+        .description('Elimina un secret del workspace')
+        .argument('<key>', 'Nombre del secret a eliminar')
+        .option('-f, --force', 'Eliminar sin confirmacion', false)
+        .option('--dev', 'Usar ambiente de desarrollo', false)
+        .action(async (key, options) => {
+        try {
+            const credentials = await (0, credentials_1.getStoredCredentials)();
+            const api = (0, api_1.createApiClient)({
+                apiKey: credentials.apiKey,
+                workspace: credentials.workspace,
+                zone: credentials.zone,
+                dev: options.dev,
+            });
+            if (!options.force) {
+                const confirmed = await askConfirmation(`  Eliminar secret "${key}"? (y/N): `);
+                if (!confirmed) {
+                    logger_1.logger.info('\n  Operacion cancelada');
+                    process.exit(0);
+                }
+            }
+            const spinner = (0, ui_1.createSpinner)(`Eliminando secret "${key}"...`);
+            spinner.start();
+            await api.delete(`/api/workers/secrets/${encodeURIComponent(key)}`);
+            spinner.succeed(`Secret "${key}" eliminado`);
+            console.log();
+            if (options.dev) {
+                logger_1.logger.warning('Ambiente: desarrollo');
+            }
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                logger_1.logger.error(`Secret "${key}" no encontrado`);
+            }
+            else {
+                const message = error instanceof Error ? error.message : 'Error desconocido';
+                logger_1.logger.error(message);
+            }
+            process.exit(1);
+        }
+    });
+}
+function askConfirmation(question) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}

package/dist/commands/workers/test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCommand = void 0;
+const commander_1 = require("commander");
+const credentials_1 = require("../../utils/credentials");
+const api_1 = require("../../utils/api");
+const logger_1 = require("../../utils/logger");
+const ui_1 = require("../../utils/ui");
+exports.testCommand = new commander_1.Command('test')
+    .description('Ejecutar un worker manualmente para probarlo')
+    .argument('<name>', 'Nombre del worker a ejecutar')
+    .option('-p, --payload <json>', 'Payload JSON para el worker (ej: \'{"producto":"iPhone"}\')')
+    .option('-t, --type <type>', 'Tipo del worker (tool, worker, sync, schedule, webhook)')
+    .option('--contact <id>', 'ID del contacto (contexto para tools)')
+    .option('--agent <id>', 'ID del agente (contexto para tools)')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (name, options) => {
+    try {
+        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const api = (0, api_1.createApiClient)({
+            apiKey: credentials.apiKey,
+            workspace: credentials.workspace,
+            zone: credentials.zone,
+            dev: options.dev,
+        });
+        // Parsear payload
+        let payload = {};
+        if (options.payload) {
+            try {
+                payload = JSON.parse(options.payload);
+            }
+            catch {
+                logger_1.logger.error('El payload no es JSON valido');
+                logger_1.logger.dim('Ejemplo: --payload \'{"producto":"iPhone 15"}\'');
+                process.exit(1);
+            }
+        }
+        logger_1.logger.title(`Ejecutando worker "${name}"`);
+        console.log();
+        if (Object.keys(payload).length > 0) {
+            logger_1.logger.label('Payload', JSON.stringify(payload, null, 2));
+            console.log();
+        }
+        const spinner = (0, ui_1.createSpinner)('Ejecutando...');
+        spinner.start();
+        const response = await api.post('/api/worker/execute', {
+            workerName: name,
+            type: options.type,
+            payload,
+            triggerSource: 'cli-test',
+            agentId: options.agent,
+            contactId: options.contact,
+        });
+        const data = response.data;
+        const duration = data.duration ?? 0;
+        spinner.stop();
+        if (data.success) {
+            logger_1.logger.success(`Ejecutado en ${duration}ms`);
+        }
+        else {
+            logger_1.logger.error(`Fallo en ${duration}ms`);
+        }
+        console.log();
+        // Mostrar resultado
+        if (data.result !== undefined && data.result !== null) {
+            logger_1.logger.label('Resultado', '');
+            const result = data.result;
+            // Si es un ToolResponse, mostrar formateado
+            if (typeof result === 'object' && 'result' in result) {
+                console.log();
+                logger_1.logger.label('  result', ui_1.theme.success(String(result.result)));
+                if (result.data) {
+                    logger_1.logger.label('  data', JSON.stringify(result.data, null, 2));
+                }
+                if (Array.isArray(result.actions) && result.actions.length > 0) {
+                    logger_1.logger.label('  actions', '');
+                    for (const action of result.actions) {
+                        const a = action;
+                        logger_1.logger.dim(`    - ${a.type}: ${a.value}${a.code ? ` (${a.code})` : ''}`);
+                    }
+                }
+            }
+            else {
+                // Resultado generico
+                console.log(JSON.stringify(result, null, 2));
+            }
+        }
+        // Mostrar error si hubo
+        if (data.error) {
+            console.log();
+            logger_1.logger.label('Error', ui_1.theme.error(data.error));
+        }
+        console.log();
+        if (options.dev) {
+            logger_1.logger.warning('Ambiente: desarrollo');
+        }
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            logger_1.logger.error(`Worker "${name}" no encontrado o inactivo`);
+            logger_1.logger.dim('Verifica que el worker este desplegado con: plazbot workers list');
+        }
+        else {
+            const message = error.response?.data?.message || error.message || 'Error desconocido';
+            logger_1.logger.error(message);
+        }
+        process.exit(1);
+    }
+});

package/dist/types/workers.js

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