plazbot-cli 0.2.26 → 0.3.2

package/src/commands/agent/wizard.ts

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import axios from 'axios';
 import ora from 'ora';
-import { theme, section, kvPair } from '../../utils/ui';
+import { theme, section, kvPair } from '../../utils/ui.js';
 
 interface AgentConfig {
   name: string;
@@ -174,7 +174,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
     const { channelType } = await (inquirer as any).prompt([{
       type: 'list',
       name: 'channelType',
-      message: 'Que canal deseas conectar?',
+      message: 'Which channel do you want to connect?',
       choices: CHANNEL_CHOICES,
     }]);
 
@@ -182,7 +182,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
     const targetType = channelType === 'whatsapp_business' ? 'whatsapp' : channelType;
 
     // Cargar integraciones existentes del tipo seleccionado
-    const loadSpinner = ora({ text: chalk.gray('Cargando integraciones...'), spinner: 'dots', color: 'green' }).start();
+    const loadSpinner = ora({ text: chalk.gray('Loading integrations...'), spinner: 'dots', color: 'green' }).start();
     const allIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
     const existing = allIntegrations.filter((ig: any) => ig.type === targetType);
     loadSpinner.stop();
@@ -196,12 +196,12 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
         value: ig.id,
       }));
       choices.push(new (inquirer as any).Separator());
-      choices.push({ name: chalk.hex('#4ade80')('+ Agregar uno nuevo (generar link)'), value: '__new__' });
+      choices.push({ name: chalk.hex('#4ade80')('+ Add a new one (generate link)'), value: '__new__' });
 
       const { selected } = await (inquirer as any).prompt([{
         type: 'list',
         name: 'selected',
-        message: `Integraciones de ${channelLabel} disponibles:`,
+        message: `Available ${channelLabel} integrations:`,
         choices,
       }]);
 
@@ -212,12 +212,12 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
 
         // Activar la integracion si no esta activa
         if (!selectedIntegration.isActive) {
-          const actSpinner = ora({ text: chalk.gray('Activando integracion...'), spinner: 'dots', color: 'green' }).start();
+          const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
           const activated = await activateIntegration(baseUrl, ctx.workspaceId, selectedIntegration.id, headers);
           if (activated) {
-            actSpinner.succeed(chalk.hex('#4ade80')('Integracion activada correctamente.'));
+            actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
           } else {
-            actSpinner.warn(chalk.hex('#FFA726')('No se pudo activar la integracion. Puedes activarla manualmente desde la plataforma.'));
+            actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
           }
         }
 
@@ -226,13 +226,13 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
           key: getIntegrationKey(selectedIntegration),
           multianswer: false,
         });
