plazbot-cli 0.4.0 → 0.5.0

package/dist/studio/slash/handlers.js

@@ -54,15 +54,18 @@ slashRegistry.register({
             for (const cmd of items) {
                 const usage = cmd.usage ?? `/${cmd.name}`;
                 const aliasPart = cmd.aliases?.length
-                    ? ` _(alias: ${cmd.aliases.map((a) => '/' + a).join(', ')})_`
+                    ? ` (${cmd.aliases.length > 1 ? 'aliases' : 'alias'}: ${cmd.aliases.map((a) => '`/' + a + '`').join(', ')})`
                     : '';
                 lines.push(`- \`${usage}\`${aliasPart} — ${cmd.description}`);
             }
             lines.push('');
         }
         lines.push('**Keyboard shortcuts**');
-        lines.push('- `Esc` — cancel the current stream');
-        lines.push('- `Ctrl+C` — exit Studio');
+        lines.push('- `Enter` — send the message');
+        lines.push('- `↑` / `↓` — browse your previous messages');
+        lines.push('- `Tab` or `→` — accept the gray suggestion from your history');
+        lines.push('- `Esc` — cancel the current response (or a pending channel connection)');
+        lines.push('- `Ctrl+C` — exit Studio immediately');
         lines.push('');
         lines.push('**Tip:** you can also speak naturally — e.g. _"list my agents"_, _"create a sales agent for WhatsApp"_ or _"connect this agent to WhatsApp Business"_.');
         useStudioStore.getState().pushSyntheticAssistant(lines.join('\n'));
@@ -72,7 +75,7 @@ slashRegistry.register({
 slashRegistry.register({
     name: 'clear',
     aliases: ['cls'],
-    description: 'Clear the conversation (keeps the loaded agent and token usage)',
+    description: 'Clear the message history and the input history (keeps the loaded agent and token usage)',
     category: 'session',
     handler() {
         useStudioStore.getState().clearMessages();
@@ -171,14 +174,14 @@ slashRegistry.register({
 slashRegistry.register({
     name: 'export',
     aliases: ['download'],
-    description: 'Export the current agent configuration to a JSON file on disk',
+    description: 'Write the loaded agent configuration as JSON to [path] (default: ./<agent-name>.json)',
     category: 'agent',
     usage: '/export [path]',
     async handler(parsed) {
         const store = useStudioStore.getState();
         const { agentConfig } = store;
         if (!agentConfig) {
-            store.pushSyntheticAssistant('No hay agente cargado. Crea o carga uno antes con `/load <id>`.', { error: true });
+            store.pushSyntheticAssistant('No agent configuration loaded. Create one first or use `/load <id>`.', { error: true });
             return { kind: 'noop' };
         }
         const cfg = agentConfig;
@@ -188,11 +191,11 @@ slashRegistry.register({
         const targetPath = resolve(process.cwd(), expandTilde(targetArg));
         try {
             await writeFile(targetPath, JSON.stringify(agentConfig, null, 2), 'utf-8');
-            store.pushSyntheticAssistant(`Agente exportado a \`${targetPath}\`.\n\nValídalo con: \`plazbot agent validate ${targetPath}\``);
+            store.pushSyntheticAssistant(`Agent configuration exported to \`${targetPath}\`.\n\nValidate it with: \`plazbot agent validate ${targetPath}\``);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            store.pushSyntheticAssistant(`No pude escribir el archivo: ${message}`, { error: true });
+            store.pushSyntheticAssistant(`Could not write the file: ${message}`, { error: true });
         }
         return { kind: 'noop' };
     },

package/dist/studio/state/store.js

@@ -64,7 +64,7 @@ export const useStudioStore = create((set, get) => ({
     },
     failAllRunningSteps(message) {
         set((s) => ({
-            steps: s.steps.map((x) => x.status === 'running' ? { ...x, status: 'error', errorMessage: message ?? 'Cancelado' } : x),
+            steps: s.steps.map((x) => x.status === 'running' ? { ...x, status: 'error', errorMessage: message ?? 'Cancelled' } : x),
         }));
     },
     setAgentConfig(cfg) {

package/dist/utils/agent-errors.js

@@ -9,35 +9,38 @@ export function describeAgentLoadError(error, agentId, credentials, context = {}
     const status = err?.response?.status;
     const workspace = context.workspaceOverride || credentials.workspace;
     const zone = context.zoneOverride || credentials.zone;
-    const envHint = context.dev ? ' (env: --dev / localhost:5090)' : '';
+    const envHint = context.dev ? ' (development environment, localhost:5090)' : '';
     if (status === 404) {
         return [
             `Agent "${agentId}" was not found in workspace ${workspace} (zone ${zone})${envHint}.`,
-            chalk.gray('  Verify the ID and active workspace:'),
-            chalk.gray('    plazbot status'),
+            chalk.gray('  Check the ID and the active workspace:'),
+            chalk.gray('    plazbot whoami'),
             chalk.gray('    plazbot agent list'),
-            chalk.gray('  If the agent lives in a different zone, re-init with the right one:'),
-            chalk.gray('    plazbot login'),
+            chalk.gray('  If the agent is in another workspace, switch to it:'),
+            chalk.gray('    plazbot workspace use <workspaceId>'),
+            chalk.gray('  If it is in another zone, sign in to that zone:'),
+            chalk.gray('    plazbot login --zone EU'),
         ].join('\n');
     }
     if (status === 401) {
         return [
-            'Authentication token rejected (401).',
-            chalk.gray('  Re-run: plazbot login'),
+            'Your session is invalid or expired (401).',
+            chalk.gray('  Sign in again: plazbot login'),
         ].join('\n');
     }
     if (status === 403) {
         return [
-            `No permissions to access agent "${agentId}" in workspace ${workspace}.`,
-            chalk.gray('  Confirm your user has access to that workspace.'),
+            `You do not have permission to access agent "${agentId}" in workspace ${workspace}.`,
+            chalk.gray('  Check the active workspace: plazbot whoami'),
+            chalk.gray('  Switch with: plazbot workspace use <workspaceId>'),
         ].join('\n');
     }
     if (status === 429) {
-        return 'Rate limit reached. Try again in a few seconds.';
+        return 'Too many requests. Try again in a few seconds.';
     }
     if (typeof status === 'number' && status >= 500) {
         return [
-            `Backend error (HTTP ${status})${envHint}.`,
+            `Plazbot API error (HTTP ${status})${envHint}.`,
             chalk.gray(`  ${err.response?.data?.message || err.message || ''}`).trimEnd(),
         ].join('\n');
     }

package/dist/utils/agent-patch.js

@@ -0,0 +1,60 @@
+// Partial agent updates. POST /api/agent/patch changes only the fields sent (each top-level
+// field replaces the stored one). With an API that doesn't have /patch yet (404 on the route),
+// it falls back to fetching the agent, applying the fields and sending the full document to
+// /api/agent/update, which replaces the whole agent.
+import { Agent } from 'plazbot';
+import { createApiClient } from './api.js';
+import { CliError } from './output.js';
+import { cleanAgentForExport } from '../commands/agent/export.js';
+function toCliError(data, status, agentId) {
+    if (status === 401)
+        return new CliError(data?.message || 'Your session is invalid or expired.', 'unauthorized', "Run 'plazbot login' to sign in again.");
+    if (status === 403)
+        return new CliError(data?.message || 'You do not have permission to update this agent.', 'forbidden', "Check the active workspace with 'plazbot whoami'.");
+    if (status === 404)
+        return new CliError(`Agent ${agentId} was not found in the active workspace.`, 'not_found', "Check the ID with 'plazbot agent list'.");
+    const errors = (Array.isArray(data?.errors) ? data.errors : [])
+        .map((err) => (typeof err === 'string' ? err : JSON.stringify(err)));
+    const base = data?.message || `Agent update failed (HTTP ${status}).`;
+    const message = errors.length
+        ? `${base.replace(/\.?$/, ':')}\n${errors.map((e, i) => `    ${i + 1}. ${e}`).join('\n')}`
+        : base;
+    return new CliError(message, 'update_failed', "Check the fields with 'plazbot agent validate <file>'.");
+}
+/**
+ * Applies `patch` to the agent. `current` (the stored agent) is only needed for the fallback;
+ * pass it when you already have it to avoid an extra request.
+ */
+export async function patchAgent(target, agentId, patch, current) {
+    const api = createApiClient(target);
+    const headers = { 'x-agent-id': agentId };
+    const res = await api.post('/api/agent/patch', patch, { headers, validateStatus: () => true });
+    const routeMissing = res.status === 404 && typeof res.data?.success !== 'boolean';
+    if (!routeMissing) {
+        if (!res.data?.success)
+            throw toCliError(res.data, res.status, agentId);
+        return;
+    }
+    // API without /patch: full-document update built from the stored agent
+    let stored = current;
+    if (!stored) {
+        const agent = new Agent({
+            workspaceId: target.workspace,
+            apiKey: target.apiKey,
+            zone: target.zone,
+            ...(target.dev && { customUrl: 'http://localhost:5090' }),
+        });
+        const response = await agent.getAgentById({ id: agentId });
+        stored = response?.agent || response?.data || response;
+        if (!stored || !stored.name)
+            throw toCliError(null, 404, agentId);
+    }
+    const payload = { ...cleanAgentForExport(stored), ...patch };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null)
+            delete payload[key];
+    }
+    const full = await api.post('/api/agent/update', payload, { headers, validateStatus: () => true });
+    if (!full.data?.success)
+        throw toCliError(full.data, full.status, agentId);
+}

package/dist/utils/banner.js

@@ -40,29 +40,33 @@ export async function showBanner() {
     const rightColumn = [];
     if (credentials) {
         rightColumn.push(chalk.bold.hex('#4CAF50')('Connected workspace'));
-        rightColumn.push(chalk.gray(`  ${credentials.workspace || 'N/A'}`));
+        rightColumn.push(chalk.gray(`  ${credentials.workspaceName || credentials.workspace || 'N/A'}`));
+        if (credentials.workspaceName && credentials.workspace)
+            rightColumn.push(chalk.gray(`  ${credentials.workspace}`));
         if (credentials.email)
             rightColumn.push(chalk.gray(`  ${credentials.email}`));
         rightColumn.push(chalk.gray(`  Zone: ${credentials.zone || 'N/A'}`));
         rightColumn.push('');
         rightColumn.push(chalk.hex('#4CAF50')('─'.repeat(35)));
         rightColumn.push('');
-        rightColumn.push(chalk.bold.hex('#4CAF50')('Comandos rápidos'));
+        rightColumn.push(chalk.bold.hex('#4CAF50')('Quick commands'));
         rightColumn.push(chalk.white('  plazbot whatsapp setup'));
         rightColumn.push(chalk.white('  plazbot whatsapp send-message'));
         rightColumn.push(chalk.white('  plazbot agent list'));
         rightColumn.push(chalk.white('  plazbot studio'));
+        rightColumn.push(chalk.white('  plazbot --help'));
     }
     else {
-        rightColumn.push(chalk.bold.hex('#FFA726')('Sin sesión'));
+        rightColumn.push(chalk.bold.hex('#FFA726')('Not signed in'));
         rightColumn.push('');
-        rightColumn.push(chalk.bold.hex('#4CAF50')('Empieza aquí'));
+        rightColumn.push(chalk.bold.hex('#4CAF50')('Get started'));
         rightColumn.push(chalk.white('  plazbot login'));
         rightColumn.push(chalk.white('  plazbot whatsapp setup'));
+        rightColumn.push(chalk.white('  plazbot --help'));
         rightColumn.push('');
         rightColumn.push(chalk.hex('#4CAF50')('─'.repeat(35)));
         rightColumn.push('');
-        rightColumn.push(chalk.bold.hex('#4CAF50')('Documentación'));
+        rightColumn.push(chalk.bold.hex('#4CAF50')('Documentation'));
         rightColumn.push(chalk.gray('  https://developers.plazbot.com'));
     }
     // Imprimir título

package/dist/utils/confirm.js

@@ -0,0 +1,31 @@
+// Confirmation prompts with a Stripe-style escape hatch for scripts: -y, --yes (alias --confirm).
+import { Option } from 'commander';
+import inquirer from 'inquirer';
+import { CliError, isJsonMode } from './output.js';
+/** Adds `-y, --yes` (plus hidden `--confirm` and legacy `-f, --force`) to a command. */
+export function addYesOption(cmd) {
+    return cmd
+        .addOption(new Option('-y, --yes', 'Skip the confirmation prompt (for scripts and CI)').default(false))
+        .addOption(new Option('--confirm', 'Alias of --yes').hideHelp())
+        .addOption(new Option('-f, --force', 'Alias of --yes').hideHelp());
+}
+/**
+ * Asks for confirmation unless --yes was passed. Without an interactive terminal
+ * (CI, pipes, --json) it fails instead of waiting for input forever.
+ * Returns false when the user answers no.
+ */
+export async function confirmAction(message, options) {
+    if (options.yes || options.confirm || options.force)
+        return true;
+    if (!process.stdin.isTTY || isJsonMode()) {
+        throw new CliError('This action needs confirmation and there is no interactive terminal.', 'confirmation_required', 'Re-run the command with --yes to confirm.');
+    }
+    const { ok } = await inquirer.prompt([{ type: 'confirm', name: 'ok', message, default: false }]);
+    return ok;
+}
+/** Fails when an interactive prompt would be needed but there is no terminal. */
+export function requireInteractive(what, hint) {
+    if (!process.stdin.isTTY || isJsonMode()) {
+        throw new CliError(`${what} needs an interactive terminal.`, 'interactive_required', hint);
+    }
+}

package/dist/utils/credentials.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { CliError } from './output.js';
 const configDir = path.join(os.homedir(), '.plazbot');
 const configPath = path.join(configDir, 'config.json');
 /**
@@ -24,12 +25,13 @@ export async function getStoredCredentials() {
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
         if (!config.apiKey || !config.workspace || !config.zone) {
-            throw new Error('Credenciales incompletas');
+            throw new Error('Incomplete credentials');
         }
-        return config;
+        // Older versions of `plazbot init` stored the zone as typed (e.g. "eu").
+        return { ...config, zone: parseZone(config.zone) ?? 'LA' };
     }
     catch (error) {
-        throw new Error("No hay una sesión activa. Ejecuta 'plazbot login' para iniciar sesión.");
+        throw new CliError('You are not signed in.', 'not_signed_in', "Run 'plazbot login', or set PLAZBOT_API_KEY and PLAZBOT_WORKSPACE_ID.");
     }
 }
 export async function saveCredentials(credentials) {
@@ -41,6 +43,14 @@ export async function saveCredentials(credentials) {
 export async function removeCredentials() {
     await fs.rm(configPath, { force: true });
 }
+/**
+ * Normalizes a zone flag (case-insensitive) to 'LA' | 'EU'. Returns null when invalid,
+ * so each command can report it in its own way.
+ */
+export function parseZone(value) {
+    const zone = (value ?? '').trim().toUpperCase();
+    return zone === 'LA' || zone === 'EU' ? zone : null;
+}
 export function apiBaseUrl(zone, dev = false) {
     if (dev)
         return 'http://localhost:5090';

package/dist/utils/logger.js

@@ -1,39 +1,42 @@
 import chalk from 'chalk';
+import { isJsonMode } from './output.js';
+// In --json mode human output goes to stderr so stdout stays pure JSON.
+const out = (message) => (isJsonMode() ? console.error : console.log)(message);
 export const logger = {
     info: (message) => {
-        console.log(chalk.white(message));
+        out(chalk.white(message));
     },
     success: (message) => {
-        console.log(chalk.hex('#66BB6A')(`\n  ${message}`));
+        out(chalk.hex('#66BB6A')(`\n  ${message}`));
     },
     warning: (message) => {
-        console.log(chalk.hex('#FFA726')(`\n  ${message}`));
+        out(chalk.hex('#FFA726')(`\n  ${message}`));
     },
     error: (error) => {
         const message = error instanceof Error ? error.message : error;
         console.error(chalk.hex('#EF5350')(`\n  Error: ${message}`));
     },
     divider: (length = 50) => {
-        console.log(chalk.gray('─'.repeat(length)));
+        out(chalk.gray('─'.repeat(length)));
     },
     doubleDivider: (length = 50) => {
-        console.log(chalk.gray('═'.repeat(length)));
+        out(chalk.gray('═'.repeat(length)));
     },
     label: (key, value) => {
-        console.log(`  ${chalk.gray(key + ':')} ${chalk.white(value)}`);
+        out(`  ${chalk.gray(key + ':')} ${chalk.white(value)}`);
     },
     title: (text) => {
-        console.log(chalk.bold.hex('#4CAF50')(`\n  ${text}`));
-        console.log(chalk.gray('  ' + '─'.repeat(40)));
+        out(chalk.bold.hex('#4CAF50')(`\n  ${text}`));
+        out(chalk.gray('  ' + '─'.repeat(40)));
     },
     dim: (message) => {
-        console.log(chalk.gray(`  ${message}`));
+        out(chalk.gray(`  ${message}`));
     },
     json: (data) => {
         const formatted = JSON.stringify(data, null, 2)
             .split('\n')
             .map(line => '  ' + line)
             .join('\n');
-        console.log(chalk.gray(formatted));
+        out(chalk.gray(formatted));
     }
 };

package/dist/utils/output.js

@@ -0,0 +1,78 @@
+// Shared output conventions for every command:
+// - `--json`: stdout carries only JSON; human output (logger, spinners) goes to stderr.
+// - Errors: a readable message (or {"error": {...}} on stderr in JSON mode) and exit code 1.
+import chalk from 'chalk';
+import { Option } from 'commander';
+let jsonMode = false;
+export function setJsonMode(value) {
+    jsonMode = value;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+/** Standard `--json` option. */
+export function jsonOption(description = 'Output machine-readable JSON') {
+    return new Option('--json', description).default(false);
+}
+/** Prints a JSON document to stdout. */
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+/** An expected failure with a message meant for the user (no stack trace). */
+export class CliError extends Error {
+    code;
+    hint;
+    constructor(message, code = 'error', hint) {
+        super(message);
+        this.code = code;
+        this.hint = hint;
+        this.name = 'CliError';
+    }
+}
+/** Turns any thrown value (CliError, SDK error, axios error) into a message and a status. */
+export function describeError(error) {
+    if (error instanceof CliError) {
+        return { message: error.message, code: error.code, hint: error.hint };
+    }
+    const err = error;
+    const status = err?.response?.status;
+    const data = err?.response?.data;
+    const apiMessage = typeof data === 'string' ? data : data?.message || data?.error;
+    if (status === 401) {
+        return { message: apiMessage || 'Your session is invalid or expired.', code: 'unauthorized', status, hint: "Run 'plazbot login' to sign in again." };
+    }
+    if (status === 403) {
+        return { message: apiMessage || 'You do not have permission for this action.', code: 'forbidden', status, hint: "Check the active workspace with 'plazbot whoami'." };
+    }
+    if (status === 404) {
+        return { message: apiMessage || 'Resource not found.', code: 'not_found', status, hint: "Check the ID and the active workspace ('plazbot whoami')." };
+    }
+    if (status === 429) {
+        return { message: apiMessage || 'Too many requests.', code: 'rate_limited', status, hint: 'Wait a few seconds and try again.' };
+    }
+    if (status && status >= 500) {
+        return { message: apiMessage || `Plazbot API error (HTTP ${status}).`, code: 'api_error', status, hint: 'Try again in a few minutes.' };
+    }
+    if (status) {
+        return { message: apiMessage || `Request failed (HTTP ${status}).`, code: 'request_failed', status };
+    }
+    if (err?.code === 'ENOTFOUND' || err?.code === 'ECONNREFUSED' || err?.code === 'ETIMEDOUT' || err?.code === 'ECONNRESET') {
+        return { message: `Could not reach the Plazbot API (${err.code}).`, code: 'network_error', hint: 'Check your internet connection.' };
+    }
+    const message = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+    return { message: message || 'Unknown error', code: 'error' };
+}
+/** Prints the error in the active format and exits with code 1. */
+export function fail(error) {
+    const { message, code, status, hint } = describeError(error);
+    if (jsonMode) {
+        process.stderr.write(JSON.stringify({ error: { message, code, ...(status && { status }), ...(hint && { hint }) } }) + '\n');
+    }
+    else {
+        console.error(chalk.hex('#EF5350')(`\n  Error: ${message}`));
+        if (hint)
+            console.error(chalk.gray(`  ${hint}`));
+        console.error();
+    }
+    process.exit(1);
+}

package/dist/utils/phone.js

@@ -0,0 +1,22 @@
+// Phone numbers: every command takes the number as -p, --phone and accepts any common
+// international format (+51 912 345 678, 0051-912345678, 51912345678).
+import { Option } from 'commander';
+import { CliError } from './output.js';
+export function phoneOption(description = 'WhatsApp number in international format, e.g. +51912345678') {
+    return new Option('-p, --phone <number>', description);
+}
+/** Returns the number as digits with country code (E.164 without '+'), or throws. */
+export function normalizePhone(input, flag = '--phone') {
+    if (!input || !String(input).trim()) {
+        throw new CliError(`Missing phone number.`, 'missing_phone', `Pass it with ${flag}, e.g. ${flag} +51912345678`);
+    }
+    let digits = String(input).trim().replace(/[\s().-]/g, '');
+    if (digits.startsWith('+'))
+        digits = digits.slice(1);
+    else if (digits.startsWith('00'))
+        digits = digits.slice(2);
+    if (!/^\d{8,15}$/.test(digits)) {
+        throw new CliError(`Invalid phone number "${input}".`, 'invalid_phone', 'Use the international format with country code, e.g. +51912345678 or 51912345678.');
+    }
+    return digits;
+}

package/dist/utils/ui.js

@@ -1,7 +1,8 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import Table from 'cli-table3';
-// Colores del tema Plazbot
+import { isJsonMode } from './output.js';
+// Plazbot theme colors
 export const theme = {
     primary: chalk.hex('#4CAF50'),
     secondary: chalk.hex('#2196F3'),
@@ -19,9 +20,11 @@ export function createSpinner(text) {
         text: theme.muted(text),
         spinner: 'dots',
         color: 'green',
+        // ora writes to stderr; in --json mode it stays silent
+        isSilent: isJsonMode(),
     });
 }
-// Tabla formateada
+// Formatted table
 export function createTable(headers, rows) {
     const table = new Table({
         head: headers.map(h => theme.bold.hex('#4CAF50')(h)),
@@ -39,7 +42,7 @@ export function createTable(headers, rows) {
     rows.forEach(row => table.push(row));
     return table.toString();
 }
-// Box simple
+// Simple box
 export function box(content, title) {
     const lines = content.split('\n');
     const maxLen = Math.max(...lines.map(l => stripAnsi(l).length), title ? stripAnsi(title).length + 4 : 0);
@@ -58,14 +61,14 @@ export function box(content, title) {
     result += theme.muted('  └' + '─'.repeat(width) + '┘');
     return result;
 }
-// Strip ANSI codes para calcular longitud real
+// Strip ANSI codes to measure the visible length
 function stripAnsi(str) {
     return str.replace(/\x1b\[[0-9;]*m/g, '');
 }
-// Formato de fecha legible
+// Readable date
 export function formatDate(date) {
     const d = new Date(date);
-    return d.toLocaleDateString('es-ES', {
+    return d.toLocaleDateString('en-US', {
         year: 'numeric',
         month: 'short',
         day: 'numeric',
@@ -76,18 +79,18 @@ export function formatDate(date) {
 // Status badge
 export function statusBadge(enabled) {
     return enabled
-        ? theme.success('● activo')
-        : theme.error('○ inactivo');
+        ? theme.success('● active')
+        : theme.error('○ inactive');
 }
-// Key-value pair formateado
+// Formatted key-value pair
 export function kvPair(key, value) {
     return `  ${theme.muted(key + ':')} ${value}`;
 }
-// Sección con título
+// Section with title
 export function section(title) {
     return '\n' + theme.bold.hex('#4CAF50')(`  ${title}`) + '\n' + theme.muted('  ' + '─'.repeat(40));
 }
-// Progress bar simple
+// Simple progress bar
 export function progressBar(current, total, width = 30) {
     const percent = Math.round((current / total) * 100);
     const filled = Math.round((current / total) * width);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "plazbot-cli",
-  "version": "0.4.0",
-  "description": "CLI oficial de Plazbot: WhatsApp for Developers, agentes IA y workers desde tu terminal",
+  "version": "0.5.0",
+  "description": "Official Plazbot CLI: WhatsApp for Developers, AI agents and workers from your terminal",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {