plazbot-cli 0.4.1 → 0.5.0

package/dist/commands/workers/secret.js

@@ -1,156 +1,232 @@
 import { Command } from 'commander';
+import inquirer from 'inquirer';
 import { getStoredCredentials } from '../../utils/credentials.js';
 import { createApiClient } from '../../utils/api.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { createSpinner, createTable, theme, formatDate } from '../../utils/ui.js';
-import readline from 'readline';
+import { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
+import { addYesOption, confirmAction } from '../../utils/confirm.js';
+const SECRET_KEY_RE = /^[A-Z][A-Z0-9_]*$/;
+function validateKey(key) {
+    if (!SECRET_KEY_RE.test(key)) {
+        throw new CliError(`Invalid secret name "${key}". Use UPPER_SNAKE_CASE: uppercase letters, digits and underscores, starting with a letter.`, 'invalid_secret_key', 'Example: STRIPE_API_KEY');
+    }
+}
+function apiFor(options, credentials) {
+    return createApiClient({
+        apiKey: credentials.apiKey,
+        workspace: credentials.workspace,
+        zone: credentials.zone,
+        dev: options.dev,
+    });
+}
+// Reads the whole stdin (piped input) and strips the trailing newline added by echo.
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8').replace(/\r?\n$/, '');
+}
+async function resolveSecretValue(key, value) {
+    if (value !== undefined)
+        return value;
+    if (!process.stdin.isTTY) {
+        const piped = await readStdin();
+        if (!piped) {
+            throw new CliError('No secret value received on stdin.', 'missing_secret_value', `Example: echo "$VALUE" | plazbot workers secret set ${key}`);
+        }
+        return piped;
+    }
+    if (isJsonMode()) {
+        throw new CliError('The secret value is required in --json mode.', 'missing_secret_value', `Pipe it through stdin: echo "$VALUE" | plazbot workers secret set ${key} --json`);
+    }
+    const { secret } = await inquirer.prompt([{
+            type: 'password',
+            name: 'secret',
+            message: `Value for ${key}:`,
+            mask: '*',
+            validate: (v) => v.length > 0 || 'The value cannot be empty',
+        }]);
+    return secret;
+}
 // ── Comando padre: secret ───────────────────────────────────────────────────
 export const secretCommand = new Command('secret')
