plazbot-cli 0.2.25 → 0.3.1

package/src/commands/agent/copy.ts

@@ -1,14 +1,15 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { createSpinner } from '../../utils/ui';
-import { AgentCommandOptions } from '../../types/agent';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { createSpinner } from '../../utils/ui.js';
+import { AgentCommandOptions } from '../../types/agent.js';
 
 export const copyCommand = new Command('copy')
-  .description('Clonar un agente existente')
-  .argument('<agentId>', 'ID del agente a clonar')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Clone an existing agent')
+  .argument('<agentId>', 'Agent ID to clone')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: AgentCommandOptions) => {
     try {
       const credentials = await getStoredCredentials();
@@ -19,22 +20,27 @@ export const copyCommand = new Command('copy')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      const spinner = createSpinner('Clonando agente...');
+      const spinner = createSpinner('Cloning agent...');
       spinner.start();
 
       const result = await (agent as any).copyAgent({ id: agentId });
 
-      spinner.succeed('Agente clonado exitosamente');
+      spinner.succeed('Agent cloned successfully');
 
-      logger.title('Agente clonado');
+      logger.title('Cloned agent');
       if (result?.agentId || result?.id) {
-        logger.label('Nuevo ID', result.agentId || result.id);
+        logger.label('New ID', result.agentId || result.id);
       }
-      logger.dim('\nEl agente clonado tiene el widget deshabilitado por defecto.');
+      logger.dim('\nThe cloned agent has the widget disabled by default.');
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido';
+      const message = error instanceof Error ? error.message : 'Unknown error';
       logger.error(message);
       process.exit(1);
     }
   });
+
+addExamples(copyCommand, [
+  { description: 'Clone an agent (widget stays disabled on the copy)',
+    command: 'plazbot agent copy agt_AbcDef123' },
+]);

package/src/commands/agent/create.ts

@@ -1,16 +1,17 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { AgentCommandOptions } from '../../types/agent';
-import { createSpinner } from '../../utils/ui';
-import { runAgentWizard } from './wizard';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { AgentCommandOptions } from '../../types/agent.js';
+import { createSpinner } from '../../utils/ui.js';
+import { runAgentWizard } from './wizard.js';
 import fs from 'fs/promises';
 
 export const createCommand = new Command('create')
-  .description('Crea un nuevo agente de IA (wizard interactivo o archivo JSON)')
-  .argument('[configPath]', 'Ruta al archivo de configuracion JSON (opcional)')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Create a new AI agent (interactive wizard or JSON file)')
+  .argument('[configPath]', 'Path to the JSON config file (optional)')
+  .option('--dev', 'Use development environment', false)
   .action(async (configPath: string | undefined, options: AgentCommandOptions) => {
     try {
       const credentials = await getStoredCredentials();
@@ -30,10 +31,10 @@ export const createCommand = new Command('create')
           const fileContent = await fs.readFile(configPath, 'utf-8');
           agentConfig = JSON.parse(fileContent);
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
-          throw new Error(`Error al leer el archivo de configuracion: ${errorMessage}`);
+          const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+          throw new Error(`Failed to read config file: ${errorMessage}`);
         }
-        logger.title('Creando agente desde archivo');
+        logger.title('Creating agent from file');
         logger.json(agentConfig);
       } else {
         // Modo wizard interactivo
@@ -43,51 +44,60 @@ export const createCommand = new Command('create')
         const { confirm } = await inquirer.default.prompt([{
           type: 'confirm',
           name: 'confirm',
-          message: 'Crear el agente con esta configuracion?',
+          message: 'Create the agent with this configuration?',
           default: true,
         }]);
 
         if (!confirm) {
-          logger.warning('Creacion cancelada');
+          logger.warning('Creation cancelled');
           return;
         }
       }
 
-      const spinner = createSpinner('Creando agente...');
+      const spinner = createSpinner('Creating agent...');
       spinner.start();
 
       const result = await agent.addAgent(agentConfig);
 
-      spinner.succeed('Agente creado exitosamente');
+      spinner.succeed('Agent created successfully');
 
-      logger.title('Detalles del agente');
+      logger.title('Agent details');
       if (result.agentId) {
         logger.label('ID', result.agentId);
       }
       if (agentConfig.name) {
-        logger.label('Nombre', agentConfig.name);
+        logger.label('Name', agentConfig.name);
       }
-      logger.label('Tool Calling', agentConfig.useToolCalling ? 'Activado' : 'Desactivado');
+      logger.label('Tool Calling', agentConfig.useToolCalling ? 'Enabled' : 'Disabled');
 
       if (agentConfig.channels && agentConfig.channels.length > 0) {
         agentConfig.channels.forEach((ch: any) => {
-          logger.label(`Canal (${ch.channel})`, ch.key);
+          logger.label(`Channel (${ch.channel})`, ch.key);
         });
       }
 
       console.log();
-      logger.dim('Siguiente paso: plazbot agent chat -a ' + (result.agentId || '<agentId>'));
+      logger.dim('Next step: plazbot agent chat -a ' + (result.agentId || '<agentId>'));
       console.log();
 
       if (options.dev) {
-        logger.warning('Ambiente: desarrollo');
+        logger.warning('Environment: development');
       }
 
       process.exit(0);
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido al crear el agente';
+      const message = error instanceof Error ? error.message : 'Unknown error while creating the agent';
       logger.error(message);
       process.exit(1);
     }
   });