-        console.log(chalk.hex('#4ade80')(`  Canal asociado: ${label}`));
+        console.log(chalk.hex('#4ade80')(`  Channel linked: ${label}`));
       }
     }
 
     // Si no hay existentes o eligio "Agregar nuevo" → generar link de onboarding
     if (!selectedIntegration) {
-      const spinner = ora({ text: chalk.gray('Generando link de conexion...'), spinner: 'dots', color: 'green' }).start();
+      const spinner = ora({ text: chalk.gray('Generating connection link...'), spinner: 'dots', color: 'green' }).start();
 
       try {
         const linkRes = await axios.post(
@@ -242,7 +242,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
         );
 
         if (!linkRes.data?.success) {
-          spinner.fail(chalk.hex('#EF5350')(`Error: ${linkRes.data?.message || 'No se pudo generar el link'}`));
+          spinner.fail(chalk.hex('#EF5350')(`Error: ${linkRes.data?.message || 'Could not generate the link'}`));
         } else {
           const shortUrl = linkRes.data.data?.shortUrl || '';
           spinner.stop();
@@ -250,7 +250,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
           // Mostrar link
           console.log();
           console.log(chalk.hex('#4CAF50')('  ─'.repeat(32)));
-          console.log(chalk.bold(`  Envia este link para conectar ${channelLabel}:`));
+          console.log(chalk.bold(`  Send this link to connect ${channelLabel}:`));
           console.log();
           console.log('  ' + chalk.hex('#22d3ee')(shortUrl));
           console.log();
@@ -261,7 +261,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
           const prevIds = new Set(allIntegrations.map((i: any) => i.id));
 
           // Polling para detectar nueva integracion (Enter para saltar)
-          const pollSpinner = ora({ text: chalk.gray('Esperando conexion... (Enter para saltar)'), spinner: 'dots', color: 'cyan' }).start();
+          const pollSpinner = ora({ text: chalk.gray('Waiting for connection... (Enter to skip)'), spinner: 'dots', color: 'cyan' }).start();
           const POLL_INTERVAL = 5000;
           const MAX_POLLS = 60;
           let detected: any = null;
@@ -306,20 +306,20 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
               }
             } catch {}
             const elapsed = Math.floor(((i + 1) * POLL_INTERVAL) / 1000);
-            pollSpinner.text = chalk.gray(`Esperando conexion... ${elapsed}s (Enter para saltar)`);
+            pollSpinner.text = chalk.gray(`Waiting for connection... ${elapsed}s (Enter to skip)`);
           }
 
           if (detected) {
             const detectedName = getIntegrationLabel(detected);
-            pollSpinner.succeed(chalk.hex('#4ade80')(`Conexion detectada: ${detectedName}`));
+            pollSpinner.succeed(chalk.hex('#4ade80')(`Connection detected: ${detectedName}`));
 
             // Activar la integracion detectada
-            const actSpinner = ora({ text: chalk.gray('Activando integracion...'), spinner: 'dots', color: 'green' }).start();
+            const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
             const activated = await activateIntegration(baseUrl, ctx.workspaceId, detected.id, headers);
             if (activated) {
-              actSpinner.succeed(chalk.hex('#4ade80')('Integracion activada correctamente.'));
+              actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
             } else {
-              actSpinner.warn(chalk.hex('#FFA726')('No se pudo activar la integracion. Puedes activarla manualmente desde la plataforma.'));
+              actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
             }
 
             channels.push({
@@ -327,29 +327,29 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
               key: getIntegrationKey(detected),
               multianswer: false,
             });
-            console.log(chalk.hex('#4ade80')('  Canal asociado correctamente.'));
+            console.log(chalk.hex('#4ade80')('  Channel linked successfully.'));
           } else {
-            pollSpinner.warn(chalk.hex('#FFA726')(skipped ? 'Omitido.' : 'Timeout: no se detecto conexion.'));
+            pollSpinner.warn(chalk.hex('#FFA726')(skipped ? 'Skipped.' : 'Timeout: no connection detected.'));
             const { action } = await (inquirer as any).prompt([{
               type: 'list', name: 'action',
-              message: 'Que deseas hacer?',
+              message: 'What would you like to do?',
               choices: [
-                { name: 'Ingresar ID manualmente', value: 'manual' },
-                { name: 'Saltar', value: 'skip' },
+                { name: 'Enter ID manually', value: 'manual' },
+                { name: 'Skip', 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' },
+                { type: 'input', name: 'key', message: `${channelLabel} channel ID/number:`, validate: (v: string) => v.length > 0 || 'Required' },
               ]);
 
               // Activar la integracion ingresada manualmente
-              const actSpinner = ora({ text: chalk.gray('Activando integracion...'), spinner: 'dots', color: 'green' }).start();
+              const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
               const activated = await activateIntegration(baseUrl, ctx.workspaceId, key, headers);
               if (activated) {
-                actSpinner.succeed(chalk.hex('#4ade80')('Integracion activada correctamente.'));
+                actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
               } else {
-                actSpinner.warn(chalk.hex('#FFA726')('No se pudo activar la integracion. Puedes activarla manualmente desde la plataforma.'));
+                actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
               }
 
               channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key, multianswer: false });
@@ -361,7 +361,7 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
       }
     }
 
-    const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Conectar otro canal?', default: false }]);
+    const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Connect another channel?', default: false }]);
     addMore = more;
   }
 
@@ -369,144 +369,144 @@ export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChann
 }
 
 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'));
+  console.log(section('Create new AI agent'));
+  console.log(theme.muted('  Answer the following questions to configure your agent.\n'));
 
   // Paso 1: Informacion basica
