plazbot-cli 0.2.20 → 0.2.21

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.20",
+  "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/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);

package/src/commands/workers/list.ts

@@ -0,0 +1,93 @@
+import { Command } from 'commander';
+import { getStoredCredentials } from '../../utils/credentials';
+import { createApiClient } from '../../utils/api';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme, statusBadge, formatDate } from '../../utils/ui';
+import { WorkerListOptions, WorkerListItem } from '../../types/workers';
+
+export const listCommand = new 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: WorkerListOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const api = createApiClient({
+        apiKey: credentials.apiKey,
+        workspace: credentials.workspace,
+        zone: credentials.zone,
+        dev: options.dev,
+      });
+
+      const spinner = createSpinner('Obteniendo workers...');
+      spinner.start();
+
+      const params: Record<string, string> = {};
+      if (options.type) params.type = options.type;
+      if (options.status) params.status = options.status;
+
+      const response = await api.get('/api/workers', { params });
+      const workers: WorkerListItem[] = response.data;
+
+      spinner.stop();
+
+      if (!workers || workers.length === 0) {
+        logger.info('\n  No se encontraron workers en este workspace');
+        logger.dim('  Despliega tu primer worker: plazbot workers deploy ./workers/mi-tool.ts');
+        console.log();
+        return;
+      }
+
+      logger.title(`Workers (${workers.length})`);
+
+      const rows = workers.map(w => [
+        w.name,
+        typeLabel(w.type),
+        w.status === 'active' ? theme.success('activo')
+          : w.status === 'error' ? theme.error('error')
+          : theme.muted('inactivo'),
+        `${w.executionCount}`,
+        w.errorCount > 0 ? theme.error(`${w.errorCount}`) : theme.muted('0'),
+        w.avgDurationMs > 0 ? `${w.avgDurationMs}ms` : '—',
+        w.lastExecutedAt ? formatDate(w.lastExecutedAt) : '—',
+      ]);
+
+      console.log(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.warning('Workers con error:');
+        errored.forEach(w => {
+          logger.dim(`  ${w.name}: ${w.lastError || 'sin detalles'}`);
+        });
+      }
+
+      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);
+    }
+  });
+
+function typeLabel(type: string): string {
+  const labels: Record<string, string> = {
+    tool: theme.secondary('tool'),
+    worker: theme.primary('worker'),
+    sync: theme.accent('sync'),
+    schedule: theme.muted('schedule'),
+    webhook: theme.warning('webhook'),
+  };
+  return labels[type] || type;
+}

package/src/commands/workers/logs.ts

@@ -0,0 +1,89 @@
+import { Command } from 'commander';
+import { getStoredCredentials } from '../../utils/credentials';
+import { createApiClient } from '../../utils/api';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme, formatDate } from '../../utils/ui';
+import { WorkerLogsOptions, WorkerLogItem } from '../../types/workers';
+
+export const logsCommand = new 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: string, options: WorkerLogsOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const api = createApiClient({
+        apiKey: credentials.apiKey,
+        workspace: credentials.workspace,
+        zone: credentials.zone,
+        dev: options.dev,
+      });
+
+      const spinner = createSpinner(`Obteniendo logs de "${name}"...`);
+      spinner.start();
+
+      const params: Record<string, string> = {
+        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: WorkerLogItem[] = response.data;
+
+      spinner.stop();
+
+      if (!logs || logs.length === 0) {
+        logger.info(`\n  No se encontraron logs para "${name}"`);
+        console.log();
+        return;
+      }
+
+      logger.title(`Logs de "${name}" (${logs.length})`);
+
+      const rows = logs.map(log => [
+        formatDate(log.createdAt),
+        log.status === 'success' ? theme.success('ok')
+          : log.status === 'error' ? theme.error('error')
+          : theme.warning('timeout'),
+        `${log.durationMs}ms`,
+        log.triggerSource || '—',
+        log.error ? theme.error(truncate(log.error, 40)) : '—',
+      ]);
+
+      console.log(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.label('Exitosos', theme.success(`${successCount}`));
+      logger.label('Errores', errorCount > 0 ? theme.error(`${errorCount}`) : theme.muted('0'));
+      logger.label('Duracion promedio', `${avgDuration}ms`);
+      console.log();
+
+      if (options.dev) {
+        logger.warning('Ambiente: desarrollo');
+      }
+
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        logger.error(`Worker "${name}" no encontrado`);
+      } else {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger.error(message);
+      }
+      process.exit(1);
+    }
+  });
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.substring(0, max - 3) + '...';
+}