+
+addExamples(createCommand, [
+  { description: 'Launch the interactive wizard to design the agent',
+    command: 'plazbot agent create' },
+  { description: 'Create directly from a JSON configuration file',
+    command: 'plazbot agent create ./agent.json' },
+  { description: 'Create against a local backend (dev mode)',
+    command: 'plazbot agent create ./agent.json --dev' },
+]);

package/src/commands/agent/delete.ts

@@ -1,14 +1,15 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { AgentCommandOptions } from '../../types/agent';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { AgentCommandOptions } from '../../types/agent.js';
 import readline from 'readline';
 
 export const deleteCommand = new Command('delete')
-  .description('Elimina un agente existente')
-  .argument('<agentId>', 'ID del agente a eliminar')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Delete an existing agent')
+  .argument('<agentId>', 'Agent ID to delete')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: AgentCommandOptions) => {
     try {
       // Obtener credenciales guardadas
@@ -25,11 +26,11 @@ export const deleteCommand = new Command('delete')
       const response: any = await agent.getAgentById({ id: agentId });
       const agentDetails = response.agent || response.data || response;
 
-      logger.warning('\nVas a eliminar el siguiente agente:');
+      logger.warning('\nYou are about to delete the following agent:');
       logger.divider();
       logger.info(`ID: ${agentDetails.id || agentId}`);
-      logger.info(`Nombre: ${agentDetails.name || '—'}`);
-      logger.info(`Descripcion: ${agentDetails.description || '—'}`);
+      logger.info(`Name: ${agentDetails.name || '—'}`);
+      logger.info(`Description: ${agentDetails.description || '—'}`);
       logger.divider();
 
       // Crear interfaz para confirmación
@@ -39,27 +40,32 @@ export const deleteCommand = new Command('delete')
       });
 
       // Preguntar por confirmación
-      rl.question('\nEstas seguro que deseas eliminar este agente? (y/N): ', async (answer) => {
+      rl.question('\nAre you sure you want to delete this agent? (y/N): ', async (answer) => {
         if (answer.toLowerCase() === 'y') {
           await agent.deleteAgent({
             id: agentId
           });
-          
-          logger.success('Agente eliminado exitosamente');
-          
+
+          logger.success('Agent deleted successfully');
+
           if (options.dev) {
-            logger.warning('Ambiente: desarrollo');
+            logger.warning('Environment: development');
           }
         } else {
-          logger.error('Operación cancelada');
+          logger.error('Operation cancelled');
         }
-        
+
         rl.close();
       });
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido al eliminar el agente';
+      const message = error instanceof Error ? error.message : 'Unknown error while deleting the agent';
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });
+
+addExamples(deleteCommand, [
+  { description: 'Delete an agent (asks for y/N confirmation)',
+    command: 'plazbot agent delete agt_AbcDef123' },
+]);

package/src/commands/agent/enable-widget.ts

@@ -1,14 +1,15 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { EnableWidgetOptions } from '../../types/agent';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { EnableWidgetOptions } from '../../types/agent.js';
 
 export const enableCommand = new Command('enable-widget')