-  console.log(theme.bold('\n  Paso 1/8: Informacion basica'));
+  console.log(theme.bold('\n  Step 1/8: Basic information'));
   const basic = await (inquirer as any).prompt([
     {
       type: 'input',
       name: 'name',
-      message: 'Nombre del agente:',
-      validate: (v: string) => v.length > 0 || 'El nombre es requerido',
+      message: 'Agent name:',
+      validate: (v: string) => v.length > 0 || 'Name is required',
     },
     {
       type: 'input',
       name: 'description',
-      message: 'Descripcion breve:',
+      message: 'Short description:',
       default: '',
     },
     {
       type: 'input',
       name: 'prompt',
-      message: 'Prompt del sistema (instrucciones principales):',
-      default: 'Eres un asistente virtual amigable y profesional.',
+      message: 'System prompt (main instructions):',
+      default: 'You are a friendly and professional virtual assistant.',
     },
     {
       type: 'number',
       name: 'buffer',
-      message: 'Buffer de conversacion (3-20 mensajes):',
+      message: 'Conversation buffer (3-20 messages):',
       default: 5,
-      validate: (v: number) => (v >= 3 && v <= 20) || 'Debe ser entre 3 y 20',
+      validate: (v: number) => (v >= 3 && v <= 20) || 'Must be between 3 and 20',
     },
     {
       type: 'list',
       name: 'color',
-      message: 'Color del agente:',
+      message: 'Agent color:',
       choices: COLORS,
       default: 'blue',
     },
   ]);
 
   // Paso 2: Personalidad
-  console.log(theme.bold('\n  Paso 2/8: Personalidad e instrucciones'));
+  console.log(theme.bold('\n  Step 2/8: Personality and instructions'));
   const personality = await (inquirer as any).prompt([
     {
       type: 'list',
       name: 'tone',
-      message: 'Tono de comunicacion:',
+      message: 'Communication tone:',
       choices: ['profesional', 'amigable', 'formal', 'casual', 'tecnico', 'empatico'],
       default: 'profesional',
     },
     {
       type: 'list',
       name: 'style',
-      message: 'Estilo de respuesta:',
+      message: 'Response style:',
       choices: ['conciso', 'detallado', 'conversacional', 'directo'],
       default: 'conciso',
     },
     {
       type: 'input',
       name: 'personality',
-      message: 'Personalidad en una frase:',
-      default: 'Servicial y conocedor',
+      message: 'Personality in one sentence:',
+      default: 'Helpful and knowledgeable',
     },
     {
       type: 'input',
       name: 'objective',
-      message: 'Objetivo principal del agente:',
-      default: 'Ayudar a los usuarios con sus consultas',
+      message: 'Main objective of the agent:',
+      default: 'Help users with their queries',
     },
     {
       type: 'list',
       name: 'language',
-      message: 'Idioma principal:',
+      message: 'Primary language:',
       choices: ['Espanol', 'English', 'Portugues', 'Frances'],
       default: 'Espanol',
     },
     {
       type: 'confirm',
       name: 'useEmojis',
-      message: 'Usar emojis en respuestas?',
+      message: 'Use emojis in responses?',
       default: true,
     },
   ]);
 
   // Paso 3: Persona
-  console.log(theme.bold('\n  Paso 3/8: Identidad del agente'));
+  console.log(theme.bold('\n  Step 3/8: Agent identity'));
   const person = await (inquirer as any).prompt([
     {
       type: 'input',
       name: 'name',
-      message: 'Nombre del personaje (como se presenta):',
+      message: 'Character name (how it introduces itself):',
       default: basic.name,
     },
     {
       type: 'input',
       name: 'role',
-      message: 'Rol (ej: Asistente de ventas, Soporte tecnico):',
-      default: 'Asistente virtual',
+      message: 'Role (e.g. Sales assistant, Tech support):',
+      default: 'Virtual assistant',
     },
     {
       type: 'confirm',
       name: 'firstPerson',
-      message: 'Hablar en primera persona?',
+      message: 'Speak in first person?',
       default: true,
     },
   ]);
 
   // Paso 4: Fallbacks