package/src/commands/workers/remove.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import { getStoredCredentials } from '../../utils/credentials';
+import { createApiClient } from '../../utils/api';
+import { logger } from '../../utils/logger';
+import { createSpinner } from '../../utils/ui';
+import { WorkerRemoveOptions } from '../../types/workers';
+import readline from 'readline';
+
+export const removeCommand = new 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: string, options: WorkerRemoveOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const api = createApiClient({
+        apiKey: credentials.apiKey,
+        workspace: credentials.workspace,
+        zone: credentials.zone,
+        dev: options.dev,
+      });
+
+      // Verificar que el worker existe
+      const spinner = createSpinner(`Buscando worker "${name}"...`);
+      spinner.start();
+
+      let workerInfo: any;
+      try {
+        const response = await api.get(`/api/workers/${encodeURIComponent(name)}`);
+        workerInfo = response.data;
+        spinner.stop();
+      } catch (error: any) {
+        spinner.stop();
+        if (error.response?.status === 404) {
+          logger.error(`Worker "${name}" no encontrado`);
+        } else {
+          logger.error(error.response?.data?.message || error.message);
+        }
+        process.exit(1);
+      }
+
+      // Mostrar info del worker
+      logger.warning(`\n  Vas a eliminar el siguiente worker:`);
+      logger.divider();
+      logger.label('Nombre', workerInfo.name);
+      logger.label('Tipo', workerInfo.type);
+      logger.label('Estado', workerInfo.status);
+      logger.label('Ejecuciones', `${workerInfo.executionCount || 0}`);
+      logger.divider();
+
+      // Confirmacion
+      if (!options.force) {
+        const confirmed = await askConfirmation(
+          `Eliminar worker "${name}"? Esta accion no se puede deshacer (y/N): `
+        );
+
+        if (!confirmed) {
+          logger.info('\n  Operacion cancelada');
+          process.exit(0);
+        }
+      }
+
+      const deleteSpinner = createSpinner(`Eliminando "${name}"...`);
+      deleteSpinner.start();
+
+      await api.delete(`/api/workers/${encodeURIComponent(name)}`);
+
+      deleteSpinner.succeed(`Worker "${name}" eliminado`);
+      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);
+    }
+  });
+
+function askConfirmation(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y');
+    });
+  });
+}

package/src/commands/workers/secret.ts

@@ -0,0 +1,179 @@
+import { Command } from 'commander';
+import { getStoredCredentials } from '../../utils/credentials';
+import { createApiClient } from '../../utils/api';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme, formatDate } from '../../utils/ui';
+import { WorkerSecretItem } from '../../types/workers';
+import readline from 'readline';
+
+// ── Comando padre: secret ───────────────────────────────────────────────────
+
+export const secretCommand = new Command('secret')
+  .description('Gestionar secrets (variables de entorno) de los workers')
+  .addCommand(secretSetCommand())
+  .addCommand(secretListCommand())
+  .addCommand(secretRemoveCommand());
+
+// ── secret set ──────────────────────────────────────────────────────────────
+
+function secretSetCommand(): Command {
+  return new 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: string, value: string, options: { dev?: boolean }) => {
+      try {
+        const credentials = await getStoredCredentials();
+        const api = createApiClient({
+          apiKey: credentials.apiKey,
+          workspace: credentials.workspace,
+          zone: credentials.zone,
+          dev: options.dev,
+        });
+
+        const spinner = createSpinner(`Guardando secret "${key}"...`);
+        spinner.start();
+
+        await api.put('/api/workers/secrets', { key, value });
+
+        spinner.succeed(`Secret "${key}" guardado`);
+        logger.dim(`  Disponible en tus workers como plz.env.${key}`);
+        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);
+      }
+    });
+}
+
+// ── secret list ─────────────────────────────────────────────────────────────
+
+function secretListCommand(): Command {
+  return new Command('list')
+    .description('Lista todos los secrets del workspace (sin mostrar valores)')
+    .option('--dev', 'Usar ambiente de desarrollo', false)
+    .action(async (options: { dev?: boolean }) => {
+      try {
+        const credentials = await getStoredCredentials();
+        const api = createApiClient({
+          apiKey: credentials.apiKey,
+          workspace: credentials.workspace,
+          zone: credentials.zone,
+          dev: options.dev,
+        });
+
+        const spinner = createSpinner('Obteniendo secrets...');
+        spinner.start();
+
+        const response = await api.get('/api/workers/secrets');
+        const secrets: WorkerSecretItem[] = response.data;
+
+        spinner.stop();
+
+        if (!secrets || secrets.length === 0) {
+          logger.info('\n  No hay secrets configurados');
+          logger.dim('  Agrega uno: plazbot workers secret set MI_KEY mi_valor');
+          console.log();
+          return;
+        }
+
+        logger.title(`Secrets (${secrets.length})`);
+
+        const rows = secrets.map(s => [
+          s.key,
+          theme.muted('••••••••'),
+          formatDate(s.updatedAt),
+        ]);
+
+        console.log(createTable(
+          ['Key', 'Valor', 'Actualizado'],
+          rows,
+        ));
+
+        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);
+      }
+    });
+}
+
+// ── secret remove ───────────────────────────────────────────────────────────
+
+function secretRemoveCommand(): Command {
+  return new 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: string, options: { dev?: boolean; force?: boolean }) => {
+      try {
+        const credentials = await getStoredCredentials();
+        const api = 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.info('\n  Operacion cancelada');
+            process.exit(0);
+          }
+        }
+
+        const spinner = 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.warning('Ambiente: desarrollo');
+        }
+
+      } catch (error: any) {
+        if (error.response?.status === 404) {
+          logger.error(`Secret "${key}" no encontrado`);
+        } else {
+          const message = error instanceof Error ? error.message : 'Error desconocido';
+          logger.error(message);
+        }
+        process.exit(1);
+      }
+    });
+}
+
+function askConfirmation(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y');
+    });
+  });
+}