plazbot-cli 0.1.2

package/src/commands/portal/create.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import { Portal } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { PortalCommandOptions } from '../../types/portal';
+
+export const createCommand = new Command('create')
+  .description('Crea un nuevo portal con configuración simplificada')
+  .requiredOption('-n, --name <name>', 'Nombre del portal')
+  .requiredOption('-t, --title <title>', 'Título de bienvenida del portal')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: PortalCommandOptions & { name: string; title: string }) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const portal = new Portal({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n🚀 Creando portal...');
+      
+      const portalCreated = await portal.addPortal({
+        name: options.name,
+        title: options.title,
+        zone: credentials.zone as "LA" | "EU",
+        // Valores por defecto
+        subtitle: "",
+        logo: "",
+        logodark: "",
+        access: "direct",
+        disabled: false,
+        brandOff: false
+      });
+
+      logger.success('Portal creado exitosamente');
+      logger.info('\n📋 Detalles del portal:');
+      logger.divider();
+      logger.info(`ID: ${portalCreated.id}`);
+      logger.info(`URL: ${portalCreated.url}`);
+      logger.divider();
+
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al crear el portal';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/portal/delete.ts

@@ -0,0 +1,63 @@
+import { Command } from 'commander';
+import { Portal } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { PortalCommandOptions, PortalResponse } from '../../types/portal';
+import inquirer from 'inquirer';
+
+export const deleteCommand = new Command('delete')
+  .description('Elimina un portal')
+  .argument('<portalId>', 'ID del portal')
+  .option('--force', 'Eliminar sin confirmación', false)
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (portalId: string, options: PortalCommandOptions) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const portal = new Portal({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      // Obtener detalles del portal para mostrar qué se va a eliminar
+      const portalDetails = await portal.getPortal(portalId) as PortalResponse;
+
+      logger.info('\n🗑️ Portal a eliminar:');
+      logger.divider();
+      logger.info(`ID: ${portalDetails.portal.id}`);
+      logger.info(`Nombre: ${portalDetails.portal.name}`);
+      logger.info(`URL: ${portalDetails.portal.url}`);
+      
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: '¿Estás seguro de que quieres eliminar este portal?',
+          default: false
+        }]);
+
+        if (!confirm) {
+          logger.info('Operación cancelada.');
+          return;
+        }
+      }
+
+      logger.info('\n🔄 Eliminando portal...');
+      
+      await portal.deletePortal(portalId);
+      
+      logger.success('Portal eliminado exitosamente');
+      
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al eliminar el portal';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/portal/get.ts

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import { Portal } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { PortalCommandOptions, PortalResponse, PortalLink, PortalAgent } from '../../types/portal';
+
+export const getCommand = new Command('get')
+  .description('Muestra información detallada de un portal')
+  .argument('<portalId>', 'ID del portal')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (portalId: string, options: PortalCommandOptions) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const portal = new Portal({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n🔄 Obteniendo detalles del portal...');
+      
+      const response = await portal.getPortal(portalId) as PortalResponse;
+      const portalDetails = response.portal;
+
+      logger.info('\n🌐 Detalles del portal:');
+      logger.divider();
+      
+      logger.info(`ID: ${portalDetails.id}`);
+      logger.info(`Nombre: ${portalDetails.name}`);
+      logger.info(`URL: ${portalDetails.url}`);
+      logger.info(`Acceso: ${portalDetails.access}`);
+      logger.info(`Estado: ${portalDetails.disabled ? 'Deshabilitado' : 'Habilitado'}`);
+      
+      if (portalDetails.title) {
+        logger.info(`Título: ${portalDetails.title}`);
+      }
+      if (portalDetails.subtitle) {
+        logger.info(`Subtítulo: ${portalDetails.subtitle}`);
+      }
+
+      if (portalDetails.logo) {
+        logger.info(`\n🖼️ Recursos:`);
+        logger.info(`Logo: ${portalDetails.logo}`);
+        if (portalDetails.logodark) {
+          logger.info(`Logo (modo oscuro): ${portalDetails.logodark}`);
+        }
+      }
+
+      if (portalDetails.links && portalDetails.links.length > 0) {
+        logger.info('\n🔗 Enlaces:');
+        portalDetails.links.forEach((link: PortalLink) => {
+          logger.info(`- ${link.value}: ${link.url}`);
+        });
+      }
+
+      if (portalDetails.agents && portalDetails.agents.length > 0) {
+        logger.info('\n🤖 Agentes asociados:');
+        portalDetails.agents.forEach((agent: PortalAgent) => {
+          logger.info(`- ${agent.name} (${agent.id})`);
+        });
+      }
+
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al obtener detalles del portal';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/portal/index.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import { getCommand } from './get';
+import { deleteCommand } from './delete';
+import { createCommand } from './create';
+import { updateCommand } from './update';
+import { addAgentCommand } from './add-agent';
+import { listCommand } from './list';
+import { addLinkCommand } from './add-link';
+import { clearLinksCommand } from './clear-links';
+
+export const portalCommands = new Command('portal')
+  .description('Comandos relacionados con portales')
+  .addCommand(listCommand)
+  .addCommand(getCommand)
+  .addCommand(deleteCommand)
+  .addCommand(createCommand)
+  .addCommand(updateCommand)
+  .addCommand(addAgentCommand)
+  .addCommand(addLinkCommand)
+  .addCommand(clearLinksCommand); 

package/src/commands/portal/list.ts

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import { Portal } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { PortalCommandOptions } from '../../types/portal';
+
+export const listCommand = new Command('list')
+  .description('Muestra el portal asociado al workspace')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: PortalCommandOptions) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const portal = new Portal({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n🔍 Buscando portal del workspace...');
+      
+      const response = await portal.getExistsPortal();
+      const portalDetails = response.portal;
+
+      logger.info('\n🌐 Portal encontrado:');
+      logger.divider();
+      logger.info(`ID: ${portalDetails.id}`);
+      logger.info(`Nombre: ${portalDetails.name}`);
+      logger.info(`URL: ${portalDetails.url}`);
+      logger.info(`Acceso: ${portalDetails.access}`);
+      logger.info(`Estado: ${portalDetails.disabled ? 'Deshabilitado' : 'Habilitado'}`);
+      
+      if (portalDetails.title) {
+        logger.info(`Título: ${portalDetails.title}`);
+      }
+      if (portalDetails.subtitle) {
+        logger.info(`Subtítulo: ${portalDetails.subtitle}`);
+      }
+
+      if (portalDetails.logo) {
+        logger.info('\n🖼️ Recursos:');
+        logger.info(`Logo: ${portalDetails.logo}`);
+        if (portalDetails.logodark) {
+          logger.info(`Logo (modo oscuro): ${portalDetails.logodark}`);
+        }
+      }
+
+      if (portalDetails.links && portalDetails.links.length > 0) {
+        logger.info('\n🔗 Enlaces:');
+        portalDetails.links.forEach((link: { value: string; url: string }) => {
+          logger.info(`- ${link.value}: ${link.url}`);
+        });
+      }
+
+      if (portalDetails.agents && portalDetails.agents.length > 0) {
+        logger.info('\n🤖 Agentes asociados:');
+        portalDetails.agents.forEach((agent: { name: string; id: string }) => {
+          logger.info(`- ${agent.name} (${agent.id})`);
+        });
+      }
+      
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al listar el portal';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/portal/update.ts

@@ -0,0 +1,82 @@
+import { Command } from 'commander';
+import { Portal } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { PortalCommandOptions } from '../../types/portal';
+
+export const updateCommand = new Command('update')
+  .description('Actualiza un portal existente')
+  .argument('<portalId>', 'ID del portal a actualizar')
+  .option('-n, --name <name>', 'Nuevo nombre del portal')
+  .option('-t, --title <title>', 'Nuevo título del portal')
+  .option('-s, --subtitle <subtitle>', 'Nuevo subtítulo del portal')
+  .option('-l, --logo <url>', 'Nueva URL del logo')
+  .option('-d, --logo-dark <url>', 'Nueva URL del logo en modo oscuro')
+  .option('-a, --access <type>', 'Tipo de acceso (direct o form)')
+  .option('--disabled <value>', 'Estado de deshabilitación (true o false)')
+  .option('--brand-off <value>', 'Estado de marca deshabilitada (true o false)')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (portalId: string, options: PortalCommandOptions) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const portal = new Portal({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      // Obtener detalles actuales del portal
+      const currentPortal = await portal.getPortal(portalId);
+
+      logger.info('\n🌐 Actualizando portal...');
+      logger.info('Portal actual:');
+      logger.info(JSON.stringify(currentPortal.portal, null, 2));
+      
+      // Construir objeto de actualización solo con los campos proporcionados
+      const updateData: any = { id: portalId };
+      
+      if (options.name) updateData.name = options.name;
+      if (options.title) updateData.title = options.title;
+      if (options.subtitle) updateData.subtitle = options.subtitle;
+      if (options.logo) updateData.logo = options.logo;
+      if (options.logoDark) updateData.logodark = options.logoDark;
+      if (options.access) {
+        if (options.access !== 'direct' && options.access !== 'form') {
+          throw new Error('El tipo de acceso debe ser "direct" o "form"');
+        }
+        updateData.access = options.access;
+      }
+      if (options.disabled) {
+        if (options.disabled !== 'true' && options.disabled !== 'false') {
+          throw new Error('El valor de disabled debe ser "true" o "false"');
+        }
+        updateData.disabled = options.disabled === 'true';
+      }
+      if (options.brandOff) {
+        if (options.brandOff !== 'true' && options.brandOff !== 'false') {
+          throw new Error('El valor de brand-off debe ser "true" o "false"');
+        }
+        updateData.brandOff = options.brandOff === 'true';
+      }
+
+      logger.info('\nCambios a aplicar:');
+      logger.info(JSON.stringify(updateData, null, 2));
+      
+      const result = await portal.updatePortal(updateData);
+
+      logger.success('Portal actualizado exitosamente');
+      logger.info(`Mensaje: ${result.message}`);
+      
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al actualizar el portal';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/whatsapp/delete-webhook.ts

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+
+interface DeleteWebhookOptions {
+  dev?: boolean;
+  number: string;
+}
+
+export const deleteWebhookCommand = new Command('delete-webhook')
+  .description('Elimina el webhook de WhatsApp')
+  .requiredOption('-n, --number <phone>', 'Número de WhatsApp (con código de país, ej: 51912345678)')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: DeleteWebhookOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n🗑️ Eliminando webhook de WhatsApp...');
+      logger.info(`Número: ${options.number}`);
+
+      await messageClient.deleteWebhook({
+        number: options.number
+      });
+
+      logger.success('Webhook eliminado exitosamente');
+    } catch (error: unknown) {
+      logger.error(`❌ Error al eliminar webhook: ${(error as Error).message}`);
+      process.exit(1);
+    }
+  }); 

package/src/commands/whatsapp/index.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { sendMessageCommand } from './send';
+import { sendTemplateCommand } from './send-template';
+import { registerWebhookCommand } from './register-webhook';
+import { deleteWebhookCommand } from './delete-webhook';
+
+export const whatsappCommands = new Command('whatsapp')
+  .description('Comandos relacionados con mensajes de WhatsApp')
+  .addCommand(sendMessageCommand)
+  .addCommand(sendTemplateCommand)
+  .addCommand(registerWebhookCommand)
+  .addCommand(deleteWebhookCommand); 

package/src/commands/whatsapp/register-webhook.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+
+interface RegisterWebhookOptions {
+  dev?: boolean;
+  number: string;
+  url: string;
+}
+
+export const registerWebhookCommand = new Command('register-webhook')
+  .description('Registra un webhook para WhatsApp')
+  .requiredOption('-n, --number <phone>', 'Número de WhatsApp (con código de país, ej: 51912345678)')
+  .requiredOption('-u, --url <webhook>', 'URL del webhook')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: RegisterWebhookOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n🔗 Registrando webhook de WhatsApp...');
+      logger.info(`Número: ${options.number}`);
+      logger.info(`URL: ${options.url}`);
+
+      await messageClient.registerWebhook({
+        number: options.number,
+        webhookUrl: options.url
+      });
+
+      logger.success('Webhook registrado exitosamente');
+    } catch (error: unknown) {
+      logger.error(`❌ Error al registrar webhook: ${(error as Error).message}`);
+      process.exit(1);
+    }
+  }); 