-  console.log(theme.bold('\n  Paso 4/8: Mensajes de fallback'));
+  console.log(theme.bold('\n  Step 4/8: Fallback messages'));
   const fallbacks = await (inquirer as any).prompt([
     {
       type: 'input',
       name: 'noAnswer',
-      message: 'Cuando no tiene respuesta:',
+      message: 'When it has no answer:',
       default: 'Lo siento, no tengo informacion sobre eso. Puedo ayudarte con otra consulta?',
     },
     {
       type: 'input',
       name: 'serviceError',
-      message: 'Cuando hay error de servicio:',
+      message: 'When there is a service error:',
       default: 'Disculpa, estamos experimentando dificultades tecnicas. Intenta de nuevo en unos momentos.',
     },
     {
       type: 'input',
       name: 'misunderstanding',
-      message: 'Cuando no entiende la pregunta:',
+      message: 'When it does not understand the question:',
       default: 'No estoy seguro de entender tu consulta. Podrias reformularla?',
     },
   ]);
 
   // Paso 5: Tool Calling
-  console.log(theme.bold('\n  Paso 5/8: Tool Calling'));
-  console.log(theme.muted('  Tool Calling permite al agente ejecutar acciones automaticas\n'));
+  console.log(theme.bold('\n  Step 5/8: Tool Calling'));
+  console.log(theme.muted('  Tool Calling lets the agent execute automatic actions\n'));
   const { useToolCalling } = await (inquirer as any).prompt([
     {
       type: 'confirm',
       name: 'useToolCalling',
-      message: 'Activar Tool Calling?',
+      message: 'Enable Tool Calling?',
       default: true,
     },
   ]);
@@ -517,39 +517,39 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
     const { addServices } = await (inquirer as any).prompt([{
       type: 'confirm',
       name: 'addServices',
-      message: 'Agregar servicios externos (API calls)?',
+      message: 'Add external services (API calls)?',
       default: false,
     }]);
 
     if (addServices) {
       let addMore = true;
       while (addMore) {
-        console.log(theme.muted('\n  Nuevo servicio:'));
+        console.log(theme.muted('\n  New service:'));
         const svc = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Nombre/intent del servicio:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'reference', message: 'Palabras clave de referencia:', default: '' },
-          { type: 'list', name: 'method', message: 'Metodo HTTP:', choices: ['GET', 'POST'] },
-          { type: 'input', name: 'endpoint', message: 'URL del endpoint:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+          { type: 'input', name: 'intent', message: 'Service name/intent:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'reference', message: 'Reference keywords:', default: '' },
+          { type: 'list', name: 'method', message: 'HTTP method:', choices: ['GET', 'POST'] },
+          { type: 'input', name: 'endpoint', message: 'Endpoint URL:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
         ]);
 
         // Required fields
         const fields: AgentService['requiredFields'] = [];
         const { addFields } = await (inquirer as any).prompt([{
           type: 'confirm', name: 'addFields',
-          message: 'Agregar campos requeridos?', default: false,
+          message: 'Add required fields?', default: false,
         }]);
         if (addFields) {
           let moreFields = true;
           while (moreFields) {
             const field = await (inquirer as any).prompt([
-              { type: 'input', name: 'name', message: 'Nombre del campo:' },
-              { type: 'list', name: 'type', message: 'Tipo:', choices: ['string', 'number', 'boolean', 'date'] },
-              { type: 'input', name: 'description', message: 'Descripcion:' },
-              { type: 'input', name: 'promptHint', message: 'Hint para el LLM:' },
+              { type: 'input', name: 'name', message: 'Field name:' },
+              { type: 'list', name: 'type', message: 'Type:', choices: ['string', 'number', 'boolean', 'date'] },
+              { type: 'input', name: 'description', message: 'Description:' },
+              { type: 'input', name: 'promptHint', message: 'Hint for the LLM:' },
             ]);
             fields.push(field);
-            const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro campo?', default: false }]);
+            const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another field?', default: false }]);
             moreFields = more;
           }
         }
@@ -568,7 +568,7 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
           responseConditions: [],
         });
 