-  .description('Habilita o deshabilita el widget de un agente')
-  .argument('<agentId>', 'ID del agente')
-  .option('-d, --disable', 'Deshabilitar el widget en lugar de habilitarlo')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Enable or disable an agent widget')
+  .argument('<agentId>', 'Agent ID')
+  .option('-d, --disable', 'Disable the widget instead of enabling it')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: EnableWidgetOptions) => {
     try {
       // Obtener credenciales guardadas
@@ -25,35 +26,42 @@ export const enableCommand = new Command('enable-widget')
       const _res: any = await agent.getAgentById({ id: agentId });
       const agentDetails = _res.agent || _res.data || _res;
 
-      logger.title('Estado actual del widget');
-      logger.label('Agente', agentDetails.name);
+      logger.title('Current widget status');
+      logger.label('Agent', agentDetails.name);
 
       // Cambiar estado
       const newState = !options.disable; // Si --disable está presente, newState será false
-      const result = await agent.enableWidget({ 
-        id: agentId, 
-        enable: newState 
+      const result = await agent.enableWidget({
+        id: agentId,
+        enable: newState
       });
 
-      logger.success(`Widget ${newState ? 'habilitado' : 'deshabilitado'} exitosamente`);
-      
-      logger.title('Respuesta del servidor');
-      logger.label('Estado', result.success ? 'Exitoso' : 'Fallido');
-      logger.label('Mensaje', result.message);
+      logger.success(`Widget ${newState ? 'enabled' : 'disabled'} successfully`);
+
+      logger.title('Server response');
+      logger.label('Status', result.success ? 'Success' : 'Failed');
+      logger.label('Message', result.message);
 
       if (newState && result.script) {
-        logger.title('Instrucciones de instalacion');
-        logger.dim('Coloca este script debajo de la etiqueta <HEAD> en tu sitio web:');
+        logger.title('Installation instructions');
+        logger.dim('Place this script under the <HEAD> tag of your website:');
         logger.info('\n' + result.script);
       }
-      
+
       if (options.dev) {
-        logger.warning('Ambiente: desarrollo');
+        logger.warning('Environment: development');
       }
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido al modificar el widget';
+      const message = error instanceof Error ? error.message : 'Unknown error while updating the widget';
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });
+
+addExamples(enableCommand, [
+  { description: 'Enable the widget and print the <script> snippet',
+    command: 'plazbot agent enable-widget agt_AbcDef123' },
+  { description: 'Disable an existing widget',
+    command: 'plazbot agent enable-widget agt_AbcDef123 --disable' },
+]);

package/src/commands/agent/export.ts

@@ -1,8 +1,9 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { createSpinner } from '../../utils/ui';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { createSpinner } from '../../utils/ui.js';
 import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
@@ -173,14 +174,14 @@ function cleanAgentForExport(agentData: any): any {
 }
 
 export const exportCommand = new Command('export')
-  .description('Exportar configuracion limpia de un agente (compatible con importacion)')
-  .argument('<agentId>', 'ID del agente a exportar')
-  .option('-w, --workspace <id>', 'Workspace ID origen (sobreescribe config local)')
-  .option('-z, --zone <zone>', 'Zona LA o EU (sobreescribe config local)')
-  .option('-o, --output <path>', 'Ruta del archivo de salida (.json)')
-  .option('--no-channels', 'Excluir canales de la exportacion')
-  .option('--no-ai', 'Excluir configuracion de IA personalizada')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Export a clean agent configuration (compatible with import)')
+  .argument('<agentId>', 'Agent ID to export')
+  .option('-w, --workspace <id>', 'Source workspace ID (overrides local config)')
+  .option('-z, --zone <zone>', 'Zone LA or EU (overrides local config)')
+  .option('-o, --output <path>', 'Output file path (.json)')
+  .option('--no-channels', 'Exclude channels from export')
+  .option('--no-ai', 'Exclude custom AI configuration')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: {
     workspace?: string;
     zone?: string;
@@ -196,7 +197,7 @@ export const exportCommand = new Command('export')
       const effectiveZone = (options.zone?.toUpperCase() === 'EU' ? 'EU' : options.zone?.toUpperCase() === 'LA' ? 'LA' : credentials.zone) as 'LA' | 'EU';
 
       if (options.workspace || options.zone) {
-        console.log(chalk.hex('#FFA726')(`\n  Modo soporte: workspace=${effectiveWorkspace} zona=${effectiveZone}`));
+        console.log(chalk.hex('#FFA726')(`\n  Support mode: workspace=${effectiveWorkspace} zone=${effectiveZone}`));
       }
 
       const agent = new Agent({
@@ -206,13 +207,13 @@ export const exportCommand = new Command('export')
         ...(options.dev && { customUrl: 'http://localhost:5090' }),
       });
 
-      const spinner = createSpinner('Obteniendo agente...');
+      const spinner = createSpinner('Fetching agent...');
       spinner.start();
 
       const response: any = await agent.getAgentById({ id: agentId });
       const agentData = response.agent || response.data || response;
 
-      spinner.succeed('Agente obtenido');
+      spinner.succeed('Agent fetched');
 
       // Limpiar para exportacion
       const cleaned = cleanAgentForExport(agentData);
@@ -233,35 +234,46 @@ export const exportCommand = new Command('export')
       if (options.output) {
         const outputPath = path.resolve(options.output);
         fs.writeFileSync(outputPath, jsonOutput, 'utf-8');
-        console.log(chalk.hex('#4ade80')(`\n  Exportado a: ${outputPath}`));
+        console.log(chalk.hex('#4ade80')(`\n  Exported to: ${outputPath}`));
       } else {
         console.log();
         console.log(jsonOutput);
       }
 
       console.log();
-      console.log(chalk.gray('  Este JSON es compatible con:'));
-      console.log(chalk.gray('  - plazbot agent create <archivo.json>'));
-      console.log(chalk.gray('  - Importar JSON en la plataforma (AgentTraining)'));
+      console.log(chalk.gray('  This JSON is compatible with:'));
+      console.log(chalk.gray('  - plazbot agent create <file.json>'));
+      console.log(chalk.gray('  - Importing JSON in the platform (AgentTraining)'));
       console.log();
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido';
+      const message = error instanceof Error ? error.message : 'Unknown error';
       logger.error(message);
       process.exit(1);
     }
   });
 