package/src/commands/whatsapp/send-template.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { TemplateCommandOptions } from '../../types/message';
+
+export const sendTemplateCommand = new Command('send-template')
+  .description('Envía una plantilla de WhatsApp')
+  .requiredOption('-p, --phone <number>', 'Número de teléfono del destinatario (con código de país, ej: 51912345678)')
+  .requiredOption('-t, --template <name>', 'Nombre de la plantilla a enviar')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: TemplateCommandOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n📱 Enviando plantilla de WhatsApp...');
+      logger.info(`A: ${options.phone}`);
+      logger.info(`Plantilla: ${options.template}`);
+      
+      const response = await messageClient.onConversation({
+        to: options.phone,
+        template: options.template
+      });
+
+      logger.success('Plantilla enviada exitosamente');
+      logger.info('\n📋 Detalles:');
+      logger.info(JSON.stringify(response, null, 2));
+      
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Error desconocido al enviar la plantilla';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/commands/whatsapp/send.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { DirectMessageCommandOptions } from '../../types/message';
+
+export const sendMessageCommand = new Command('send-message')
+  .description('Envía un mensaje de WhatsApp')
+  .requiredOption('-t, --to <phone>', 'Número de teléfono del destinatario (con código de país, ej: 51912345678)')
+  .requiredOption('-m, --message <text>', 'Mensaje a enviar')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: DirectMessageCommandOptions) => {
+    try {
+      // Obtener credenciales guardadas
+      const credentials = await getStoredCredentials();
+      
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      logger.info('\n📱 Enviando mensaje de WhatsApp...');
+      logger.info(`A: ${options.to}`);
+      logger.info(`Mensaje: ${options.message}`);
+      
+      const response = await messageClient.onWhatsappMessage({
+        message: options.message,
+        to: options.to
+      });
+
+      logger.success('Mensaje enviado exitosamente');
+      logger.info('\n📋 Detalles:');
+      logger.info(JSON.stringify(response, null, 2));
+      
+      if (options.dev) {
+        logger.warning('\nAmbiente: desarrollo');
+      }
+
+    } catch (error: unknown) {
+      const message = (error as Error)?.message || 'Error desconocido al enviar el mensaje';
+      logger.error(message);
+      process.exit(1);
+    }
+  }); 