-        const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro servicio?', default: false }]);
+        const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another service?', default: false }]);
         addMore = more;
       }
     }
@@ -580,34 +580,34 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
     const { addActions } = await (inquirer as any).prompt([{
       type: 'confirm',
       name: 'addActions',
-      message: 'Agregar acciones (tag, stage, asignar agente)?',
+      message: 'Add actions (tag, stage, assign agent)?',
       default: false,
     }]);
 
     if (addActions) {
       let addMore = true;
       while (addMore) {
-        console.log(theme.muted('\n  Nueva accion:'));
+        console.log(theme.muted('\n  New action:'));
         const act = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Nombre/intent de la accion:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'reference', message: 'Palabras clave de referencia:', default: '' },
+          { type: 'input', name: 'intent', message: 'Action name/intent:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'reference', message: 'Reference keywords:', default: '' },
           {
-            type: 'list', name: 'actionType', message: 'Tipo de accion:',
+            type: 'list', name: 'actionType', message: 'Action type:',
             choices: [
-              { name: 'Agendar evento', value: 'action.event.add' },
-              { name: 'Actualizar evento (reagendar)', value: 'action.event.update' },
-              { name: 'Listar eventos', value: 'action.event.list' },
-              { name: 'Eliminar evento (cancelar)', value: 'action.event.delete' },
-              { name: 'Agregar tag', value: 'action.tag' },
-              { name: 'Cambiar stage', value: 'action.stage' },
-              { name: 'Derivar a agente humano', value: 'action.agentShutDown' },
-              { name: 'Marcar como resuelto', value: 'action.solved' },
-              { name: 'Asignar agente', value: 'action.asign' },
-              { name: 'Segmentacion', value: 'action.segmentation' },
+              { name: 'Schedule event', value: 'action.event.add' },
+              { name: 'Update event (reschedule)', value: 'action.event.update' },
+              { name: 'List events', value: 'action.event.list' },
+              { name: 'Delete event (cancel)', value: 'action.event.delete' },
+              { name: 'Add tag', value: 'action.tag' },
+              { name: 'Change stage', value: 'action.stage' },
+              { name: 'Hand off to human agent', value: 'action.agentShutDown' },
+              { name: 'Mark as resolved', value: 'action.solved' },
+              { name: 'Assign agent', value: 'action.asign' },
+              { name: 'Segmentation', value: 'action.segmentation' },
             ],
           },
-          { type: 'input', name: 'actionValue', message: 'Valor de la accion:', default: '' },
-          { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+          { type: 'input', name: 'actionValue', message: 'Action value:', default: '' },
+          { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
         ]);
 
         actions.push({
@@ -619,30 +619,30 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
           action: [{ type: act.actionType, value: act.actionValue }],
         });
 
-        const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Agregar otra accion?', default: false }]);
+        const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another action?', default: false }]);
         addMore = more;
       }
     }
   }
 
   // Paso 6: AI Provider
-  console.log(theme.bold('\n  Paso 6/8: Proveedor de IA'));
+  console.log(theme.bold('\n  Step 6/8: AI provider'));
   const { configureAI } = await (inquirer as any).prompt([{
     type: 'confirm',
     name: 'configureAI',
-    message: 'Configurar proveedor de IA personalizado?',
+    message: 'Configure a custom AI provider?',
     default: false,
   }]);
 
   const aiProviders: AIProvider[] = [];
   if (configureAI) {
     const ai = await (inquirer as any).prompt([
-      { type: 'list', name: 'provider', message: 'Proveedor:', choices: ['openai', 'claude', 'gemini'] },
+      { type: 'list', name: 'provider', message: 'Provider:', choices: ['openai', 'claude', 'gemini'] },
     ]);
     const models = MODELS[ai.provider] || MODELS.openai;
     const aiConfig = await (inquirer as any).prompt([
-      { type: 'list', name: 'model', message: 'Modelo:', choices: models },
-      { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v: string) => v.length > 0 || 'Requerido' },
+      { type: 'list', name: 'model', message: 'Model:', choices: models },
+      { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v: string) => v.length > 0 || 'Required' },
     ]);
 
     aiProviders.push({
@@ -656,12 +656,12 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
   }
 
   // Paso 7: Conectar canal
-  console.log(theme.bold('\n  Paso 7/8: Conectar canal'));
+  console.log(theme.bold('\n  Step 7/8: Connect channel'));
   let channels: AgentChannel[] = [];
   const { addChannel } = await (inquirer as any).prompt([{
     type: 'confirm',
     name: 'addChannel',
-    message: 'Deseas conectar un canal (WhatsApp, Instagram, Messenger)?',
+    message: 'Connect a channel (WhatsApp, Instagram, Messenger)?',
     default: false,
   }]);
 
@@ -670,19 +670,19 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
   } 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 },
