plazbot-cli 0.2.19 → 0.2.21

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 });

package/dist/utils/api.js

@@ -0,0 +1,25 @@
+"use strict";
+// Utilidades para llamadas directas al API de Plazbot
+// Usado por comandos que no tienen clase SDK (ej: workers)
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiClient = createApiClient;
+const axios_1 = __importDefault(require("axios"));
+function getBaseUrl(zone, dev) {
+    if (dev)
+        return 'http://localhost:5090';
+    return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
+}
+function createApiClient(options) {
+    const baseURL = getBaseUrl(options.zone, options.dev);
+    return axios_1.default.create({
+        baseURL,
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': options.apiKey,
+            'x-workspace-id': options.workspace,
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plazbot-cli",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "CLI para Plazbot SDK",
   "main": "dist/cli.js",
   "bin": {
@@ -44,7 +44,7 @@
     "marked": "^12.0.2",
     "marked-terminal": "^7.2.1",
     "ora": "^5.4.1",
-    "plazbot": "^2.0.0"
+    "plazbot": "^2.1.4"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/cli.ts

@@ -4,6 +4,7 @@ import { portalCommands } from './commands/portal';
 import { authCommands } from './commands/auth';
 import { agentCommands } from './commands/agent';
 import { whatsappCommands } from './commands/whatsapp';
+import { workersCommands } from './commands/workers';
 import { showBanner } from './utils/banner';
 
 // Configuracion basica del CLI
@@ -24,6 +25,9 @@ program.addCommand(portalCommands);
 // Registrar todos los comandos de WhatsApp
 program.addCommand(whatsappCommands);
 
+// Registrar todos los comandos de Workers
+program.addCommand(workersCommands);
+
 // Si no se pasan argumentos, mostrar banner
 if (process.argv.length <= 2) {
   showBanner().then(() => {

package/src/commands/agent/templates.ts

@@ -5,6 +5,7 @@ import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
 import { theme, section, kvPair, createTable, createSpinner } from '../../utils/ui';
 import { AgentCommandOptions } from '../../types/agent';
+import { connectChannelFlow, WizardContext } from './wizard';
 
 interface TemplatePlaceholder {
   key: string;
@@ -727,24 +728,25 @@ export const templatesCommand = new Command('templates')
         placeholderAnswers[ph.key] = value.trim();
       }
 
-      // Paso 3: WhatsApp
-      console.log(theme.bold('\n  Canal WhatsApp'));
-      const { deployWhatsApp } = await (inquirer as any).prompt([{
+      // Paso 3: Canales (WhatsApp, Messenger, Instagram, Telegram)
+      console.log(theme.bold('\n  Conexion de canales'));
+      const { wantChannels } = await (inquirer as any).prompt([{
         type: 'confirm',
-        name: 'deployWhatsApp',
-        message: 'Deseas desplegarlo en WhatsApp?',
+        name: 'wantChannels',
+        message: 'Deseas conectar canales (WhatsApp, Messenger, Instagram, Telegram)?',
         default: true,
       }]);
 
-      let whatsappNumber = '';
-      if (deployWhatsApp) {
-        const { number } = await (inquirer as any).prompt([{
-          type: 'input',
-          name: 'number',
-          message: 'Numero de WhatsApp (con codigo de pais, ej: +51999888777):',
-          validate: (v: string) => v.trim().length > 0 || 'El numero es requerido',
-        }]);
-        whatsappNumber = number.trim();
+      const credentials = await getStoredCredentials();
+      let connectedChannels: { channel: string; key: string; multianswer: boolean }[] = [];
+      if (wantChannels) {
+        const wizardCtx: WizardContext = {
+          zone: credentials.zone,
+          workspaceId: credentials.workspace,
+          apiKey: credentials.apiKey,
+          dev: !!options.dev,
+        };
+        connectedChannels = await connectChannelFlow(wizardCtx);
       }
 
       // Paso 4: API Key de OpenAI
@@ -782,8 +784,8 @@ export const templatesCommand = new Command('templates')
 
       finalConfig.timezone = timezone;
 
-      if (deployWhatsApp && whatsappNumber) {
-        finalConfig.channels = [{ channel: 'whatsapp', key: whatsappNumber }];
+      if (connectedChannels.length > 0) {
+        finalConfig.channels = connectedChannels;
       } else {
         finalConfig.channels = [];
       }
@@ -805,7 +807,7 @@ export const templatesCommand = new Command('templates')
       for (const ph of template.placeholders) {
         console.log(kvPair(ph.label, placeholderAnswers[ph.key]));
       }
-      console.log(kvPair('WhatsApp', deployWhatsApp ? whatsappNumber : 'No configurado'));
+      console.log(kvPair('Canales', connectedChannels.length > 0 ? connectedChannels.map(c => `${c.channel} (${c.key})`).join(', ') : 'No configurado'));
       console.log(kvPair('API Key OpenAI', apiToken ? 'Configurada' : 'No configurada (el agente no funcionara sin ella)'));
       console.log(kvPair('Zona horaria', timezone));
       console.log(kvPair('Acciones', String(finalConfig.actions.length)));
@@ -825,8 +827,6 @@ export const templatesCommand = new Command('templates')
       }
 
       // Paso 7: Crear agente
-      const credentials = await getStoredCredentials();
-
       const agent = new Agent({
         workspaceId: credentials.workspace,
         apiKey: credentials.apiKey,
@@ -849,17 +849,20 @@ export const templatesCommand = new Command('templates')
       }
       logger.label('Nombre', finalConfig.name);
       logger.label('Industria', template.industry);
-      if (deployWhatsApp) {
-        logger.label('WhatsApp', whatsappNumber);
+      if (connectedChannels.length > 0) {
+        logger.label('Canales', connectedChannels.map(c => `${c.channel} (${c.key})`).join(', '));
       }
       logger.label('Acciones', String(finalConfig.actions.length));
 
       console.log();
       console.log(section('Siguientes pasos'));
-      console.log(theme.bold('  1.') + ' Crea tu cuenta en ' + theme.success('appla.plazbot.com/register'));
-      console.log(theme.bold('  2.') + ' Ve a Agentes en el menu e importa el archivo');
-      console.log(theme.bold('  3.') + ' Conecta WhatsApp en Ajustes > Integraciones');
-      console.log(theme.bold('  4.') + ' Agrega tu API Key de OpenAI en Modelos de IA');
+      if (connectedChannels.length === 0) {
+        console.log(theme.bold('  1.') + ' Conecta canales desde: ' + theme.success('plazbot agent chat -a <agentId>'));
+        console.log(theme.bold('  2.') + ' O conecta desde la plataforma en Ajustes > Integraciones');
+      } else {
+        console.log(theme.bold('  1.') + ' Tu agente ya tiene canales conectados y activados');
+      }
+      console.log(theme.bold(`  ${connectedChannels.length === 0 ? '3' : '2'}.`) + ' Agrega tu API Key de OpenAI si no la configuraste');
       console.log();
 
       if (!apiToken) {

package/src/commands/agent/wizard.ts

@@ -96,7 +96,7 @@ const MODELS: Record<string, string[]> = {
 
 const COLORS = ['blue', 'green', 'orange', 'gray', 'white'];
 
-interface WizardContext {
+export interface WizardContext {
   zone: string;
   workspaceId: string;
   apiKey: string;
@@ -160,7 +160,7 @@ async function activateIntegration(baseUrl: string, workspaceId: string, integra
   }
 }
 
-async function connectChannelFlow(ctx: WizardContext): Promise<AgentChannel[]> {
+export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChannel[]> {
   const channels: AgentChannel[] = [];
   const baseUrl = getBaseUrl(ctx.zone, ctx.dev);
   const headers = {

package/src/commands/workers/deploy.ts

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import path from 'path';
+import { getStoredCredentials } from '../../utils/credentials';
+import { createApiClient } from '../../utils/api';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme } from '../../utils/ui';
+import { WorkerDeployOptions, WorkerDeployResult } from '../../types/workers';
+
+export const deployCommand = new 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: string | undefined, options: WorkerDeployOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+
+      // Buscar archivos de workers
+      const files = await resolveWorkerFiles(file);
+
+      if (files.length === 0) {
+        logger.error('No se encontraron archivos de workers para desplegar');
+        logger.dim('Uso: plazbot workers deploy ./workers/mi-tool.ts');
+        logger.dim('  o: plazbot workers deploy (busca en ./workers/ automaticamente)');
+        process.exit(1);
+      }
+
+      const api = createApiClient({
+        apiKey: credentials.apiKey,
+        workspace: credentials.workspace,
+        zone: credentials.zone,
+        dev: options.dev,
+      });
+
+      logger.title(`Desplegando ${files.length} worker${files.length > 1 ? 's' : ''}`);
+      console.log();
+
+      const results: { file: string; result?: WorkerDeployResult; error?: string }[] = [];
+
+      for (const filePath of files) {
+        const fileName = path.basename(filePath);
+        const spinner = createSpinner(`Desplegando ${fileName}...`);
+        spinner.start();
+
+        try {
+          // Leer archivo fuente
+          const sourceCode = await fs.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 as WorkerDeployResult;
+          spinner.succeed(`${fileName} → ${data.name} (${data.type})`);
+          results.push({ file: fileName, result: data });
+
+        } catch (error: any) {
+          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.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(createTable(
+          ['Nombre', 'Tipo', 'Estado', 'URL/Cron'],
+          rows,
+        ));
+      }
+
+      if (failed.length > 0) {
+        logger.warning(`${failed.length} worker${failed.length > 1 ? 's' : ''} fallaron`);
+        failed.forEach(f => 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.title('Webhook URLs');
+        webhooks.forEach(w => {
+          logger.label(w.result!.name, theme.secondary(w.result!.webhookUrl!));
+        });
+      }
+
+      console.log();
+
+      if (options.dev) {
+        logger.warning('Ambiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Resuelve los archivos a desplegar
+async function resolveWorkerFiles(file?: string): Promise<string[]> {
+  if (file) {
+    // Archivo especifico
+    const resolved = path.resolve(file);
+    try {
+      await fs.access(resolved);
+      return [resolved];
+    } catch {
+      throw new Error(`Archivo no encontrado: ${file}`);
+    }
+  }
+
+  // Buscar en ./workers/ automaticamente
+  const workersDir = path.resolve('workers');
+  try {
+    const entries = await fs.readdir(workersDir);
+    const tsFiles = entries
+      .filter(e => e.endsWith('.ts') && !e.endsWith('.d.ts'))
+      .map(e => path.join(workersDir, e));
+
+    return tsFiles;
+  } catch {
+    return [];
+  }
+}

package/src/commands/workers/index.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import { deployCommand } from './deploy';
+import { listCommand } from './list';
+import { logsCommand } from './logs';
+import { removeCommand } from './remove';
+import { secretCommand } from './secret';
+import { testCommand } from './test';
+
+export const workersCommands = new Command('workers')
+  .description('Comandos para gestionar workers (tools, syncs, schedules, webhooks)')
+  .addCommand(deployCommand)
+  .addCommand(listCommand)
+  .addCommand(logsCommand)
+  .addCommand(removeCommand)
+  .addCommand(secretCommand)
+  .addCommand(testCommand);