package/src/types/agent.ts

@@ -0,0 +1,63 @@
+import { BaseCommandOptions } from './common';
+
+export interface AgentCommandOptions {
+  dev?: boolean;
+}
+
+export interface ChatOptions extends BaseCommandOptions {
+  agentId: string;
+  sessionId?: string;
+  multipleAnswers?: boolean;
+}
+
+export interface OnMessageOptions extends BaseCommandOptions {
+  agentId: string;
+  question: string;
+  sessionId?: string;
+  multipleAnswers?: boolean;
+}
+
+export interface EnableWidgetOptions extends AgentCommandOptions {
+  disable?: boolean;
+}
+
+export interface ListAgentsOptions extends BaseCommandOptions {
+}
+
+export interface AgentListItem {
+  id: string;
+  name: string;
+  enable: boolean;
+  description: string;
+  createdAt: string;
+}
+
+export interface ChatMessage {
+  timestamp: string;
+  role: string;
+  content: string;
+  metadata?: Record<string, any>;
+  source?: string;
+}
+
+export interface ChatHistoryParams {
+  id: string;
+  limit: number;
+  from?: string;
+  to?: string;
+}
+
+export interface ChatHistoryResponse {
+  messages: ChatMessage[];
+  success: boolean;
+}
+
+export interface AgentSource {
+  title?: string;
+  url?: string;
+}
+
+export interface AgentResponse {
+  answer: string;
+  sources?: AgentSource[];
+} 