+addExamples(exportCommand, [
+  { description: 'Print the cleaned JSON to stdout',
+    command: 'plazbot agent export agt_AbcDef123' },
+  { description: 'Write the cleaned JSON to a file',
+    command: 'plazbot agent export agt_AbcDef123 -o ./agent.json' },
+  { description: 'Export without channels nor AI credentials (portable JSON)',
+    command: 'plazbot agent export agt_AbcDef123 -o ./agent.json --no-channels --no-ai' },
+  { description: 'Export from a different workspace (support mode)',
+    command: 'plazbot agent export agt_AbcDef123 -w wok_Other123 -z LA -o ./agent.json' },
+]);
+
 export const crossCopyCommand = new Command('cross-copy')
-  .description('Copiar un agente de un workspace a otro')
-  .argument('<agentId>', 'ID del agente a copiar')
-  .requiredOption('--from-workspace <id>', 'Workspace ID de origen')
-  .requiredOption('--to-workspace <id>', 'Workspace ID de destino')
-  .option('--from-zone <zone>', 'Zona del workspace origen (LA o EU)', 'LA')
-  .option('--to-zone <zone>', 'Zona del workspace destino (LA o EU)', 'LA')
-  .option('--no-channels', 'No copiar canales (recomendado)')
-  .option('--no-ai', 'No copiar configuracion de IA personalizada')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Copy an agent from one workspace to another')
+  .argument('<agentId>', 'Agent ID to copy')
+  .requiredOption('--from-workspace <id>', 'Source workspace ID')
+  .requiredOption('--to-workspace <id>', 'Target workspace ID')
+  .option('--from-zone <zone>', 'Source workspace zone (LA or EU)', 'LA')
+  .option('--to-zone <zone>', 'Target workspace zone (LA or EU)', 'LA')
+  .option('--no-channels', 'Do not copy channels (recommended)')
+  .option('--no-ai', 'Do not copy custom AI configuration')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: {
     fromWorkspace: string;
     toWorkspace: string;
@@ -278,16 +290,16 @@ export const crossCopyCommand = new Command('cross-copy')
 
       console.log();
       console.log(chalk.hex('#4CAF50')('  ┌' + '─'.repeat(58) + '┐'));
-      console.log(chalk.hex('#4CAF50')('  │') + chalk.bold('  Copiar agente entre workspaces').padEnd(68) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.bold('  Copy agent between workspaces').padEnd(68) + chalk.hex('#4CAF50')('│'));
       console.log(chalk.hex('#4CAF50')('  └' + '─'.repeat(58) + '┘'));
       console.log();
-      console.log(chalk.gray(`  Origen:  ${options.fromWorkspace} (${fromZone})`));
-      console.log(chalk.gray(`  Destino: ${options.toWorkspace} (${toZone})`));
-      console.log(chalk.gray(`  Agente:  ${agentId}`));
+      console.log(chalk.gray(`  Source: ${options.fromWorkspace} (${fromZone})`));
+      console.log(chalk.gray(`  Target: ${options.toWorkspace} (${toZone})`));
+      console.log(chalk.gray(`  Agent:  ${agentId}`));
       console.log();
 
       // 1. Obtener agente del workspace origen
-      const spinnerGet = createSpinner('Obteniendo agente del workspace origen...');
+      const spinnerGet = createSpinner('Fetching agent from source workspace...');
       spinnerGet.start();
 
       const sourceAgent = new Agent({
@@ -301,11 +313,11 @@ export const crossCopyCommand = new Command('cross-copy')
       const agentData = response.agent || response.data || response;
 
       if (!agentData || !agentData.name) {
-        spinnerGet.fail('No se encontro el agente en el workspace origen');
+        spinnerGet.fail('Agent not found in source workspace');
         process.exit(1);
       }
 
-      spinnerGet.succeed(`Agente obtenido: ${agentData.name}`);
+      spinnerGet.succeed(`Agent fetched: ${agentData.name}`);
 
       // 2. Limpiar JSON
       const cleaned = cleanAgentForExport(agentData);
@@ -329,29 +341,29 @@ export const crossCopyCommand = new Command('cross-copy')
 
       // 3. Mostrar resumen
       console.log();
-      console.log(chalk.bold('  Configuracion a copiar:'));
-      console.log(chalk.gray(`  Nombre:       ${cleaned.name}`));
-      console.log(chalk.gray(`  Zona destino: ${cleaned.zone}`));
-      console.log(chalk.gray(`  Canales:      ${cleaned.channels?.length || 0}`));
-      console.log(chalk.gray(`  Servicios:    ${cleaned.services?.length || 0}`));
-      console.log(chalk.gray(`  Acciones:     ${cleaned.actions?.length || 0}`));
-      console.log(chalk.gray(`  AI Custom:    ${cleaned.customAIConfig ? 'Si' : 'No'}`));
+      console.log(chalk.bold('  Configuration to copy:'));
+      console.log(chalk.gray(`  Name:        ${cleaned.name}`));
+      console.log(chalk.gray(`  Target zone: ${cleaned.zone}`));
+      console.log(chalk.gray(`  Channels:    ${cleaned.channels?.length || 0}`));
+      console.log(chalk.gray(`  Services:    ${cleaned.services?.length || 0}`));
+      console.log(chalk.gray(`  Actions:     ${cleaned.actions?.length || 0}`));
+      console.log(chalk.gray(`  Custom AI:   ${cleaned.customAIConfig ? 'Yes' : 'No'}`));
       console.log();
 
       const { confirm } = await (inquirer as any).prompt([{
         type: 'confirm',
         name: 'confirm',
-        message: 'Crear este agente en el workspace destino?',
+        message: 'Create this agent in the target workspace?',
         default: true,
       }]);
 
       if (!confirm) {
-        console.log(chalk.gray('  Operacion cancelada.'));
+        console.log(chalk.gray('  Operation cancelled.'));
         return;
       }
 
       // 4. Crear en workspace destino
-      const spinnerCreate = createSpinner('Creando agente en workspace destino...');
+      const spinnerCreate = createSpinner('Creating agent in target workspace...');
       spinnerCreate.start();
 
       const targetAgent = new Agent({
@@ -364,24 +376,33 @@ export const crossCopyCommand = new Command('cross-copy')
       const result: any = await targetAgent.addAgent(cleaned);
 
       if (result?.success === false) {
-        spinnerCreate.fail(`Error: ${result.message || 'No se pudo crear el agente'}`);
+        spinnerCreate.fail(`Error: ${result.message || 'Could not create the agent'}`);
         process.exit(1);
       }
 
       const newId = result?.agentId || result?.id || result?.data?.agentId;
-      spinnerCreate.succeed('Agente creado exitosamente');
+      spinnerCreate.succeed('Agent created successfully');
 
       console.log();
       if (newId) {
-        console.log(chalk.hex('#4ade80')(`  Nuevo ID: ${newId}`));
+        console.log(chalk.hex('#4ade80')(`  New ID: ${newId}`));
       }
-      console.log(chalk.gray('  Widget deshabilitado por defecto.'));
-      console.log(chalk.gray('  Canales deben configurarse manualmente en el workspace destino.'));
+      console.log(chalk.gray('  Widget disabled by default.'));
+      console.log(chalk.gray('  Channels must be configured manually in the target workspace.'));
       console.log();
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido';
+      const message = error instanceof Error ? error.message : 'Unknown error';
       logger.error(message);
       process.exit(1);
     }
   });
+
+addExamples(crossCopyCommand, [
+  { description: 'Copy an agent between two LA workspaces (skip channels)',
+    command: 'plazbot agent cross-copy agt_AbcDef123 --from-workspace wok_Source123 --to-workspace wok_Target456' },
+  { description: 'Copy across zones (LA → EU)',
+    command: 'plazbot agent cross-copy agt_AbcDef123 --from-workspace wok_Source123 --from-zone LA --to-workspace wok_Target456 --to-zone EU' },
+  { description: 'Copy preserving channels and AI providers',
+    command: 'plazbot agent cross-copy agt_AbcDef123 --from-workspace wok_Source123 --to-workspace wok_Target456 --channels --ai' },
+]);