-    .description('Manage worker secrets (environment variables)')
+    .description('Manage worker secrets (available as plz.env.KEY)')
     .addCommand(secretSetCommand())
     .addCommand(secretListCommand())
     .addCommand(secretRemoveCommand());
 addExamples(secretCommand, [
-    { description: 'Save (or update) an API key as a secret',
-        command: 'plazbot workers secret set STRIPE_API_KEY sk_live_xxxxx' },
-    { description: 'List every secret (values are hidden)',
+    { description: 'Save a secret (prompts for the value with hidden input)',
+        command: 'plazbot workers secret set STRIPE_API_KEY' },
+    { description: 'Save a secret from stdin (scripts/CI)',
+        command: 'echo "$STRIPE_KEY" | plazbot workers secret set STRIPE_API_KEY' },
+    { description: 'List every secret (values are never shown)',
         command: 'plazbot workers secret list' },
-    { description: 'Delete a secret with confirmation prompt',
-        command: 'plazbot workers secret remove STRIPE_API_KEY' },
     { description: 'Delete a secret without confirmation',
-        command: 'plazbot workers secret remove STRIPE_API_KEY -f' },
+        command: 'plazbot workers secret remove STRIPE_API_KEY --yes' },
 ]);
 // ── secret set ──────────────────────────────────────────────────────────────
 function secretSetCommand() {
-    return new Command('set')
+    const cmd = new Command('set')
         .description('Create or update a secret')
-        .argument('<key>', 'Secret name (e.g.: STRIPE_API_KEY)')
-        .argument('<value>', 'Secret value')
+        .argument('<key>', 'Secret name in UPPER_SNAKE_CASE (e.g. STRIPE_API_KEY)')
+        .argument('[value]', 'Secret value (omit it to be prompted, or pipe it through stdin)')
+        .addOption(jsonOption())
         .option('--dev', 'Use development environment', false)
         .action(async (key, value, options) => {
         try {
+            validateKey(key);
+            const secretValue = await resolveSecretValue(key, value);
+            if (!secretValue.trim()) {
+                throw new CliError('The secret value cannot be empty.', 'missing_secret_value');
+            }
             const credentials = await getStoredCredentials();
-            const api = createApiClient({
-                apiKey: credentials.apiKey,
-                workspace: credentials.workspace,
-                zone: credentials.zone,
-                dev: options.dev,
-            });
+            const api = apiFor(options, credentials);
             const spinner = createSpinner(`Saving secret "${key}"...`);
             spinner.start();
-            await api.put('/api/worker/secrets', { key, value });
+            try {
+                const response = await api.put('/api/worker/secrets', { key, value: secretValue });
+                if (response.data?.success === false) {
+                    throw new CliError(response.data.message || `Could not save secret "${key}".`, 'secret_save_failed');
+                }
+            }
+            catch (error) {
+                spinner.stop();
+                throw error;
+            }
             spinner.succeed(`Secret "${key}" saved`);
-            logger.dim(`  Available in your workers as plz.env.${key}`);
+            if (isJsonMode()) {
+                printJson({ key, saved: true });
+                return;
+            }
+            logger.dim(`Available in your workers as plz.env.${key}`);
+            if (value !== undefined) {
+                logger.dim('Tip: omit the value (or pipe it through stdin) to keep it out of your shell history.');
+            }
             console.log();
             if (options.dev) {
                 logger.warning('Environment: development');
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error(message);
-            process.exit(1);
+            fail(error);
         }
     });
+    addExamples(cmd, [
+        { description: 'Prompt for the value with hidden input (recommended)',
+            command: 'plazbot workers secret set STRIPE_API_KEY' },
+        { description: 'Read the value from stdin',
+            command: 'echo "$STRIPE_KEY" | plazbot workers secret set STRIPE_API_KEY' },
+        { description: 'Read the value from a file',
+            command: 'plazbot workers secret set GOOGLE_CREDENTIALS < ./service-account.json' },
+        { description: 'Pass the value inline (stays in your shell history)',
+            command: 'plazbot workers secret set API_BASE_URL https://api.example.com' },
+    ]);
+    addNotes(cmd, [
+        'Passing the value as an argument leaks it to your shell history and process list; prefer the prompt or stdin.',
+        'Setting an existing key overwrites its value. Values are encrypted and never shown again.',
+    ]);
+    return cmd;
 }
 // ── secret list ─────────────────────────────────────────────────────────────
 function secretListCommand() {
-    return new Command('list')
-        .description('List all secrets in the workspace (without showing values)')
+    const cmd = new Command('list')
+        .description('List the secrets in the workspace (values are never shown)')
+        .addOption(jsonOption())
         .option('--dev', 'Use development environment', false)
         .action(async (options) => {
         try {
             const credentials = await getStoredCredentials();
-            const api = createApiClient({
-                apiKey: credentials.apiKey,
-                workspace: credentials.workspace,
-                zone: credentials.zone,
-                dev: options.dev,
-            });
+            const api = apiFor(options, credentials);
             const spinner = createSpinner('Fetching secrets...');
             spinner.start();
-            const response = await api.get('/api/worker/secrets');
-            const secrets = response.data;
-            spinner.stop();
-            if (!secrets || secrets.length === 0) {
+            let secrets;
+            try {
+                const response = await api.get('/api/worker/secrets');
+                secrets = Array.isArray(response.data) ? response.data : [];
+            }
+            finally {
+                spinner.stop();
+            }
+            if (isJsonMode()) {
+                printJson(secrets.map(s => ({ key: s.key, updatedAt: s.updatedAt ?? null })));
+                return;
+            }
+            if (secrets.length === 0) {
                 logger.info('\n  No secrets configured');
-                logger.dim('  Add one: plazbot workers secret set MY_KEY my_value');
+                logger.dim('Add one: plazbot workers secret set MY_KEY');
                 console.log();
                 return;
             }
             logger.title(`Secrets (${secrets.length})`);
-            const rows = secrets.map(s => [
-                s.key,
-                theme.muted('••••••••'),
-                formatDate(s.updatedAt),
-            ]);
-            console.log(createTable(['Key', 'Value', 'Updated'], rows));
+            console.log(createTable(['Key', 'Value', 'Updated'], secrets.map(s => [s.key, theme.muted('••••••••'), s.updatedAt ? formatDate(s.updatedAt) : '—'])));
             console.log();
             if (options.dev) {
                 logger.warning('Environment: development');
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error(message);
-            process.exit(1);
+            fail(error);
         }
     });
+    addExamples(cmd, [
+        { description: 'List every secret',
+            command: 'plazbot workers secret list' },
+        { description: 'List secret names as JSON',
+            command: 'plazbot workers secret list --json' },
+    ]);
+    return cmd;
 }
 // ── secret remove ───────────────────────────────────────────────────────────
 function secretRemoveCommand() {
-    return new Command('remove')
+    const cmd = new Command('remove')
         .description('Delete a secret from the workspace')
         .argument('<key>', 'Name of the secret to delete')
-        .option('-f, --force', 'Delete without confirmation', false)
-        .option('--dev', 'Use development environment', false)
-        .action(async (key, options) => {
+        .addOption(jsonOption())
+        .option('--dev', 'Use development environment', false);
+    addYesOption(cmd);
+    cmd.action(async (key, options) => {
         try {
-            const credentials = await getStoredCredentials();
-            const api = createApiClient({
-                apiKey: credentials.apiKey,
-                workspace: credentials.workspace,
-                zone: credentials.zone,
-                dev: options.dev,
-            });
-            if (!options.force) {
-                const confirmed = await askConfirmation(`  Delete secret "${key}"? (y/N): `);
-                if (!confirmed) {
-                    logger.info('\n  Operation cancelled');
-                    process.exit(0);
-                }
+            const ok = await confirmAction(`Delete secret "${key}"? Workers using plz.env.${key} will stop working.`, options);
+            if (!ok) {
+                logger.dim('Aborted.');
+                process.exit(1);
             }
+            const credentials = await getStoredCredentials();
+            const api = apiFor(options, credentials);
             const spinner = createSpinner(`Deleting secret "${key}"...`);
             spinner.start();
-            await api.delete(`/api/worker/secrets/${encodeURIComponent(key)}`);
+            try {
+                await api.delete(`/api/worker/secrets/${encodeURIComponent(key)}`);
+            }
+            catch (error) {
+                spinner.stop();
+                if (error?.response?.status === 404) {
+                    throw new CliError(`Secret "${key}" not found.`, 'not_found', 'List your secrets with: plazbot workers secret list');
+                }
+                throw error;
+            }
             spinner.succeed(`Secret "${key}" deleted`);
+            if (isJsonMode()) {
+                printJson({ key, removed: true });
+                return;
+            }
             console.log();
             if (options.dev) {
                 logger.warning('Environment: development');
             }
         }
         catch (error) {
-            if (error.response?.status === 404) {
-                logger.error(`Secret "${key}" not found`);
-            }
-            else {
-                const message = error instanceof Error ? error.message : 'Unknown error';
-                logger.error(message);
-            }
-            process.exit(1);
+            fail(error);
         }
     });
-}
-function askConfirmation(question) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y');
-        });
-    });
+    addExamples(cmd, [
+        { description: 'Delete a secret (asks for confirmation)',
+            command: 'plazbot workers secret remove STRIPE_API_KEY' },
+        { description: 'Delete without confirmation (scripts/CI)',
+            command: 'plazbot workers secret remove STRIPE_API_KEY --yes' },
+    ]);
+    return cmd;
 }

package/dist/commands/workers/test.js

@@ -1,19 +1,24 @@
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
+import fs from 'fs/promises';
 import { getStoredCredentials } from '../../utils/credentials.js';
 import { createApiClient } from '../../utils/api.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { createSpinner, theme } from '../../utils/ui.js';
+import { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
 export const testCommand = new Command('test')
-    .description('Run a worker manually to test it')
+    .description('Run a deployed worker manually to test it')
     .argument('<name>', 'Name of the worker to run')
-    .option('-p, --payload <json>', 'JSON payload for the worker (e.g.: \'{"product":"iPhone"}\')')
-    .option('-t, --type <type>', 'Worker type (tool, worker, sync, schedule, webhook)')
-    .option('--contact <id>', 'Contact ID (context for tools)')
-    .option('--agent <id>', 'Agent ID (context for tools)')
+    .option('-d, --data <json>', 'Input data as a JSON object, or @file.json to read it from a file')
+    .addOption(new Option('--payload <json>', 'Alias of --data').hideHelp())
+    .addOption(new Option('-t, --type <type>', 'Worker type').choices(['tool', 'worker', 'sync', 'schedule', 'webhook']))
+    .option('--contact <id>', 'Contact ID passed as context (tools)')
+    .option('--agent <id>', 'Agent ID passed as context (tools)')
+    .addOption(jsonOption('Print the raw execution result as JSON'))
     .option('--dev', 'Use development environment', false)
     .action(async (name, options) => {
     try {
+        const payload = await parseData(options.data ?? options.payload);
         const credentials = await getStoredCredentials();
         const api = createApiClient({
             apiKey: credentials.apiKey,
@@ -21,51 +26,53 @@ export const testCommand = new Command('test')
             zone: credentials.zone,
             dev: options.dev,
         });
-        // Parsear payload
-        let payload = {};
-        if (options.payload) {
-            try {
-                payload = JSON.parse(options.payload);
-            }
-            catch {
-                logger.error('Payload is not valid JSON');
-                logger.dim('Example: --payload \'{"product":"iPhone 15"}\'');
-                process.exit(1);
-            }
-        }
         logger.title(`Running worker "${name}"`);
-        console.log();
         if (Object.keys(payload).length > 0) {
-            logger.label('Payload', JSON.stringify(payload, null, 2));
-            console.log();
+            logger.label('Data', JSON.stringify(payload));
         }
         const spinner = createSpinner('Running...');
         spinner.start();
-        const response = await api.post('/api/worker/execute', {
-            workerName: name,
-            type: options.type,
-            payload,
-            triggerSource: 'cli-test',
-            agentId: options.agent,
-            contactId: options.contact,
-        });
-        const data = response.data;
-        const duration = data.duration ?? 0;
-        spinner.stop();
-        if (data.success) {
+        let data;
+        try {
+            const response = await api.post('/api/worker/execute', {
+                workerName: name,
+                type: options.type,
+                payload,
+                triggerSource: 'cli-test',
+                agentId: options.agent,
+                contactId: options.contact,
+            });
+            data = response.data;
+        }
+        catch (error) {
+            if (error?.response?.status === 404) {
+                throw new CliError(`Worker "${name}" not found or inactive.`, 'not_found', 'Check it is deployed with: plazbot workers list');
+            }
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+        const ok = data?.success === true;
+        if (isJsonMode()) {
+            printJson(data);
+            if (!ok)
+                process.exit(1);
+            return;
+        }
+        const duration = data?.duration ?? 0;
+        if (ok) {
             logger.success(`Completed in ${duration}ms`);
         }
         else {
             logger.error(`Failed in ${duration}ms`);
         }
-        console.log();
-        // Mostrar resultado
-        if (data.result !== undefined && data.result !== null) {
+        if (data?.result !== undefined && data?.result !== null) {
+            console.log();
             logger.label('Result', '');
             const result = data.result;
             // Si es un ToolResponse, mostrar formateado
             if (typeof result === 'object' && 'result' in result) {
-                console.log();
                 logger.label('  result', theme.success(String(result.result)));
                 if (result.data) {
                     logger.label('  data', JSON.stringify(result.data, null, 2));
@@ -74,44 +81,85 @@ export const testCommand = new Command('test')
                     logger.label('  actions', '');
                     for (const action of result.actions) {
                         const a = action;
-                        logger.dim(`    - ${a.type}: ${a.value}${a.code ? ` (${a.code})` : ''}`);
+                        logger.dim(`  - ${a.type}: ${a.value}${a.code ? ` (${a.code})` : ''}`);
                     }
                 }
             }
             else {
-                // Resultado generico
                 console.log(JSON.stringify(result, null, 2));
             }
         }
-        // Mostrar error si hubo
-        if (data.error) {
+        const errorMessage = data?.error || (!ok ? data?.message : undefined);
+        if (errorMessage) {
             console.log();
-            logger.label('Error', theme.error(data.error));
+            logger.label('Error', theme.error(errorMessage));
+        }
+        if (Array.isArray(data?.errors) && data.errors.length > 0) {
+            data.errors.forEach(e => logger.dim(`- ${typeof e === 'string' ? e : JSON.stringify(e)}`));
         }
         console.log();
         if (options.dev) {
             logger.warning('Environment: development');
         }
+        if (!ok)
+            process.exit(1);
     }
     catch (error) {
-        if (error.response?.status === 404) {
-            logger.error(`Worker "${name}" not found or inactive`);
-            logger.dim('Verify the worker is deployed with: plazbot workers list');
-        }
-        else {
-            const message = error.response?.data?.message || error.message || 'Unknown error';
-            logger.error(message);
-        }
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(testCommand, [
-    { description: 'Run a worker without payload',
-        command: 'plazbot workers test my-tool' },
-    { description: 'Run a worker with a JSON payload',
-        command: 'plazbot workers test get-stock -p \'{"product":"iPhone 15"}\'' },
-    { description: 'Run a tool with contact and agent context',
-        command: 'plazbot workers test my-tool --contact ctc_AbcDef123 --agent agt_AbcDef123' },
-    { description: 'Run against the local backend',
-        command: 'plazbot workers test my-tool --dev' },
+    { description: 'Run a worker without input data',
+        command: 'plazbot workers test get-stock' },
+    { description: 'Run a worker with JSON data',
+        command: 'plazbot workers test get-stock -d \'{"product":"iPhone 15"}\'' },
+    { description: 'Read the input data from a file',
+        command: 'plazbot workers test sync-orders -d @./payload.json' },
+    { description: 'Run a tool with contact and agent context, raw JSON output',
+        command: 'plazbot workers test get-stock --contact ctc_AbcDef123 --agent age_AbcDef123 --json' },
 ]);
+addNotes(testCommand, [
+    'The worker must be deployed first (plazbot workers deploy). Executions are logged with source "cli-test".',
+    'Exits with code 1 when the execution fails (success: false).',
+]);
+// Parses --data: inline JSON, @file.json, or @- for stdin. Must be a JSON object.
+async function parseData(raw) {
+    if (raw === undefined || raw === '')
+        return {};
+    let text = raw;
+    let source = '--data';
+    if (raw.startsWith('@')) {
+        const file = raw.slice(1);
+        if (!file) {
+            throw new CliError('Missing file name after "@".', 'invalid_data', 'Example: -d @./payload.json');
+        }
+        if (file === '-') {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            text = Buffer.concat(chunks).toString('utf-8');
+            source = 'stdin';
+        }
+        else {
+            try {
+                text = await fs.readFile(file, 'utf-8');
+            }
+            catch {
+                throw new CliError(`Could not read data file: ${file}.`, 'file_not_found', 'Check the path after "@".');
+            }
+            source = file;
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? ` (${error.message})` : '';
+        throw new CliError(`Invalid JSON in ${source}${detail}.`, 'invalid_json', 'Example: -d \'{"product":"iPhone 15"}\' or -d @./payload.json');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new CliError(`The data in ${source} must be a JSON object.`, 'invalid_data', 'Example: -d \'{"product":"iPhone 15"}\'');
+    }
+    return parsed;
+}