package/src/types/auth.ts

@@ -0,0 +1,8 @@
+import { BaseCommandOptions } from './common';
+
+export interface LoginOptions extends BaseCommandOptions {
+  email: string;
+  apiKey: string;
+  workspace: string;
+  zone: "LA" | "EU";
+} 

package/src/types/common.ts

@@ -0,0 +1,10 @@
+export interface BaseCommandOptions {
+  dev?: boolean;
+}
+
+export interface SDKOptions {
+  workspaceId: string;
+  apiKey: string;
+  zone: "LA" | "EU";
+  customUrl?: string;
+} 

package/src/types/message.ts

@@ -0,0 +1,34 @@
+export interface MessageCommandOptions {
+  dev?: boolean;
+  to?: string;
+  message?: string;
+  phone?: string;
+  template?: string;
+}
+
+export interface DirectMessageCommandOptions {
+  dev?: boolean;
+  to: string;
+  message: string;
+}
+
+export interface TemplateCommandOptions {
+  dev?: boolean;
+  phone: string;
+  template: string;
+}
+
+export interface WhatsappMessageParams {
+  message: string;
+  to: string;
+}
+
+export interface ConversationTemplateParams {
+  to: string;
+  template: string;
+}
+
+export interface WebhookParams {
+  number: string;
+  webhookUrl: string;
+}