+      { type: 'input', name: 'key', message: 'WhatsApp number (with country code):', validate: (v: string) => v.length > 0 || 'Required' },
+      { type: 'confirm', name: 'multianswer', message: 'Allow multiple answers?', default: false },
     ]);
     channels.push({ channel: 'whatsapp', key: wa.key, multianswer: wa.multianswer });
   }
 
   // Paso 8: Ejemplos
-  console.log(theme.bold('\n  Paso 8/8: Ejemplos de conversacion'));
+  console.log(theme.bold('\n  Step 8/8: Conversation examples'));
   const examples: AgentExample[] = [];
   const { addExamples } = await (inquirer as any).prompt([{
     type: 'confirm',
     name: 'addExamples',
-    message: 'Agregar ejemplos de conversacion?',
+    message: 'Add conversation examples?',
     default: false,
   }]);
 
@@ -690,11 +690,11 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
     let addMore = true;
     while (addMore) {
       const ex = await (inquirer as any).prompt([
-        { type: 'input', name: 'user', message: 'Mensaje del usuario:' },
-        { type: 'input', name: 'agent', message: 'Respuesta del agente:' },
+        { type: 'input', name: 'user', message: 'User message:' },
+        { type: 'input', name: 'agent', message: 'Agent response:' },
       ]);
-      examples.push({ value: `Usuario: ${ex.user}\nAgente: ${ex.agent}`, color: 'blue' });
-      const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Agregar otro ejemplo?', default: false }]);
+      examples.push({ value: `User: ${ex.user}\nAgent: ${ex.agent}`, color: 'blue' });
+      const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another example?', default: false }]);
       addMore = more;
     }
   }
@@ -736,19 +736,19 @@ export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?
   };
 
   // Preview
-  console.log(section('Vista previa de la configuracion'));
-  console.log(kvPair('Nombre', config.name));
+  console.log(section('Configuration preview'));
+  console.log(kvPair('Name', config.name));
   console.log(kvPair('Prompt', config.prompt.substring(0, 80) + '...'));
-  console.log(kvPair('Tool Calling', config.useToolCalling ? 'Activado' : 'Desactivado'));
-  console.log(kvPair('Servicios', String(config.services.length)));
-  console.log(kvPair('Acciones', String(config.actions.length)));
+  console.log(kvPair('Tool Calling', config.useToolCalling ? 'Enabled' : 'Disabled'));
+  console.log(kvPair('Services', String(config.services.length)));
+  console.log(kvPair('Actions', String(config.actions.length)));
   console.log(kvPair('AI Provider', config.customAIConfig ? config.aiProviders[0]?.provider + ' / ' + config.aiProviders[0]?.model : 'Default (Plazbot)'));
   if (config.channels.length > 0) {
     config.channels.forEach((ch, i) => {
-      console.log(kvPair(`Canal ${i + 1} (${ch.channel})`, ch.key));
+      console.log(kvPair(`Channel ${i + 1} (${ch.channel})`, ch.key));
     });
   } else {
-    console.log(kvPair('Canales', 'No configurado'));
+    console.log(kvPair('Channels', 'Not configured'));
   }
   console.log();
 

package/src/commands/auth/index.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { loginCommand } from './login';
-import { logoutCommand } from './logout';
-import { statusCommand } from './status';
+import { loginCommand } from './login.js';
+import { logoutCommand } from './logout.js';
+import { statusCommand } from './status.js';
 
 export const authCommands: Command[] = [
   loginCommand,