plazbot-cli 0.2.3 → 0.2.5

package/src/commands/agent/monitor.ts

@@ -0,0 +1,352 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { theme } from '../../utils/ui';
+import chalk from 'chalk';
+import readline from 'readline';
+import { HubConnectionBuilder, HttpTransportType, HubConnectionState } from '@microsoft/signalr';
+
+// Colores por tipo de evento (mismos del MonitorTab frontend)
+const EVENT_COLORS: Record<string, { color: string; label: string }> = {
+  msg_in:        { color: '#22d3ee', label: 'msg_in' },
+  msg_out:       { color: '#4ade80', label: 'msg_out' },
+  tool_call:     { color: '#c084fc', label: 'tool_call' },
+  api_req:       { color: '#fbbf24', label: 'api_req' },
+  api_res:       { color: '#fbbf24', label: 'api_res' },
+  action:        { color: '#f97316', label: 'action' },
+  rag:           { color: '#60a5fa', label: 'rag' },
+  tokens:        { color: '#94a3b8', label: 'tokens' },
+  error:         { color: '#ef4444', label: 'error' },
+  model:         { color: '#a78bfa', label: 'model' },
+  intent:        { color: '#a78bfa', label: 'intent' },
+  bot_off:       { color: '#f97316', label: 'bot_off' },
+  session_field: { color: '#a78bfa', label: 'session_field' },
+};
+
+const DEFAULT_EVENT_COLOR = { color: '#94a3b8', label: 'unknown' };
+
+interface AgentLogEvent {
+  timestamp: string;
+  workspace_id: string;
+  agent_id: string;
+  contact_id: string;
+  contact_name: string;
+  session_id: string;
+  event_type: string;
+  event_title: string;
+  event_data: string;
+  duration_ms: number;
+  level: string;
+}
+
+function getBaseUrl(zone: string, dev: boolean): string {
+  if (dev) return 'http://localhost:5090';
+  return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
+}
+
+function formatTimestamp(ts: string): string {
+  try {
+    const d = new Date(ts);
+    return d.toLocaleTimeString('es-ES', { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  } catch {
+    return ts.substring(11, 19);
+  }
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (!text) return '';
+  return text.length > maxLen ? text.substring(0, maxLen - 3) + '...' : text;
+}
+
+function shortSession(sessionId: string): string {
+  if (!sessionId) return '';
+  return sessionId.substring(0, 6);
+}
+
+function renderLogLine(
+  log: AgentLogEvent,
+  opts: { showSession: boolean; jsonMode: boolean },
+  lastSessionId: string
+): string {
+  // Modo JSON crudo
+  if (opts.jsonMode) {
+    return JSON.stringify(log);
+  }
+
+  const config = EVENT_COLORS[log.event_type] || DEFAULT_EVENT_COLOR;
+  const colorFn = chalk.hex(config.color);
+  const grayFn = chalk.hex('#71717a');
+  const dimFn = chalk.hex('#52525b');
+
+  let lines: string[] = [];
+
+  // Separador de sesion
+  if (lastSessionId && log.session_id && log.session_id !== lastSessionId) {
+    lines.push(dimFn('  ' + '─'.repeat(16) + ' nueva sesion ' + '─'.repeat(16)));
+  }
+
+  // Linea principal
+  const timestamp = grayFn(formatTimestamp(log.timestamp));
+  const dot = colorFn('●');
+  const eventType = colorFn(config.label.padEnd(14));
+  const title = chalk.white(truncate(log.event_title, 80));
+  const duration = log.duration_ms > 0 ? dimFn(` ${log.duration_ms}ms`) : '';
+  const session = opts.showSession && log.session_id
+    ? dimFn(` [${shortSession(log.session_id)}]`)
+    : '';
+
+  lines.push(`  ${timestamp}  ${dot} ${eventType} ${title}${duration}${session}`);
+
+  // Linea de contacto para mensajes
+  if (log.contact_name && (log.event_type === 'msg_in' || log.event_type === 'msg_out')) {
+    lines.push(dimFn('                     | contacto: ') + dimFn(log.contact_name));
+  }
+
+  return lines.join('\n');
+}
+
+function printHeader(agentName: string) {
+  console.log();
+  console.log(chalk.hex('#4CAF50')('  ┌' + '─'.repeat(62) + '┐'));
+  console.log(
+    chalk.hex('#4CAF50')('  │') +
+    chalk.bold(`  Monitor`) +
+    chalk.hex('#4ade80')('  ● En vivo') +
+    ' '.repeat(38) +
+    chalk.hex('#4CAF50')('│')
+  );
+  console.log(
+    chalk.hex('#4CAF50')('  │') +
+    chalk.gray(`  Agente: ${truncate(agentName, 44)}`) +
+    ' '.repeat(Math.max(0, 49 - agentName.length)) +
+    chalk.hex('#4CAF50')('│')
+  );
+  console.log(
+    chalk.hex('#4CAF50')('  │') +
+    chalk.gray('  Ctrl+C salir | /filter <tipo> | /clear | /help') +
+    ' '.repeat(12) +
+    chalk.hex('#4CAF50')('│')
+  );
+  console.log(chalk.hex('#4CAF50')('  └' + '─'.repeat(62) + '┘'));
+  console.log();
+}
+
+const COMMANDS_HELP = `
+  ${chalk.bold('Comandos disponibles:')}
+  ${chalk.hex('#4CAF50')('/filter <tipo>')}   Toggle filtro por tipo (ej: msg_in, error, tool_call)
+  ${chalk.hex('#4CAF50')('/filter clear')}    Quitar todos los filtros
+  ${chalk.hex('#4CAF50')('/filters')}         Mostrar filtros activos
+  ${chalk.hex('#4CAF50')('/clear')}           Limpiar pantalla
+  ${chalk.hex('#4CAF50')('/json')}            Toggle modo JSON expandido
+  ${chalk.hex('#4CAF50')('/help')}            Mostrar estos comandos
+
+  ${chalk.bold('Tipos de evento:')}
+  ${Object.entries(EVENT_COLORS).map(([key, val]) =>
+    `  ${chalk.hex(val.color)('●')} ${key}`
+  ).join('\n')}
+`;
+
+export const monitorCommand = new Command('monitor')
+  .description('Monitor en tiempo real de un agente (logs via SignalR)')
+  .requiredOption('-a, --agent-id <id>', 'ID del agente')
+  .option('-f, --filter <types>', 'Filtrar por tipos separados por coma (ej: msg_in,msg_out)')
+  .option('--no-session', 'Ocultar session ID')
+  .option('--json', 'Modo JSON crudo (para piping)', false)
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: {
+    agentId: string;
+    filter?: string;
+    session: boolean;
+    json: boolean;
+    dev: boolean;
+  }) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const baseUrl = getBaseUrl(credentials.zone, options.dev);
+
+      // Filtros iniciales
+      const activeFilters: Set<string> = new Set(
+        options.filter ? options.filter.split(',').map(f => f.trim()) : []
+      );
+      let jsonMode = options.json;
+      let lastSessionId = '';
+
+      // Cargar info del agente
+      let agentName = 'Agente';
+      try {
+        process.stdout.write(chalk.gray('  Conectando con agente...'));
+        const agent = new Agent({
+          workspaceId: credentials.workspace,
+          apiKey: credentials.apiKey,
+          zone: credentials.zone,
+          ...(options.dev && { customUrl: 'http://localhost:5090' }),
+        });
+        const info: any = await agent.getAgentById({ id: options.agentId });
+        if (info?.name) agentName = info.name;
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      } catch {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      }
+
+      // Dibujar header
+      if (!jsonMode) {
+        console.clear();
+        printHeader(agentName);
+      }
+
+      // Conectar a SignalR
+      const hubUrl = `${baseUrl}/agentMonitorHub`;
+      const connection = new HubConnectionBuilder()
+        .withUrl(hubUrl, {
+          skipNegotiation: true,
+          transport: HttpTransportType.WebSockets,
+        })
+        .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
+        .build();
+
+      // Evento de log
+      connection.on('agent_log', (log: AgentLogEvent) => {
+        // Aplicar filtros
+        if (activeFilters.size > 0 && !activeFilters.has(log.event_type)) return;
+
+        const line = renderLogLine(log, {
+          showSession: options.session,
+          jsonMode,
+        }, lastSessionId);
+
+        console.log(line);
+        lastSessionId = log.session_id || lastSessionId;
+      });
+
+      // Eventos de conexion
+      connection.onreconnecting(() => {
+        if (!jsonMode) {
+          console.log(chalk.hex('#FFA726')('  ⟳ Reconectando...'));
+        }
+      });
+
+      connection.onreconnected(() => {
+        if (!jsonMode) {
+          console.log(chalk.hex('#4ade80')('  ● Reconectado'));
+        }
+        connection.invoke('JoinAgentMonitor', options.agentId).catch(() => {});
+      });
+
+      connection.onclose(() => {
+        if (!jsonMode) {
+          console.log(chalk.hex('#ef4444')('  ● Desconectado'));
+        }
+      });
+
+      // Iniciar conexion
+      try {
+        await connection.start();
+        await connection.invoke('JoinAgentMonitor', options.agentId);
+        if (!jsonMode) {
+          console.log(chalk.hex('#4ade80')('  ● Conectado al monitor en tiempo real'));
+          console.log();
+        }
+      } catch (err) {
+        logger.error(`No se pudo conectar al monitor: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+
+      // readline para comandos interactivos
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: '',
+      });
+
+      // No mostrar prompt para no interferir con el stream
+      rl.on('line', (input: string) => {
+        const cmd = input.trim().toLowerCase();
+
+        if (cmd === '/help') {
+          console.log(COMMANDS_HELP);
+          return;
+        }
+
+        if (cmd === '/clear') {
+          console.clear();
+          printHeader(agentName);
+          return;
+        }
+
+        if (cmd === '/json') {
+          jsonMode = !jsonMode;
+          console.log(chalk.gray(`  Modo JSON: ${jsonMode ? 'activado' : 'desactivado'}`));
+          return;
+        }
+
+        if (cmd === '/filters') {
+          if (activeFilters.size === 0) {
+            console.log(chalk.gray('  Sin filtros activos (mostrando todos)'));
+          } else {
+            console.log(chalk.gray('  Filtros activos: ') + chalk.white([...activeFilters].join(', ')));
+          }
+          return;
+        }
+
+        if (cmd.startsWith('/filter ')) {
+          const filterType = cmd.substring(8).trim();
+          if (!filterType) {
+            console.log(chalk.gray('  Uso: /filter <tipo> | /filter clear'));
+            return;
+          }
+          if (filterType === 'clear') {
+            activeFilters.clear();
+            console.log(chalk.gray('  Todos los filtros removidos (mostrando todos)'));
+            return;
+          }
+          if (activeFilters.has(filterType)) {
+            activeFilters.delete(filterType);
+            console.log(chalk.gray(`  Filtro removido: ${filterType}`));
+          } else {
+            activeFilters.add(filterType);
+            const config = EVENT_COLORS[filterType];
+            if (config) {
+              console.log(chalk.hex(config.color)(`  ● Filtro agregado: ${filterType}`));
+            } else {
+              console.log(chalk.gray(`  Filtro agregado: ${filterType} (tipo desconocido)`));
+            }
+          }
+          if (activeFilters.size > 0) {
+            console.log(chalk.gray('  Activos: ') + chalk.white([...activeFilters].join(', ')));
+          } else {
+            console.log(chalk.gray('  Sin filtros (mostrando todos)'));
+          }
+          return;
+        }
+      });
+
+      // Cierre limpio
+      const cleanup = async () => {
+        if (!jsonMode) {
+          console.log(chalk.gray('\n  Cerrando monitor...'));
+        }
+        try {
+          if (connection.state === HubConnectionState.Connected) {
+            await connection.invoke('LeaveAgentMonitor', options.agentId);
+          }
+          await connection.stop();
+        } catch {
+          // Ignorar errores al cerrar
+        }
+        rl.close();
+        if (!jsonMode) {
+          console.log(chalk.gray('  Monitor cerrado.\n'));
+        }
+        process.exit(0);
+      };
+
+      process.on('SIGINT', cleanup);
+      process.on('SIGTERM', cleanup);
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });

package/src/commands/agent/wizard.ts

@@ -1,5 +1,7 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import axios from 'axios';
+import ora from 'ora';
 import { theme, section, kvPair } from '../../utils/ui';
 
 interface AgentConfig {
@@ -94,7 +96,187 @@ const MODELS: Record<string, string[]> = {
 
 const COLORS = ['blue', 'green', 'orange', 'gray', 'white'];
 
-export async function runAgentWizard(zone: string): Promise<AgentConfig> {
+interface WizardContext {
+  zone: string;
+  workspaceId: string;
+  apiKey: string;
+  dev: boolean;
+}
+
+function getBaseUrl(zone: string, dev: boolean): string {
+  if (dev) return 'http://localhost:5090';
+  return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
+}
+
+const CHANNEL_CHOICES = [
+  { name: 'WhatsApp', value: 'whatsapp' },
+  { name: 'WhatsApp Business', value: 'whatsapp_business' },
+  { name: 'Instagram', value: 'instagram' },
+  { name: 'Messenger', value: 'facebook' },
+];
+
+const CHANNEL_AGENT_MAP: Record<string, string> = {
+  whatsapp: 'whatsapp',
+  whatsapp_business: 'whatsapp',
+  instagram: 'instagram',
+  facebook: 'facebook',
+};
+
+async function connectChannelFlow(ctx: WizardContext): Promise<AgentChannel[]> {
+  const channels: AgentChannel[] = [];
+  const baseUrl = getBaseUrl(ctx.zone, ctx.dev);
+  const headers = {
+    'Authorization': `Bearer ${ctx.apiKey}`,
+    'x-workspace-id': ctx.workspaceId,
+    'Content-Type': 'application/json',
+  };
+
+  let addMore = true;
+  while (addMore) {
+    const { channelType } = await (inquirer as any).prompt([{
+      type: 'list',
+      name: 'channelType',
+      message: 'Que canal deseas conectar?',
+      choices: CHANNEL_CHOICES,
+    }]);
+
+    const channelLabel = CHANNEL_CHOICES.find(c => c.value === channelType)?.name || channelType;
+
+    // Generar link de onboarding
+    const spinner = ora({ text: chalk.gray('Generando link de conexion...'), spinner: 'dots', color: 'green' }).start();
+
+    try {
+      const linkRes = await axios.post(
+        `${baseUrl}/api/workspace/${ctx.workspaceId}/onboarding-link`,
+        { type: channelType },
+        { headers }
+      );
+
+      if (!linkRes.data?.success) {
+        spinner.fail(chalk.hex('#EF5350')(`Error: ${linkRes.data?.message || 'No se pudo generar el link'}`));
+        const { tryManual } = await (inquirer as any).prompt([{
+          type: 'confirm', name: 'tryManual',
+          message: 'Deseas ingresar el numero manualmente?', default: false,
+        }]);
+        if (tryManual) {
+          const { key } = await (inquirer as any).prompt([
+            { type: 'input', name: 'key', message: `ID/numero del canal ${channelLabel}:`, validate: (v: string) => v.length > 0 || 'Requerido' },
+          ]);
+          channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key, multianswer: false });
+        }
+        const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Conectar otro canal?', default: false }]);
+        addMore = more;
+        continue;
+      }
+
+      const shortUrl = linkRes.data.data?.shortUrl || '';
+      spinner.stop();
+
+      // Mostrar link en box visual
+      console.log();
+      console.log(chalk.hex('#4CAF50')('  ┌' + '─'.repeat(64) + '┐'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.bold(`  Envia este link para conectar ${channelLabel}:`).padEnd(74) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + '  '.padEnd(64) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.hex('#22d3ee')(`  ${shortUrl}`).padEnd(74) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + '  '.padEnd(64) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  └' + '─'.repeat(64) + '┘'));
+      console.log();
+
+      // Snapshot de integraciones actuales
+      let prevIntegrationIds: Set<string> = new Set();
+      try {
+        const wkRes = await axios.get(`${baseUrl}/api/workspace/${ctx.workspaceId}`, { headers });
+        const integrations = wkRes.data?.integrations || wkRes.data?.data?.integrations || [];
+        prevIntegrationIds = new Set(integrations.map((i: any) => i.id));
+      } catch {
+        // Si falla, se parte de vacio
+      }
+
+      // Polling para detectar nueva integracion
+      const pollSpinner = ora({ text: chalk.gray('Esperando conexion... (Ctrl+C para cancelar)'), spinner: 'dots', color: 'cyan' }).start();
+      const POLL_INTERVAL = 5000;
+      const MAX_POLLS = 60; // 5 minutos
+      let detected: any = null;
+
+      for (let i = 0; i < MAX_POLLS; i++) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        try {
+          const wkRes = await axios.get(`${baseUrl}/api/workspace/${ctx.workspaceId}`, { headers });
+          const integrations = wkRes.data?.integrations || wkRes.data?.data?.integrations || [];
+
+          // Buscar integraciones nuevas del tipo correcto
+          const targetType = channelType === 'whatsapp_business' ? 'whatsapp' : channelType;
+          const newOnes = integrations.filter((ig: any) =>
+            !prevIntegrationIds.has(ig.id) && ig.type === targetType
+          );
+
+          if (newOnes.length > 0) {
+            detected = newOnes[0];
+            break;
+          }
+        } catch {
+          // Ignorar errores de poll individual
+        }
+        const elapsed = Math.floor(((i + 1) * POLL_INTERVAL) / 1000);
+        pollSpinner.text = chalk.gray(`Esperando conexion... ${elapsed}s`);
+      }
+
+      if (detected) {
+        pollSpinner.succeed(chalk.hex('#4ade80')(`Conexion detectada: ${detected.aliasName || detected.id} (${channelLabel})`));
+
+        const { associate } = await (inquirer as any).prompt([{
+          type: 'confirm', name: 'associate',
+          message: 'Deseas asociar este canal al agente?', default: true,
+        }]);
+
+        if (associate) {
+          channels.push({
+            channel: CHANNEL_AGENT_MAP[channelType],
+            key: detected.id,
+            multianswer: false,
+          });
+          console.log(chalk.hex('#4ade80')('  Canal asociado correctamente.'));
+        }
+      } else {
+        pollSpinner.warn(chalk.hex('#FFA726')('Timeout: no se detecto una conexion.'));
+        const { action } = await (inquirer as any).prompt([{
+          type: 'list', name: 'action',
+          message: 'Que deseas hacer?',
+          choices: [
+            { name: 'Ingresar numero/ID manualmente', value: 'manual' },
+            { name: 'Saltar este paso', value: 'skip' },
+          ],
+        }]);
+        if (action === 'manual') {
+          const { key } = await (inquirer as any).prompt([
+            { type: 'input', name: 'key', message: `ID/numero del canal ${channelLabel}:`, validate: (v: string) => v.length > 0 || 'Requerido' },
+          ]);
+          channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key, multianswer: false });
+        }
+      }
+
+    } catch (err) {
+      spinner.fail(chalk.hex('#EF5350')(`Error al generar link: ${err instanceof Error ? err.message : err}`));
+      const { tryManual } = await (inquirer as any).prompt([{
+        type: 'confirm', name: 'tryManual',
+        message: 'Deseas ingresar el numero manualmente?', default: false,
+      }]);
+      if (tryManual) {
+        const { key } = await (inquirer as any).prompt([
+          { type: 'input', name: 'key', message: `ID/numero del canal ${channelLabel}:`, validate: (v: string) => v.length > 0 || 'Requerido' },
+        ]);
+        channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key, multianswer: false });
+      }
+    }
+
+    const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Conectar otro canal?', default: false }]);
+    addMore = more;
+  }
+
+  return channels;
+}
+
+export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?: string, dev?: boolean): Promise<AgentConfig> {
   console.log(section('Crear nuevo agente de IA'));
   console.log(theme.muted('  Responde las siguientes preguntas para configurar tu agente.\n'));
 
@@ -383,17 +565,20 @@ export async function runAgentWizard(zone: string): Promise<AgentConfig> {
     });
   }
 
-  // Paso 7: Canal WhatsApp
-  console.log(theme.bold('\n  Paso 7/8: Canal WhatsApp'));
-  const channels: AgentChannel[] = [];
-  const { addWhatsApp } = await (inquirer as any).prompt([{
+  // Paso 7: Conectar canal
+  console.log(theme.bold('\n  Paso 7/8: Conectar canal'));
+  let channels: AgentChannel[] = [];
+  const { addChannel } = await (inquirer as any).prompt([{
     type: 'confirm',
-    name: 'addWhatsApp',
-    message: 'Conectar a un numero de WhatsApp?',
+    name: 'addChannel',
+    message: 'Deseas conectar un canal (WhatsApp, Instagram, Messenger)?',
     default: false,
   }]);
 
-  if (addWhatsApp) {
+  if (addChannel && workspaceId && apiKey) {
+    channels = await connectChannelFlow({ zone, workspaceId, apiKey, dev: dev || false });
+  } else if (addChannel) {
+    // Fallback manual si no hay credenciales para API
     const wa = await (inquirer as any).prompt([
       { type: 'input', name: 'key', message: 'Numero de WhatsApp (con codigo de pais):', validate: (v: string) => v.length > 0 || 'Requerido' },
       { type: 'confirm', name: 'multianswer', message: 'Permitir multiples respuestas?', default: false },
@@ -468,7 +653,13 @@ export async function runAgentWizard(zone: string): Promise<AgentConfig> {
   console.log(kvPair('Servicios', String(config.services.length)));
   console.log(kvPair('Acciones', String(config.actions.length)));
   console.log(kvPair('AI Provider', config.customAIConfig ? config.aiProviders[0]?.provider + ' / ' + config.aiProviders[0]?.model : 'Default (Plazbot)'));
-  console.log(kvPair('Canal WhatsApp', config.channels.length > 0 ? config.channels[0].key : 'No configurado'));
+  if (config.channels.length > 0) {
+    config.channels.forEach((ch, i) => {
+      console.log(kvPair(`Canal ${i + 1} (${ch.channel})`, ch.key));
+    });
+  } else {
+    console.log(kvPair('Canales', 'No configurado'));
+  }
   console.log();
 
   return config;