plazbot-cli 0.4.1 → 0.5.0

package/dist/commands/whatsapp/broadcast.js

@@ -1,100 +1,192 @@
 import { Command } from 'commander';
-import { Message } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials.js';
+import fs from 'fs/promises';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { theme, section, progressBar } from '../../utils/ui.js';
-import fs from 'fs/promises';
+import { jsonOption, isJsonMode, printJson, fail, CliError, describeError } from '../../utils/output.js';
+import { addYesOption, confirmAction } from '../../utils/confirm.js';
+import { normalizePhone } from '../../utils/phone.js';
+import { ensureApiSuccess, getMessageClient, parseVariables } from './shared.js';
+/**
+ * Plain list of numbers: one per line, or separated by commas/semicolons.
+ * Ignores blank lines, `#` comments and a first header line that isn't a number.
+ */
+export function parsePhoneList(content) {
+    const phones = [];
+    const seen = new Set();
+    const invalid = [];
+    let duplicates = 0;
+    let header;
+    let first = true;
+    content.replace(/^/, '').split(/\r?\n/).forEach((rawLine, idx) => {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            return;
+        for (const piece of line.split(/[,;\t]/)) {
+            const entry = piece.trim().replace(/^["']|["']$/g, '').trim();
+            if (!entry)
+                continue;
+            try {
+                const phone = normalizePhone(entry);
+                if (seen.has(phone))
+                    duplicates++;
+                else {
+                    seen.add(phone);
+                    phones.push(phone);
+                }
+            }
+            catch (error) {
+                if (first && /[a-z]/i.test(entry)) {
+                    header = line; // e.g. "phone" or "phone,name": skip the whole line
+                    first = false;
+                    return;
+                }
+                invalid.push({ input: entry, line: idx + 1, error: describeError(error).message });
+            }
+            first = false;
+        }
+    });
+    return { phones, invalid, duplicates, header };
+}
 export const broadcastCommand = new Command('broadcast')
-    .description('Bulk send WhatsApp template messages')
-    .requiredOption('-t, --template <name>', 'Template name')
-    .requiredOption('--phones <file>', 'CSV file with phone numbers (one per line)')
-    .option('--var <vars...>', 'Body variables (format: name=value)')
-    .option('--delay <ms>', 'Delay between messages in ms', '1000')
-    .option('--dev', 'Use development environment', false)
-    .action(async (options) => {
+    .description('Send an approved WhatsApp template to a list of numbers')
+    .requiredOption('-t, --template <name>', 'Template name exactly as approved in Meta')
+    .requiredOption('--phones <file>', 'Text file with the numbers: one per line (commas or semicolons also work)')
+    .option('--var <name=value...>', 'Body variables sent to every recipient, name=value pairs')
+    .option('--delay <ms>', 'Pause between messages in milliseconds', '1000')
+    .option('--dry-run', 'Validate the list and show what would be sent, without sending', false)
+    .addOption(jsonOption())
+    .option('--dev', 'Use development environment', false);
+addYesOption(broadcastCommand);
+broadcastCommand.action(async (options) => {
     try {
-        const credentials = await getStoredCredentials();
-        const messageClient = new Message({
-            workspaceId: credentials.workspace,
-            apiKey: credentials.apiKey,
-            zone: credentials.zone,
-            ...(options.dev && { customUrl: "http://localhost:5090" })
-        });
-        // Leer archivo de telefonos
-        let phones;
+        const template = String(options.template || '').trim();
+        if (!template)
+            throw new CliError('Template name is required.', 'missing_template', 'Pass it with -t, --template <name>.');
+        const delay = Number(options.delay);
+        if (!Number.isFinite(delay) || delay < 0) {
+            throw new CliError(`Invalid --delay "${options.delay}".`, 'invalid_delay', 'Use a number of milliseconds, e.g. --delay 1000.');
+        }
+        const variablesBody = parseVariables(options.var, '--var');
+        let content;
         try {
-            const content = await fs.readFile(options.phones, 'utf-8');
-            phones = content.split('\n')
-                .map(line => line.trim())
-                .filter(line => line && !line.startsWith('#'));
+            content = await fs.readFile(options.phones, 'utf-8');
         }
         catch {
-            throw new Error(`Could not read file: ${options.phones}`);
+            throw new CliError(`Could not read file: ${options.phones}`, 'file_not_found', 'Check the path to your list of numbers.');
+        }
+        const list = parsePhoneList(content);
+        const json = isJsonMode();
+        if (!json) {
+            console.log(section(options.dryRun ? 'WhatsApp Broadcast (dry run)' : 'WhatsApp Broadcast'));
+            logger.label('Template', template);
+            logger.label('Recipients', String(list.phones.length));
+            if (variablesBody.length > 0)
+                logger.label('Variables', variablesBody.map(v => `${v.variable}=${v.value}`).join(', '));
+            logger.label('Delay', `${delay}ms`);
+            if (list.header)
+                logger.dim(`Skipped header line: "${list.header}"`);
+            if (list.duplicates > 0)
+                logger.dim(`Skipped ${list.duplicates} duplicate number(s).`);
+            if (list.invalid.length > 0) {
+                logger.warning(`${list.invalid.length} invalid entr${list.invalid.length === 1 ? 'y' : 'ies'} (not sent):`);
+                list.invalid.forEach(i => console.log(theme.error(`    ✖ line ${i.line}: "${i.input}"`)));
+            }
+            console.log();
         }
-        if (phones.length === 0) {
-            throw new Error('The file does not contain phone numbers');
+        if (list.phones.length === 0) {
+            throw new CliError('The file has no valid phone numbers.', 'no_recipients', 'Put one number per line in international format, e.g. +51912345678.');
         }
-        // Parsear variables
-        const variablesBody = parseVariables(options.var);
-        console.log(section('WhatsApp Broadcast'));
-        logger.label('Template', options.template);
-        logger.label('Recipients', String(phones.length));
-        logger.label('Delay', `${options.delay}ms`);
-        if (variablesBody.length > 0) {
-            logger.label('Variables', variablesBody.map(v => `${v.variable}=${v.value}`).join(', '));
+        if (options.dryRun) {
+            if (json) {
+                printJson({
+                    dryRun: true, template, variables: variablesBody,
+                    recipients: list.phones,
+                    summary: { total: list.phones.length, invalid: list.invalid, duplicates: list.duplicates },
+                });
+            }
+            else {
+                list.phones.forEach(p => console.log(`    ${theme.muted('•')} +${p}`));
+                logger.success(`Dry run: ${list.phones.length} message(s) would be sent with template "${template}". Nothing was sent.`);
+            }
+            if (list.invalid.length > 0)
+                process.exit(1);
+            return;
         }
-        console.log();
-        const delay = parseInt(options.delay) || 1000;
-        let sent = 0;
-        let failed = 0;
-        for (let i = 0; i < phones.length; i++) {
-            const phone = phones[i];
+        if (!(await confirmAction(`Send template "${template}" to ${list.phones.length} number(s)?`, options))) {
+            logger.dim('Aborted.');
+            process.exit(1);
+        }
+        const messageClient = await getMessageClient(options.dev);
+        const results = [];
+        const tty = !json && process.stdout.isTTY;
+        const total = list.phones.length;
+        const draw = (done) => {
+            if (tty)
+                process.stdout.write(`\r\x1b[2K  ${progressBar(done, total)}`);
+        };
+        draw(0);
+        for (let i = 0; i < total; i++) {
+            const phone = list.phones[i];
             try {
-                const params = {
-                    to: phone,
-                    template: options.template,
-                };
+                const params = { to: phone, template };
                 if (variablesBody.length > 0)
                     params.variablesBody = variablesBody;
-                await messageClient.onConversation(params);
-                sent++;
-            }
-            catch {
-                failed++;
-                console.log(theme.error(`  ✖ Failed: ${phone}`));
+                const response = await messageClient.onConversation(params);
+                ensureApiSuccess(response, 'Not sent');
+                results.push({ phone, status: 'sent' });
             }
-            // Progress
-            console.log(`  ${progressBar(i + 1, phones.length)}`);
-            // Rate limiting
-            if (i < phones.length - 1) {
-                await new Promise(resolve => setTimeout(resolve, delay));
+            catch (error) {
+                const msg = describeError(error).message;
+                results.push({ phone, status: 'failed', error: msg });
+                if (!json) {
+                    if (tty)
+                        process.stdout.write('\r\x1b[2K');
+                    console.log(theme.error(`  ✖ +${phone}: ${msg}`));
+                }
             }
+            draw(i + 1);
+            if (i < total - 1 && delay > 0)
+                await new Promise(r => setTimeout(r, delay));
         }
-        console.log(section('Result'));
-        logger.label('Sent', theme.success(String(sent)));
-        logger.label('Failed', failed > 0 ? theme.error(String(failed)) : '0');
-        logger.label('Total', String(phones.length));
+        if (tty)
+            process.stdout.write('\n');
+        const sent = results.filter(r => r.status === 'sent').length;
+        const failed = total - sent;
+        if (json) {
+            printJson({
+                template, results,
+                summary: { total, sent, failed, invalid: list.invalid, duplicates: list.duplicates },
+            });
+        }
+        else {
+            console.log(section('Result'));
+            logger.label('Sent', theme.success(String(sent)));
+            logger.label('Failed', failed > 0 ? theme.error(String(failed)) : '0');
+            if (list.invalid.length > 0)
+                logger.label('Invalid (skipped)', theme.error(String(list.invalid.length)));
+            logger.label('Total', String(total));
+            console.log();
+        }
+        if (failed > 0 || list.invalid.length > 0)
+            process.exit(1);
     }
     catch (error) {
-        const message = error?.message || 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(broadcastCommand, [
-    { description: 'Broadcast a template to a phone list (default 1s delay)',
-        command: 'plazbot whatsapp broadcast -t welcome --phones ./phones.csv' },
-    { description: 'Broadcast with body variables',
-        command: 'plazbot whatsapp broadcast -t promo --phones ./contacts.csv --var amount=20 code=PROMO20' },
-    { description: 'Slow broadcast (3s delay) to avoid rate limits',
-        command: 'plazbot whatsapp broadcast -t reminder --phones ./list.csv --delay 3000' },
+    { description: 'Check the list first: validates numbers, sends nothing',
+        command: 'plazbot whatsapp broadcast -t welcome --phones ./numbers.txt --dry-run' },
+    { description: 'Send a template to every number (asks for confirmation)',
+        command: 'plazbot whatsapp broadcast -t welcome --phones ./numbers.txt' },
+    { description: 'Same body variables for everyone, 3s between messages',
+        command: 'plazbot whatsapp broadcast -t promo --phones ./numbers.txt --var amount=20 code=PROMO20 --delay 3000' },
+    { description: 'Unattended run with per-number results as JSON',
+        command: 'plazbot whatsapp broadcast -t reminder --phones ./numbers.txt --yes --json > results.json' },
+]);
+addNotes(broadcastCommand, [
+    'The file is a plain list, e.g. "+51912345678" on each line (commas or semicolons also work). Blank lines, # comments and a header line are ignored; duplicates are sent once.',
+    'Invalid numbers are listed and skipped. The command exits with code 1 if any number was invalid or any send failed.',
+    'Variables are the same for every recipient. Templates can be sent outside the 24h window.',
 ]);
-function parseVariables(vars) {
-    if (!vars)
-        return [];
-    return vars.map(v => {
-        const [variable, ...rest] = v.split('=');
-        return { variable: variable.trim(), value: rest.join('=').trim() };
-    }).filter(v => v.variable && v.value);
-}

package/dist/commands/whatsapp/channels.js

@@ -1,92 +1,194 @@
 import { Command } from 'commander';
-import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { createSpinner, createTable, theme, section, statusBadge } from '../../utils/ui.js';
+import { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
+import { addYesOption, confirmAction } from '../../utils/confirm.js';
+import { phoneOption, normalizePhone } from '../../utils/phone.js';
+import { fetchFullAgent, getAgentClient, phoneDigits, updateAgentMerged } from './shared.js';
+const agentIdOf = (a) => String(a?.id || a?._id || '');
+const whatsappKeys = (a) => (Array.isArray(a?.channels) ? a.channels : [])
+    .filter((c) => c?.channel === 'whatsapp' && c?.key)
+    .map((c) => String(c.key));
+const hasNumber = (a, phone) => whatsappKeys(a).some(k => phoneDigits(k) === phone);
+// ── channels ──────────────────────────────────────────────────────────────────
 export const channelsCommand = new Command('channels')
-    .description('List agents with assigned WhatsApp channels')
+    .description('List agents that answer on a WhatsApp number')
+    .addOption(jsonOption())
     .option('--dev', 'Use development environment', false)
     .action(async (options) => {
     try {
-        const credentials = await getStoredCredentials();
-        const agent = new Agent({
-            workspaceId: credentials.workspace,
-            apiKey: credentials.apiKey,
-            zone: credentials.zone,
-            ...(options.dev && { customUrl: "http://localhost:5090" })
-        });
-        const spinner = createSpinner('Loading channels...');
-        spinner.start();
-        const agents = await agent.getAgents();
-        spinner.stop();
+        const { agent } = await getAgentClient(options.dev);
+        const spinner = createSpinner('Loading channels...').start();
+        let agents;
+        try {
+            agents = (await agent.getAgents()) || [];
+        }
+        finally {
+            spinner.stop();
+        }
+        const rows = agents
+            .filter(a => whatsappKeys(a).length > 0)
+            .map(a => ({
+            agentId: agentIdOf(a),
+            name: String(a.name || ''),
+            phones: whatsappKeys(a).map(phoneDigits),
+            enabled: a.enable !== false,
+        }));
+        if (isJsonMode()) {
+            printJson(rows);
+            return;
+        }
         console.log(section('WhatsApp Channels'));
-        const whatsappAgents = (agents || []).filter((a) => a.channels && a.channels.some((c) => c.channel === 'whatsapp'));
-        if (whatsappAgents.length === 0) {
-            console.log(theme.muted('\n  No agents with WhatsApp configured'));
-            console.log(theme.muted('  Use the wizard: plazbot agent create\n'));
+        if (rows.length === 0) {
+            console.log(theme.muted('\n  No agents have a WhatsApp number assigned yet.'));
+            console.log(theme.muted('  Assign one: plazbot whatsapp assign -p +51912345678 -a <agentId>\n'));
             return;
         }
-        const rows = whatsappAgents.map((a) => {
-            const waChannel = a.channels.find((c) => c.channel === 'whatsapp');
-            return [
-                a.id || a._id,
-                a.name,
-                waChannel?.key || 'N/A',
-                statusBadge(a.enable !== false),
-            ];
-        });
-        console.log(createTable(['Agent ID', 'Name', 'WhatsApp Number', 'Status'], rows));
+        console.log(createTable(['Agent ID', 'Name', 'WhatsApp number', 'Status'], rows.map(r => [r.agentId, r.name, r.phones.map(p => `+${p}`).join(', '), statusBadge(r.enabled)])));
+        // Same number on several agents: warn, only one should answer.
+        const owners = new Map();
+        rows.forEach(r => r.phones.forEach(p => owners.set(p, [...(owners.get(p) || []), r.name || r.agentId])));
+        for (const [p, names] of owners) {
+            if (names.length > 1) {
+                logger.warning(`+${p} is assigned to ${names.length} agents (${names.join(', ')}). Fix it with: plazbot whatsapp assign -p +${p} -a <agentId>`);
+            }
+        }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(channelsCommand, [
-    { description: 'List agents that have a WhatsApp number assigned',
+    { description: 'List agents with a WhatsApp number assigned',
         command: 'plazbot whatsapp channels' },
+    { description: 'Machine-readable list',
+        command: 'plazbot whatsapp channels --json' },
 ]);
 export const assignCommand = new Command('assign')
-    .description('Assign an agent to a WhatsApp number')
-    .argument('<phone>', 'WhatsApp number')
-    .argument('<agentId>', 'Agent ID')
-    .option('--dev', 'Use development environment', false)
-    .action(async (phone, agentId, options) => {
+    .description('Make an agent answer a WhatsApp number (moves it from any other agent)')
+    .addOption(phoneOption('WhatsApp number in international format, e.g. +51912345678'))
+    .option('-a, --agent <agentId>', 'Agent that will answer the number (e.g. age_AbcDef123)')
+    .argument('[phone]', 'Legacy positional form of --phone')
+    .argument('[agentId]', 'Legacy positional form of --agent')
+    .addOption(jsonOption())
+    .option('--dev', 'Use development environment', false);
+addYesOption(assignCommand);
+assignCommand.action(async (posPhone, posAgent, options) => {
     try {
-        const credentials = await getStoredCredentials();
-        const agent = new Agent({
-            workspaceId: credentials.workspace,
-            apiKey: credentials.apiKey,
-            zone: credentials.zone,
-            ...(options.dev && { customUrl: "http://localhost:5090" })
-        });
-        const spinner = createSpinner('Loading agent...');
-        spinner.start();
-        const agentData = await agent.getAgentById({ id: agentId });
-        spinner.stop();
-        const channels = agentData.channels || [];
-        // Verificar si ya tiene este canal
-        const existing = channels.findIndex((c) => c.channel === 'whatsapp' && c.key === phone);
-        if (existing >= 0) {
-            logger.warning('This number is already assigned to this agent');
+        // `assign -p <phone> <agentId>`: the first positional is the agent.
+        if (options.phone && posPhone && !posAgent) {
+            posAgent = posPhone;
+            posPhone = undefined;
+        }
+        const phone = normalizePhone(options.phone ?? posPhone);
+        const agentId = String(options.agent ?? posAgent ?? '').trim();
+        if (!agentId) {
+            throw new CliError('Missing agent ID.', 'missing_agent', "Pass it with -a, --agent <agentId> (see 'plazbot agent list').");
+        }
+        const { agent, credentials } = await getAgentClient(options.dev);
+        const spinner = createSpinner('Loading agents...').start();
+        let target;
+        let others;
+        try {
+            target = await fetchFullAgent(agent, agentId);
+            const all = (await agent.getAgents()) || [];
+            others = all.filter(a => agentIdOf(a) && agentIdOf(a) !== agentId && hasNumber(a, phone));
+        }
+        finally {
+            spinner.stop();
+        }
+        const targetName = String(target.name || agentId);
+        const alreadyOnTarget = hasNumber(target, phone);
+        const removedFrom = others.map(a => ({ id: agentIdOf(a), name: String(a.name || '') }));
+        if (alreadyOnTarget && others.length === 0) {
+            if (isJsonMode()) {
+                printJson({ phone, agentId, agentName: targetName, assigned: true, changed: false, removedFrom: [] });
+            }
+            else {
+                logger.success(`+${phone} is already assigned to "${targetName}". Nothing to change.`);
+            }
             return;
         }
-        // Agregar canal
-        channels.push({ channel: 'whatsapp', key: phone, multianswer: false });
-        const updateSpinner = createSpinner('Assigning...');
-        updateSpinner.start();
-        await agent.updateAgent(agentId, { channels });
-        updateSpinner.succeed(`Agent "${agentData.name}" assigned to WhatsApp ${phone}`);
+        if (others.length > 0) {
+            if (!isJsonMode()) {
+                console.log(theme.muted(`\n  +${phone} is currently assigned to:`));
+                removedFrom.forEach(a => console.log(`    ${theme.muted('•')} ${a.name || a.id} ${theme.muted(`(${a.id})`)}`));
+                console.log();
+            }
+            const question = `Move +${phone} to "${targetName}" and remove it from ${others.length} other agent${others.length > 1 ? 's' : ''}?`;
+            if (!(await confirmAction(question, options))) {
+                logger.dim('Aborted.');
+                process.exit(1);
+            }
+        }
+        // 1) Assign to the target first, so the number is never left without an agent.
+        if (!alreadyOnTarget) {
+            const s = createSpinner(`Assigning +${phone} to "${targetName}"...`).start();
+            try {
+                const channels = [
+                    ...(Array.isArray(target.channels) ? target.channels : []).map((c) => ({
+                        channel: c.channel || '', key: c.key || '', multianswer: c.multianswer || false,
+                    })),
+                    { channel: 'whatsapp', key: phone, multianswer: false },
+                ];
+                await updateAgentMerged(credentials, options.dev, agentId, target, { channels });
+            }
+            catch (error) {
+                s.stop();
+                throw error;
+            }
+            s.succeed(`+${phone} assigned to "${targetName}"`);
+        }
+        // 2) Remove the number from every other agent (full document, only channels change).
+        const failures = [];
+        for (const other of removedFrom) {
+            const s = createSpinner(`Removing +${phone} from "${other.name || other.id}"...`).start();
+            try {
+                const full = await fetchFullAgent(agent, other.id);
+                const channels = (Array.isArray(full.channels) ? full.channels : [])
+                    .filter((c) => !(c?.channel === 'whatsapp' && phoneDigits(c?.key) === phone));
+                await updateAgentMerged(credentials, options.dev, other.id, full, { channels });
+                s.succeed(`Removed +${phone} from "${other.name || other.id}"`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                s.fail(`Could not remove +${phone} from "${other.name || other.id}": ${msg}`);
+                failures.push({ ...other, error: msg });
+            }
+        }
+        const moved = removedFrom.filter(a => !failures.some(f => f.id === a.id));
+        if (isJsonMode()) {
+            printJson({
+                phone, agentId, agentName: targetName, assigned: true, changed: true,
+                removedFrom: moved,
+                ...(failures.length > 0 && { failed: failures }),
+            });
+        }
+        else if (moved.length > 0) {
+            logger.success(`+${phone} now answered by "${targetName}" (moved from ${moved.map(a => a.name || a.id).join(', ')}).`);
+        }
+        if (failures.length > 0) {
+            if (!isJsonMode()) {
+                logger.warning(`+${phone} is still assigned to ${failures.length} other agent(s). Remove it in the panel or re-run this command.`);
+            }
+            process.exit(1);
+        }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(assignCommand, [
-    { description: 'Assign a WhatsApp number to an agent',
-        command: 'plazbot whatsapp assign 51912345678 agt_AbcDef123' },
+    { description: 'Make an agent answer a number (moves it from any other agent)',
+        command: 'plazbot whatsapp assign -p +51912345678 -a age_AbcDef123' },
+    { description: 'Skip the confirmation when the number moves between agents',
+        command: 'plazbot whatsapp assign -p +51912345678 -a age_AbcDef123 --yes' },
+    { description: 'Legacy positional form (still supported)',
+        command: 'plazbot whatsapp assign 51912345678 age_AbcDef123' },
+]);
+addNotes(assignCommand, [
+    'A number is answered by one agent: if another agent has it, it is removed from that agent (asks for confirmation).',
+    'Only the channels of the affected agents change; the rest of their configuration is kept.',
+    'List the current assignments with plazbot whatsapp channels.',
 ]);