plazbot-cli 0.3.7 → 0.4.1

package/README.md

@@ -1,8 +1,44 @@
 # Plazbot CLI
 
-Official Command Line Interface for Plazbot - Manage your AI agents and portals directly from the terminal.
+CLI oficial de Plazbot: conecta WhatsApp, envía mensajes, gestiona agentes IA y despliega workers desde tu terminal.
 
-## Features
+## Empieza en 3 comandos
+
+```bash
+npm i -g plazbot-cli
+plazbot login            # abre el navegador y autorizas (sin copiar API key)
+plazbot whatsapp setup   # conecta tu número y prueba tu primer mensaje
+```
+
+`plazbot whatsapp setup` te guía paso a paso: conecta un número (WhatsApp API o tu
+WhatsApp Business actual), te pide escribir "hola" desde tu celular, responde por la API
+y registra tu webhook. Al final te da el código para tu app.
+
+### Sesión
+
+```bash
+plazbot login [--zone LA|EU] [--no-browser]   # login por navegador
+plazbot whoami                                # sesión activa
+plazbot workspace list | use <id>             # cambiar de workspace
+plazbot logout
+```
+
+En CI o servidores usa variables de entorno en lugar de `plazbot login`:
+`PLAZBOT_API_KEY`, `PLAZBOT_WORKSPACE_ID` y `PLAZBOT_ZONE` (`LA` o `EU`).
+
+### WhatsApp
+
+```bash
+plazbot whatsapp setup                                         # asistente de primer uso
+plazbot whatsapp connect [--business]                          # conectar un número
+plazbot whatsapp send-message --to 51912345678 --message "Hola"
+plazbot whatsapp send-template --phone 51912345678 --template welcome --var 1=Ana
+plazbot whatsapp register-webhook --number 51966446311 --url https://tu-app.com/whatsapp
+```
+
+Documentación: https://developers.plazbot.com/cli
+
+## Más funciones
 
 🧠 **Agent Studio (REPL interactivo, estilo Claude Code)**
 ```bash

package/dist/commands/auth/browser-login.js

@@ -0,0 +1,121 @@
+import { Command } from 'commander';
+import os from 'node:os';
+import axios from 'axios';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { apiBaseUrl, appBaseUrl, saveCredentials } from '../../utils/credentials.js';
+import { openBrowser } from '../../utils/open-browser.js';
+import { createSpinner, theme } from '../../utils/ui.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples, addNotes } from '../../utils/help.js';
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/**
+ * Ejecuta el login por navegador y guarda la sesión. Lo usan `plazbot login` y el
+ * wizard `plazbot whatsapp setup` cuando no hay sesión. Lanza Error si falla o vence.
+ */
+export async function runBrowserLogin(options) {
+    let zone;
+    if (options.zone) {
+        zone = options.zone.toUpperCase() === 'EU' ? 'EU' : 'LA';
+    }
+    else {
+        const answer = await inquirer.prompt([{
+                type: 'list',
+                name: 'zone',
+                message: '¿Dónde creaste tu cuenta de Plazbot?',
+                choices: [
+                    { name: 'América  (appla.plazbot.com)', value: 'LA' },
+                    { name: 'Europa   (appeu.plazbot.com)', value: 'EU' },
+                ],
+            }]);
+        zone = answer.zone;
+    }
+    const dev = options.dev ?? false;
+    const api = apiBaseUrl(zone, dev);
+    let data;
+    try {
+        const start = await axios.post(`${api}/api/cli/auth/start`, { deviceName: os.hostname() });
+        data = start.data?.success ? start.data?.data : undefined;
+    }
+    catch (error) {
+        throw new Error(`No se pudo conectar con Plazbot (${axios.isAxiosError(error) ? error.message : 'error de red'}).`);
+    }
+    if (!data?.deviceCode) {
+        throw new Error('No se pudo iniciar el login. Inténtalo de nuevo en unos segundos.');
+    }
+    const url = `${appBaseUrl(zone, dev)}/cli/authorize?code=${encodeURIComponent(data.userCode)}&r=${encodeURIComponent(data.requestToken)}`;
+    console.log();
+    console.log(`  Tu código de verificación: ${chalk.bold.hex('#22d3ee')(data.userCode)}`);
+    console.log();
+    const opened = options.browser !== false && openBrowser(url);
+    console.log(theme.muted(opened
+        ? '  Abrimos tu navegador. Si no se abrió, entra a:'
+        : '  Abre este link en tu navegador:'));
+    console.log(`  ${chalk.underline(url)}`);
+    console.log();
+    const spinner = createSpinner('Esperando la autorización en el navegador... (Ctrl+C para cancelar)');
+    spinner.start();
+    const deadline = Date.now() + data.expiresIn * 1000;
+    const intervalMs = Math.max(2, data.interval || 3) * 1000;
+    let approved = null;
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        try {
+            const poll = await axios.post(`${api}/api/cli/auth/poll`, { deviceCode: data.deviceCode });
+            if (poll.data?.data?.status === 'approved') {
+                approved = poll.data.data;
+                break;
+            }
+        }
+        catch {
+            // error de red puntual: seguir intentando hasta el vencimiento
+        }
+    }
+    if (!approved) {
+        spinner.fail('El código venció sin autorización.');
+        throw new Error('Ejecuta plazbot login otra vez.');
+    }
+    const credentials = {
+        apiKey: approved.apiKey,
+        workspace: approved.workspaceId,
+        workspaceName: approved.workspaceName,
+        zone: approved.zone || zone,
+        userId: approved.userId,
+        email: approved.email,
+        source: 'login',
+    };
+    await saveCredentials(credentials);
+    spinner.succeed(`Sesión iniciada en ${chalk.bold(approved.workspaceName || approved.workspaceId)} (${credentials.zone})`);
+    if (approved.email)
+        console.log(theme.muted(`  Cuenta: ${approved.email}`));
+    console.log();
+    return credentials;
+}
+export const browserLoginCommand = new Command('login')
+    .description('Inicia sesión desde el navegador (sin copiar API key)')
+    .option('-z, --zone <zone>', 'Zona donde creaste tu cuenta: LA (América) o EU (Europa)')
+    .option('--no-browser', 'No abrir el navegador automáticamente (solo mostrar el link)')
+    .option('--dev', 'Usar el entorno de desarrollo local', false)
+    .action(async (options) => {
+    try {
+        await runBrowserLogin(options);
+        console.log(theme.muted('  Siguiente paso:'));
+        console.log(`    ${chalk.cyan('plazbot whatsapp setup')}     ${theme.muted('Conecta WhatsApp y envía tu primer mensaje')}`);
+        console.log(`    ${chalk.cyan('plazbot whoami')}             ${theme.muted('Ver la sesión activa')}`);
+        console.log(`    ${chalk.cyan('plazbot workspace list')}     ${theme.muted('Cambiar de workspace')}`);
+        console.log();
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : 'Error desconocido');
+        process.exit(1);
+    }
+});
+addExamples(browserLoginCommand, [
+    { description: 'Iniciar sesión (pregunta la zona y abre el navegador)', command: 'plazbot login' },
+    { description: 'Cuenta en Europa', command: 'plazbot login --zone EU' },
+    { description: 'Servidor sin navegador: solo muestra el link', command: 'plazbot login --no-browser' },
+]);
+addNotes(browserLoginCommand, [
+    'En CI o servidores usa variables de entorno: PLAZBOT_API_KEY, PLAZBOT_WORKSPACE_ID y PLAZBOT_ZONE.',
+    'Puedes revocar el acceso en el panel: Configuración → Developer.',
+]);

package/dist/commands/auth/index.js

@@ -1,8 +1,12 @@
 import { loginCommand } from './login.js';
+import { browserLoginCommand } from './browser-login.js';
 import { logoutCommand } from './logout.js';
 import { statusCommand } from './status.js';
+import { workspaceCommand } from './workspace.js';
 export const authCommands = [
+    browserLoginCommand,
     loginCommand,
     logoutCommand,
-    statusCommand
+    statusCommand,
+    workspaceCommand
 ];

package/dist/commands/auth/login.js

@@ -3,7 +3,7 @@ import { saveCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
 import { addExamples } from '../../utils/help.js';
 export const loginCommand = new Command('init')
-    .description('Save the API key and user email locally')
+    .description('Guarda una API key manualmente (para CI; lo normal es plazbot login)')
     .option('-e, --email <email>', 'User email (optional)')
     .requiredOption('-k, --api-key <apiKey>', 'User API key')
     .requiredOption('-w, --workspace <workspace>', 'Workspace ID')
@@ -12,8 +12,6 @@ export const loginCommand = new Command('init')
     .option('--dev', 'Use development environment', false)
     .action(async (options) => {
     try {
-        // Limpiar la pantalla
-        console.clear();
         // Banner de bienvenida
         logger.info('┌' + '─'.repeat(70) + '┐');
         logger.info('│' + ' Welcome to Plazbot CLI'.padEnd(69) + '│');

package/dist/commands/auth/logout.js

@@ -2,8 +2,9 @@ import { Command } from 'commander';
 import { removeCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
 import { addExamples } from '../../utils/help.js';
-export const logoutCommand = new Command('finish')
-    .description('Remove the local user configuration')
+export const logoutCommand = new Command('logout')
+    .alias('finish')
+    .description('Cierra la sesión local (borra ~/.plazbot/config.json)')
     .option('--dev', 'Use development environment', false)
     .action(async (options) => {
     try {
@@ -21,5 +22,5 @@ export const logoutCommand = new Command('finish')
 });
 addExamples(logoutCommand, [
     { description: 'Remove the local configuration (~/.plazbot/config.json)',
-        command: 'plazbot finish' },
+        command: 'plazbot logout' },
 ]);

package/dist/commands/auth/status.js

@@ -3,25 +3,28 @@ import { getStoredCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
 import { addExamples } from '../../utils/help.js';
 import { section } from '../../utils/ui.js';
-export const statusCommand = new Command('status')
-    .description('Show the active session (workspace, email, zone)')
+export const statusCommand = new Command('whoami')
+    .alias('status')
+    .description('Muestra la sesión activa (cuenta, workspace, zona)')
     .action(async () => {
     try {
         const credentials = await getStoredCredentials();
         console.log(section('Active session'));
         if (credentials.email)
             logger.label('Email', credentials.email);
-        logger.label('Workspace', credentials.workspace);
+        logger.label('Workspace', credentials.workspaceName ? `${credentials.workspaceName} (${credentials.workspace})` : credentials.workspace);
         logger.label('Zone', credentials.zone === 'LA' ? 'Latin America (LA)' : 'Europe (EU)');
         logger.label('API', credentials.zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com');
+        if (credentials.source === 'env')
+            logger.label('Origen', 'variables de entorno (PLAZBOT_API_KEY)');
         console.log();
     }
     catch {
-        logger.error("No active session. Run 'plazbot init' to sign in.");
+        logger.error("No hay una sesión activa. Ejecuta 'plazbot login' para iniciar sesión.");
         process.exit(1);
     }
 });
 addExamples(statusCommand, [
     { description: 'Show the active workspace, email and zone',
-        command: 'plazbot status' },
+        command: 'plazbot whoami' },
 ]);

package/dist/commands/auth/workspace.js

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import chalk from 'chalk';
+import { apiBaseUrl, getStoredCredentials, saveCredentials } from '../../utils/credentials.js';
+import { createSpinner, createTable, theme } from '../../utils/ui.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+async function fetchWorkspaces(dev) {
+    const creds = await getStoredCredentials();
+    if (!creds.userId) {
+        throw new Error("Esta sesión no tiene usuario asociado. Vuelve a iniciar sesión con 'plazbot login'.");
+    }
+    const res = await axios.get(`${apiBaseUrl(creds.zone, dev)}/api/workspace/workspaceByUserId/${encodeURIComponent(creds.userId)}`, {
+        headers: { Authorization: `Bearer ${creds.apiKey}`, 'x-workspace-id': creds.workspace },
+    });
+    return (Array.isArray(res.data) ? res.data : [])
+        .filter((w) => w.isInvitationAccepted && (w.state == 1 || !w.state) && w.data?.id)
+        .map((w) => ({ id: w.data.id, name: w.data.name || w.data.id }));
+}
+const listCommand = new Command('list')
+    .description('Lista tus workspaces')
+    .option('--json', 'Salida en JSON')
+    .option('--dev', 'Usar el entorno de desarrollo local', false)
+    .action(async (options) => {
+    try {
+        const creds = await getStoredCredentials();
+        const spinner = options.json ? null : createSpinner('Cargando workspaces...').start();
+        const items = await fetchWorkspaces(options.dev);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(items.map(w => ({ ...w, active: w.id === creds.workspace })), null, 2));
+            return;
+        }
+        console.log(createTable(['', 'Workspace', 'ID'], items.map(w => [
+            w.id === creds.workspace ? chalk.green('●') : ' ', w.name, theme.muted(w.id),
+        ])));
+        console.log(theme.muted(`  Cambia con: plazbot workspace use <id>`));
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : 'Error desconocido');
+        process.exit(1);
+    }
+});
+const useCommand = new Command('use')
+    .description('Cambia el workspace activo')
+    .argument('<workspaceId>', 'ID del workspace (ver plazbot workspace list)')
+    .option('--dev', 'Usar el entorno de desarrollo local', false)
+    .action(async (workspaceId, options) => {
+    try {
+        const creds = await getStoredCredentials();
+        if (creds.source === 'env') {
+            throw new Error('La sesión viene de variables de entorno; cambia PLAZBOT_WORKSPACE_ID.');
+        }
+        const items = await fetchWorkspaces(options.dev);
+        const target = items.find(w => w.id === workspaceId);
+        if (!target)
+            throw new Error(`No tienes acceso al workspace ${workspaceId}.`);
+        await saveCredentials({ ...creds, workspace: target.id, workspaceName: target.name });
+        logger.success(`Workspace activo: ${target.name}`);
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : 'Error desconocido');
+        process.exit(1);
+    }
+});
+export const workspaceCommand = new Command('workspace')
+    .description('Ver y cambiar el workspace activo')
+    .addCommand(listCommand)
+    .addCommand(useCommand);
+addExamples(workspaceCommand, [
+    { description: 'Listar tus workspaces', command: 'plazbot workspace list' },
+    { description: 'Cambiar el workspace activo', command: 'plazbot workspace use wok_AbcDef123' },
+]);

package/dist/commands/whatsapp/connect-flow.js

@@ -0,0 +1,137 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiBaseUrl } from '../../utils/credentials.js';
+import { openBrowser } from '../../utils/open-browser.js';
+/**
+ * Lógica compartida de conexión de números de WhatsApp (connect y setup).
+ * Mismo flujo que el panel: link de onboarding co.plzb.link → el usuario completa
+ * el registro de Meta → se detecta la integración nueva → se activa.
+ */
+export const ONBOARDING_SHORT_DOMAIN = 'https://co.plzb.link';
+// Las integraciones de WhatsApp API y WhatsApp Business (coexistencia) se guardan como "whatsapp";
+// "whatsapp_business" se incluye por compatibilidad (mismo criterio que Studio).
+const WHATSAPP_TYPES = ['whatsapp', 'whatsapp_business'];
+export function apiHeaders(creds) {
+    return {
+        Authorization: `Bearer ${creds.apiKey}`,
+        'x-workspace-id': creds.workspace,
+        'Content-Type': 'application/json',
+    };
+}
+export function integrationLabel(ig) {
+    const phone = ig.cellphoneNumberFormat || ig.cellphoneNumber || ig.id;
+    const name = ig.aliasName || ig.srcName;
+    return name ? `${name} (${phone})` : phone;
+}
+/** Todas las integraciones del workspace (lanza Error con mensaje claro si falla). */
+export async function fetchIntegrations(creds, dev = false) {
+    try {
+        const res = await axios.get(`${apiBaseUrl(creds.zone, dev)}/api/workspace/${creds.workspace}`, { headers: apiHeaders(creds) });
+        const ws = Array.isArray(res.data) ? res.data[0] : res.data;
+        return ws?.integrations || [];
+    }
+    catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 401) {
+            throw new Error("Tu sesión no es válida o fue revocada. Ejecuta 'plazbot login'.");
+        }
+        throw new Error('No se pudieron cargar las integraciones del workspace.');
+    }
+}
+export function whatsappNumbers(all) {
+    return all.filter(ig => WHATSAPP_TYPES.includes(ig.type));
+}
+/** Link corto de onboarding: reutiliza el vigente, regenera si venció o crea uno nuevo. */
+export async function getOnboardingLink(creds, business, dev = false) {
+    const base = apiBaseUrl(creds.zone, dev);
+    const headers = apiHeaders(creds);
+    const type = business ? 'whatsapp_business' : 'whatsapp';
+    let link = null;
+    try {
+        link = (await axios.get(`${base}/api/workspace/${creds.workspace}/onboarding-link`, { headers, params: { type } })).data?.data ?? null;
+    }
+    catch {
+        link = null;
+    }
+    if (link?.expiresAt && new Date(link.expiresAt) < new Date()) {
+        try {
+            link = (await axios.post(`${base}/api/workspace/${creds.workspace}/onboarding-link/regenerate`, { type }, { headers })).data?.data ?? null;
+        }
+        catch {
+            link = null;
+        }
+    }
+    if (!link?.token) {
+        try {
+            link = (await axios.post(`${base}/api/workspace/${creds.workspace}/onboarding-link`, { type }, { headers })).data?.data ?? null;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response?.status === 401) {
+                throw new Error("Tu sesión no es válida o fue revocada. Ejecuta 'plazbot login'.");
+            }
+            link = null;
+        }
+    }
+    if (!link?.token)
+        throw new Error('No se pudo obtener el link de conexión.');
+    return { url: link.shortUrl || `${ONBOARDING_SHORT_DOMAIN}/${link.token}`, expiresAt: link.expiresAt };
+}
+export async function activateIntegration(creds, integrationId, dev = false) {
+    try {
+        const res = await axios.post(`${apiBaseUrl(creds.zone, dev)}/api/workspace/${creds.workspace}/integrations/${integrationId}/activate`, { isActive: true, platformCode: 'whatsapp' }, { headers: apiHeaders(creds) });
+        return res.data?.success === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Muestra el link, abre el navegador y espera (hasta `timeoutMs`) a que aparezca un número
+ * nuevo en el workspace. Lo activa y lo devuelve; null si venció el tiempo.
+ */
+export async function connectNewNumber(creds, opts) {
+    const dev = opts.dev ?? false;
+    const before = await fetchIntegrations(creds, dev);
+    const prevIds = new Set(before.map(i => i.id));
+    const { url, expiresAt } = await getOnboardingLink(creds, opts.business, dev);
+    const opened = opts.openInBrowser !== false && openBrowser(url);
+    const border = chalk.hex('#25D366');
+    console.log();
+    console.log(border('  ┃ ') + chalk.bold(opened ? 'Abrimos el registro de Meta en tu navegador.' : 'Abre este link en tu navegador:'));
+    console.log(border('  ┃ ') + chalk.hex('#22d3ee').underline(url));
+    console.log(border('  ┃ ') + chalk.gray(opts.business
+        ? 'Inicia sesión con Facebook y vincula tu app WhatsApp Business escaneando el QR.'
+        : 'Inicia sesión con Facebook, elige o crea tu cuenta de WhatsApp Business y verifica el número.'));
+    if (expiresAt)
+        console.log(border('  ┃ ') + chalk.gray(`El link vence el ${new Date(expiresAt).toLocaleDateString('es-ES', { day: 'numeric', month: 'long' })}.`));
+    console.log();
+    const spinner = ora({ text: chalk.gray('Esperando la conexión... (Ctrl+C para cancelar)'), spinner: 'dots', color: 'cyan' }).start();
+    const intervalMs = 5000;
+    const deadline = Date.now() + (opts.timeoutMs ?? 10 * 60 * 1000);
+    const startedAt = Date.now();
+    while (Date.now() < deadline) {
+        await new Promise(r => setTimeout(r, intervalMs));
+        try {
+            const fresh = whatsappNumbers(await fetchIntegrations(creds, dev)).filter(ig => !prevIds.has(ig.id));
+            if (fresh.length > 0) {
+                const detected = fresh[0];
+                spinner.succeed(chalk.hex('#4ade80')(`Número detectado: ${integrationLabel(detected)}`));
+                const act = ora({ text: chalk.gray('Activando el número...'), spinner: 'dots', color: 'green' }).start();
+                if (await activateIntegration(creds, detected.id, dev)) {
+                    act.succeed(chalk.hex('#4ade80')('Número activo'));
+                    detected.isActive = 1;
+                }
+                else {
+                    act.warn(chalk.hex('#FFA726')('No se pudo activar automáticamente. Actívalo en el panel → Integraciones.'));
+                }
+                return detected;
+            }
+        }
+        catch {
+            // error puntual: seguir esperando
+        }
+        spinner.text = chalk.gray(`Esperando la conexión... ${Math.floor((Date.now() - startedAt) / 1000)}s (Ctrl+C para cancelar)`);
+    }
+    spinner.warn(chalk.hex('#FFA726')('No detectamos una conexión nueva a tiempo.'));
+    return null;
+}