lua-cli 3.15.3 → 3.16.0

package/dist/commands/test.js

@@ -1,787 +0,0 @@
-/**
- * Test Command
- * Orchestrates the testing of individual tools in a local sandbox environment
- */
-import inquirer from 'inquirer';
-import { compileCommand } from './compile.js';
-import { printToolOutput } from './test-output.helpers.js';
-import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess, writeNextStep, writeHintBlock, } from '../utils/cli.js';
-import { initializeCommand } from '../utils/command-utils.js';
-import { executeTool, executeWebhook, executeJob, executePreProcessor, executePostProcessor, loadEnvironmentVariables, } from '../utils/sandbox.js';
-import { hasEnvFile } from '../utils/files.js';
-import { safePrompt } from '../utils/prompt-handler.js';
-import { loadManifest, loadArtifact, getPrimitivesByKind } from '../utils/artifact-loader.js';
-import { PrimitiveKind, } from '../compiler/types.js';
-import { trackEvent } from '../services/analytics.js';
-import { validateOrSuggest } from '../utils/aliases.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Shared Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Loads API key and agent ID, failing with clear error if not configured.
- */
-async function loadAuthOrFail() {
-    const { config, agentId, apiKey } = await initializeCommand({ showProgress: false });
-    return { apiKey, agentId, config };
-}
-/**
- * Prompts user to select a tool from the list.
- */
-async function promptToolSelection(tools) {
-    const toolChoices = tools.map((tool) => ({
-        name: tool.skillName
-            ? `${tool.name} (${tool.skillName}) - ${tool.description}`
-            : `${tool.name} - ${tool.description}`,
-        value: tool,
-    }));
-    const { selectedTool } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'selectedTool',
-            message: '🔧 Select a tool to test:',
-            choices: toolChoices,
-            pageSize: 10,
-        },
-    ]);
-    return selectedTool;
-}
-/**
- * Wraps execution with sandbox environment (env vars setup/teardown).
- */
-async function withSandboxEnv(fn) {
-    const envVars = loadEnvironmentVariables();
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        return await fn();
-    }
-    finally {
-        process.env = originalEnv;
-    }
-}
-/**
- * Parses JSON input, failing with formatted error message.
- */
-function parseJsonInputOrFail(inputJson, expectedFormat) {
-    try {
-        return JSON.parse(inputJson);
-    }
-    catch (error) {
-        console.error(`❌ Invalid JSON input: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        console.log(`Expected format: ${expectedFormat}`);
-        throw new Error(`Invalid JSON input: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-/**
- * Selects an entity by name (non-interactive) or prompts user (interactive).
- */
-async function selectEntityOrPrompt(options) {
-    const { items, entityName, entityType, idProperty, nameProperty, promptMessage, formatChoice, asJson } = options;
-    if (entityName) {
-        const selected = items.find((item) => item[idProperty] === entityName || item[nameProperty] === entityName);
-        if (!selected) {
-            console.error(`❌ ${entityType} "${entityName}" not found`);
-            throw new Error(`${entityType} "${entityName}" not found`);
-        }
-        progress(asJson ?? false, `✅ Selected ${entityType.toLowerCase()}: ${selected[nameProperty]}`);
-        return selected;
-    }
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selected',
-            message: promptMessage,
-            choices: items.map((item) => ({
-                name: formatChoice ? formatChoice(item) : `${item[nameProperty]}`,
-                value: item,
-            })),
-        },
-    ]);
-    if (!answer)
-        return null;
-    return answer.selected;
-}
-/**
- * Writes a progress message. In `--json` mode, routes to stderr so stdout
- * stays clean for the final JSON payload (allowing `| jq` etc.).
- */
-function progress(asJson, message) {
-    if (asJson) {
-        process.stderr.write('\r\x1b[K' + message + '\n');
-    }
-    else {
-        writeProgress(message);
-    }
-}
-/**
- * Writes a success message. In `--json` mode, routes to stderr (see `progress`).
- */
-function success(asJson, message) {
-    if (asJson) {
-        process.stderr.write('\r\x1b[K' + message + '\n');
-    }
-    else {
-        writeSuccess(message);
-    }
-}
-/**
- * Runs `compileCommand` with stdout redirected to stderr when `asJson` is
- * true, so compile output (which uses `console.log` and direct stdout writes)
- * doesn't pollute the JSON stream piped from `lua test --json`.
- */
-async function compileQuietly(asJson) {
-    if (!asJson) {
-        await compileCommand();
-        return;
-    }
-    const originalLog = console.log;
-    const originalInfo = console.info;
-    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-    // Re-route stdout writes to stderr for the duration of compile.
-    console.log = console.error;
-    console.info = console.error;
-    process.stdout.write = process.stderr.write.bind(process.stderr);
-    try {
-        await compileCommand();
-    }
-    finally {
-        console.log = originalLog;
-        console.info = originalInfo;
-        process.stdout.write = originalStdoutWrite;
-    }
-}
-/**
- * Handles execution errors with consistent formatting.
- */
-function handleExecutionError(error, entityType) {
-    console.error(`\n❌ ${entityType} execution failed:`);
-    console.error(error.message);
-    if (error.stack) {
-        console.error(error.stack);
-    }
-}
-/**
- * Extracts all tools from manifest (grouped by skill).
- */
-function extractToolsFromManifest(manifest) {
-    const tools = getPrimitivesByKind(manifest, PrimitiveKind.TOOL);
-    const skills = getPrimitivesByKind(manifest, PrimitiveKind.SKILL);
-    // Create a map of tool name to skill name
-    const toolToSkill = new Map();
-    for (const skill of skills) {
-        for (const toolName of skill.tools || []) {
-            toolToSkill.set(toolName, skill.name);
-        }
-    }
-    return tools.map((tool) => ({
-        ...tool,
-        id: tool.name,
-        skillName: toolToSkill.get(tool.name) || 'unknown',
-    }));
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Main Command
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Main test command - tests tools, webhooks, jobs, preprocessors, or postprocessors.
- */
-export async function testCommand(type, cmdObj) {
-    return withErrorHandling(async () => {
-        const entityName = cmdObj?.name || null;
-        const inputJson = cmdObj?.input || null;
-        const asJson = !!cmdObj?.json;
-        let selectedType;
-        if (type) {
-            type = validateOrSuggest('test.type', type);
-            selectedType = type;
-        }
-        else if (entityName) {
-            console.error(`❌ Type must be specified when using the --name option.`);
-            console.log('\nUsage:');
-            console.log('  lua test skill --name mySkill --input "{...}"      Test skill with JSON input');
-            console.log('  lua test webhook --name myWebhook --input "{...}"  Test webhook with JSON input');
-            throw new Error('Type must be specified when using the --name option.');
-        }
-        else {
-            const typeAnswer = await safePrompt([
-                {
-                    type: 'list',
-                    name: 'type',
-                    message: 'What would you like to test?',
-                    choices: [
-                        { name: '🛠️  Skill/Tool', value: 'skill' },
-                        { name: '🪝 Webhook', value: 'webhook' },
-                        { name: '⏰ Job', value: 'job' },
-                        { name: '📥 PreProcessor', value: 'preprocessor' },
-                        { name: '📤 PostProcessor', value: 'postprocessor' },
-                    ],
-                },
-            ]);
-            if (!typeAnswer) {
-                console.log('Test cancelled.');
-                return;
-            }
-            selectedType = typeAnswer.type;
-        }
-        switch (selectedType) {
-            case 'skill':
-                await testSkill(entityName, inputJson, asJson);
-                break;
-            case 'webhook':
-                await testWebhook(entityName, inputJson, asJson);
-                break;
-            case 'job':
-                await testJob(entityName, asJson);
-                break;
-            case 'preprocessor':
-                await testPreProcessor(entityName, inputJson, asJson);
-                break;
-            case 'postprocessor':
-                await testPostProcessor(entityName, inputJson, asJson);
-                break;
-        }
-        trackEvent('cli_test_executed', {
-            entity_type: selectedType,
-            entity_selected_by_name: !!entityName,
-            input_provided_json: !!inputJson,
-            non_interactive: !!type,
-        });
-    }, 'testing');
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Test Functions
-// ─────────────────────────────────────────────────────────────────────────────
-async function testSkill(entityName, inputJson, asJson = false) {
-    progress(asJson, '🧪 Testing Lua skill...');
-    progress(asJson, '📦 Compiling code first...');
-    await compileQuietly(asJson);
-    const manifest = loadManifest();
-    const allTools = extractToolsFromManifest(manifest);
-    const { apiKey, agentId } = await loadAuthOrFail();
-    if (hasEnvFile()) {
-        progress(asJson, `📄 Loaded environment variables from .env file`);
-    }
-    if (allTools.length === 0) {
-        console.error('❌ No tools found in compiled output.');
-        throw new Error('No tools found in compiled output.');
-    }
-    // Select tool
-    let selectedTool;
-    if (entityName) {
-        selectedTool = allTools.find((t) => t.id === entityName || t.name === entityName);
-        if (!selectedTool) {
-            console.error(`❌ Tool "${entityName}" not found`);
-            throw new Error('Tool');
-        }
-        progress(asJson, `✅ Selected tool: ${selectedTool.name}`);
-    }
-    else {
-        selectedTool = await promptToolSelection(allTools);
-        clearPromptLines(2);
-        progress(asJson, `✅ Selected tool: ${selectedTool.name}`);
-    }
-    // Get input values - for now, use simple prompts since schemas are in the bundled code
-    let inputValues = {};
-    if (inputJson) {
-        inputValues = parseJsonInputOrFail(inputJson, '{"param1": "value1", ...}');
-        progress(asJson, `Input: ${JSON.stringify(inputValues, null, 2)}`);
-    }
-    else {
-        // Simple input prompt since we don't have schema metadata at this point
-        const inputAnswer = await safePrompt([
-            { type: 'input', name: 'input', message: 'Enter input JSON (or empty for {}):', default: '{}' },
-        ]);
-        if (inputAnswer) {
-            try {
-                inputValues = JSON.parse(inputAnswer.input);
-            }
-            catch {
-                inputValues = {};
-            }
-        }
-    }
-    // Execute - load uncompressed code from dist-v2
-    progress(asJson, '\n🚀 Executing tool...');
-    const toolCode = loadArtifact(selectedTool, process.cwd());
-    await withSandboxEnv(async () => {
-        try {
-            const result = await executeTool({
-                toolCode,
-                inputs: inputValues,
-                apiKey,
-                agentId,
-                channel: 'dev',
-            });
-            success(asJson, '✅ Tool execution successful!');
-            printToolOutput('Tool', result, asJson);
-            // Skip post-action hints in --json mode so they don't pollute the JSON stream.
-            if (!asJson) {
-                writeNextStep({
-                    command: 'lua chat -e sandbox -m "test message"',
-                    rationale: 'to verify the tool integrates correctly with the agent',
-                    when: 'success',
-                });
-            }
-        }
-        catch (error) {
-            handleExecutionError(error, 'Tool');
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Tool ran locally — no server logs exist for this execution.',
-                    lines: [
-                        { label: 'Try with --json:', command: `lua test skill --name ${selectedTool.name} --json` },
-                        { label: 'Test in sandbox:', command: 'lua chat -e sandbox -m "trigger the tool"' },
-                    ],
-                    when: 'error',
-                });
-            }
-        }
-    });
-}
-async function testWebhook(entityName, inputJson, asJson = false) {
-    progress(asJson, '🪝 Testing webhook...');
-    progress(asJson, '📦 Compiling code first...');
-    await compileQuietly(asJson);
-    const { apiKey, agentId, config } = await loadAuthOrFail();
-    const manifest = loadManifest();
-    const webhooks = getPrimitivesByKind(manifest, PrimitiveKind.WEBHOOK);
-    if (webhooks.length === 0) {
-        console.error('❌ No webhooks found in compiled output.');
-        console.log('💡 Create a webhook using LuaWebhook in your code.');
-        return;
-    }
-    // Select webhook
-    const selectedWebhook = await selectEntityOrPrompt({
-        items: webhooks,
-        entityName,
-        entityType: 'Webhook',
-        idProperty: 'name',
-        nameProperty: 'name',
-        promptMessage: 'Select a webhook to test:',
-        formatChoice: (w) => `${w.name}`,
-        asJson,
-    });
-    if (!selectedWebhook) {
-        console.log('Test cancelled.');
-        return;
-    }
-    const webhookName = selectedWebhook.name;
-    // Get inputs
-    let query = {};
-    let headers = {};
-    let body = {};
-    if (inputJson) {
-        const input = parseJsonInputOrFail(inputJson, '{"query": {}, "headers": {}, "body": {}}');
-        query = input.query || {};
-        headers = input.headers || {};
-        body = input.body || {};
-    }
-    else {
-        // Simple JSON input prompts
-        const queryAnswer = await safePrompt([
-            { type: 'input', name: 'query', message: 'Enter query params JSON (or empty):', default: '{}' },
-        ]);
-        if (queryAnswer)
-            query = JSON.parse(queryAnswer.query || '{}');
-        const headersAnswer = await safePrompt([
-            { type: 'input', name: 'headers', message: 'Enter headers JSON (or empty):', default: '{}' },
-        ]);
-        if (headersAnswer)
-            headers = JSON.parse(headersAnswer.headers || '{}');
-        const bodyAnswer = await safePrompt([
-            { type: 'input', name: 'body', message: 'Enter body JSON (or empty):', default: '{}' },
-        ]);
-        if (bodyAnswer)
-            body = JSON.parse(bodyAnswer.body || '{}');
-    }
-    // Execute
-    progress(asJson, '\n🚀 Executing webhook...');
-    progress(asJson, `Query: ${JSON.stringify(query, null, 2)}`);
-    progress(asJson, `Headers: ${JSON.stringify(headers, null, 2)}`);
-    progress(asJson, `Body: ${JSON.stringify(body, null, 2)}`);
-    const webhookCode = loadArtifact(selectedWebhook, process.cwd());
-    await withSandboxEnv(async () => {
-        try {
-            const result = await executeWebhook({ webhookCode, query, headers, body, apiKey, agentId });
-            success(asJson, '\n✅ Webhook execution successful!');
-            printToolOutput('Webhook', result, asJson);
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Webhook works locally. To test in production:',
-                    lines: [
-                        { label: 'Trigger via HTTP:', command: 'curl -X POST <your webhook URL>' },
-                        { label: 'Inspect logs:', command: `lua logs --type webhook --name ${webhookName} --limit 5` },
-                    ],
-                    when: 'success',
-                });
-            }
-        }
-        catch (error) {
-            handleExecutionError(error, 'Webhook');
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Webhook ran locally — no server logs exist for this execution.',
-                    lines: [
-                        { label: 'Try with --json:', command: `lua test webhook --name ${webhookName} --json` },
-                        { label: 'Trigger in production:', command: 'curl -X POST <your webhook URL>' },
-                        { label: 'Then inspect:', command: `lua logs --type webhook --name ${webhookName} --limit 5` },
-                    ],
-                    when: 'error',
-                });
-            }
-        }
-    });
-}
-async function testJob(entityName, asJson = false) {
-    progress(asJson, '⏰ Testing job...');
-    progress(asJson, '📦 Compiling code first...');
-    await compileQuietly(asJson);
-    const { apiKey, agentId, config } = await loadAuthOrFail();
-    const manifest = loadManifest();
-    const jobs = getPrimitivesByKind(manifest, PrimitiveKind.JOB);
-    if (jobs.length === 0) {
-        console.error('❌ No jobs found in compiled output.');
-        console.log('💡 Create a job using LuaJob in your code.');
-        return;
-    }
-    // Select job
-    const selectedJob = await selectEntityOrPrompt({
-        items: jobs,
-        entityName,
-        entityType: 'Job',
-        idProperty: 'name',
-        nameProperty: 'name',
-        promptMessage: 'Select a job to test:',
-        formatChoice: (j) => `${j.name} - ${formatSchedule(j.schedule)}`,
-        asJson,
-    });
-    if (!selectedJob) {
-        console.log('Test cancelled.');
-        return;
-    }
-    const jobNameForHints = selectedJob.name;
-    // Get jobId from YAML config
-    const yamlJobs = config.jobs || [];
-    const yamlJob = yamlJobs.find((j) => j.name === selectedJob.name);
-    const jobId = yamlJob?.jobId || selectedJob.name;
-    // Execute
-    progress(asJson, `\n🚀 Executing job: ${selectedJob.name}...`);
-    progress(asJson, `📅 Schedule: ${formatSchedule(selectedJob.schedule)}`);
-    const jobCode = loadArtifact(selectedJob, process.cwd());
-    await withSandboxEnv(async () => {
-        try {
-            const result = await executeJob({
-                jobCode,
-                apiKey,
-                agentId,
-                jobData: {
-                    id: jobId,
-                    jobId: jobId,
-                    name: selectedJob.name,
-                    schedule: selectedJob.schedule,
-                    metadata: {},
-                },
-            });
-            success(asJson, '\n✅ Job execution successful!');
-            printToolOutput('Job', result, asJson);
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Job works locally. To test in production:',
-                    lines: [
-                        { label: 'Trigger now:', command: `lua jobs trigger --job-name ${jobNameForHints}` },
-                        { label: 'Inspect logs:', command: `lua logs --type job --name ${jobNameForHints} --limit 5` },
-                    ],
-                    when: 'success',
-                });
-            }
-        }
-        catch (error) {
-            handleExecutionError(error, 'Job');
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Job ran locally — no server logs exist for this execution.',
-                    lines: [
-                        { label: 'Try with --json:', command: `lua test job --name ${jobNameForHints} --json` },
-                        { label: 'Trigger in production:', command: `lua jobs trigger --job-name ${jobNameForHints}` },
-                        { label: 'Then inspect:', command: `lua logs --type job --name ${jobNameForHints} --limit 5` },
-                    ],
-                    when: 'error',
-                });
-            }
-        }
-    });
-}
-async function testPreProcessor(entityName, inputJson, asJson = false) {
-    progress(asJson, '📥 Testing preprocessor...');
-    progress(asJson, '📦 Compiling code first...');
-    await compileQuietly(asJson);
-    const manifest = loadManifest();
-    const preprocessors = getPrimitivesByKind(manifest, PrimitiveKind.PREPROCESSOR);
-    if (preprocessors.length === 0) {
-        console.error('❌ No preprocessors found in compiled output.');
-        return;
-    }
-    // Select preprocessor
-    const selected = await selectEntityOrPrompt({
-        items: preprocessors,
-        entityName,
-        entityType: 'Preprocessor',
-        idProperty: 'name',
-        nameProperty: 'name',
-        promptMessage: 'Select a preprocessor to test:',
-        formatChoice: (p) => `${p.name}`,
-        asJson,
-    });
-    if (!selected)
-        return;
-    const preprocessorName = selected.name;
-    // Get inputs
-    let message;
-    let channel;
-    if (inputJson) {
-        const input = parseJsonInputOrFail(inputJson, '{"message": "text", "channel": "channel_name"}');
-        message = input.message || 'Hello, I need help with my order';
-        channel = input.channel || 'web';
-    }
-    else {
-        const messageAnswer = await safePrompt([
-            { type: 'input', name: 'message', message: 'Enter test message:', default: 'Hello, I need help with my order' },
-        ]);
-        if (!messageAnswer)
-            return;
-        message = messageAnswer.message;
-        const channelAnswer = await safePrompt([
-            { type: 'input', name: 'channel', message: 'Enter channel:', default: 'web' },
-        ]);
-        if (!channelAnswer)
-            return;
-        channel = channelAnswer.channel;
-    }
-    // Execute
-    progress(asJson, '\n🚀 Executing preprocessor...');
-    progress(asJson, `Input message: ${message}`);
-    progress(asJson, `Channel: ${channel}`);
-    const { apiKey, agentId } = await loadAuthOrFail();
-    const preprocessorCode = loadArtifact(selected, process.cwd());
-    await withSandboxEnv(async () => {
-        try {
-            const messages = [{ type: 'text', text: message }];
-            const result = await executePreProcessor({
-                processorCode: preprocessorCode,
-                messages,
-                channel,
-                apiKey,
-                agentId,
-            });
-            success(asJson, '\n✅ PreProcessor execution successful!');
-            // Helper to display messages
-            const displayMessages = (outputMessages) => {
-                console.log(`Processed messages (${outputMessages.length}):`);
-                outputMessages.forEach((msg, idx) => {
-                    if (msg.type === 'text') {
-                        console.log(`  ${idx + 1}. [TEXT] ${msg.text}`);
-                    }
-                    else if (msg.type === 'image') {
-                        console.log(`  ${idx + 1}. [IMAGE] ${msg.mimeType}`);
-                    }
-                    else if (msg.type === 'file') {
-                        console.log(`  ${idx + 1}. [FILE] ${msg.mimeType}`);
-                    }
-                    else {
-                        console.log(`  ${idx + 1}. [${msg.type}]`, msg);
-                    }
-                });
-            };
-            if (asJson) {
-                printToolOutput('PreProcessor', result, true);
-            }
-            else if (result.action === 'block') {
-                console.log(`\nAction: BLOCK`);
-                console.log(`Response: ${result.response}`);
-                if (result.metadata) {
-                    console.log(`Metadata: ${JSON.stringify(result.metadata, null, 2)}`);
-                }
-            }
-            else if (result.action === 'proceed') {
-                console.log(`\nAction: PROCEED`);
-                const outputMessages = result.modifiedMessage || messages;
-                displayMessages(outputMessages);
-                if (result.metadata) {
-                    console.log(`Metadata: ${JSON.stringify(result.metadata, null, 2)}`);
-                }
-            }
-            else {
-                console.log(`\nAction: PROCEED (no valid action returned, messages unchanged)`);
-                displayMessages(messages);
-                console.log(`\nRaw result:`);
-                printToolOutput('PreProcessor', result, false);
-            }
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Preprocessor works locally. To test in production:',
-                    lines: [
-                        { label: 'Send a message:', command: 'lua chat -e production -m "test message"' },
-                        { label: 'Inspect logs:', command: 'lua logs --type preprocessor --limit 5' },
-                    ],
-                    when: 'success',
-                });
-            }
-        }
-        catch (error) {
-            handleExecutionError(error, 'PreProcessor');
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Preprocessor ran locally — no server logs exist for this execution.',
-                    lines: [
-                        { label: 'Try with --json:', command: `lua test preprocessor --name ${preprocessorName} --json` },
-                        { label: 'Then inspect:', command: 'lua logs --type preprocessor --limit 5' },
-                    ],
-                    when: 'error',
-                });
-            }
-        }
-    });
-}
-async function testPostProcessor(entityName, inputJson, asJson = false) {
-    progress(asJson, '📤 Testing postprocessor...');
-    progress(asJson, '📦 Compiling code first...');
-    await compileQuietly(asJson);
-    const manifest = loadManifest();
-    const postprocessors = getPrimitivesByKind(manifest, PrimitiveKind.POSTPROCESSOR);
-    if (postprocessors.length === 0) {
-        console.error('❌ No postprocessors found in compiled output.');
-        return;
-    }
-    // Select postprocessor
-    const selected = await selectEntityOrPrompt({
-        items: postprocessors,
-        entityName,
-        entityType: 'Postprocessor',
-        idProperty: 'name',
-        nameProperty: 'name',
-        promptMessage: 'Select a postprocessor to test:',
-        formatChoice: (p) => `${p.name}`,
-        asJson,
-    });
-    if (!selected)
-        return;
-    const postprocessorName = selected.name;
-    // Get inputs
-    let message;
-    let response;
-    let channel;
-    if (inputJson) {
-        const input = parseJsonInputOrFail(inputJson, '{"message": "text", "response": "text", "channel": "channel_name"}');
-        message = input.message || 'What products do you have?';
-        response = input.response || 'We have laptops, phones, and tablets available.';
-        channel = input.channel || 'web';
-    }
-    else {
-        const messageAnswer = await safePrompt([
-            {
-                type: 'input',
-                name: 'message',
-                message: 'Enter original user message:',
-                default: 'What products do you have?',
-            },
-        ]);
-        if (!messageAnswer)
-            return;
-        message = messageAnswer.message;
-        const responseAnswer = await safePrompt([
-            {
-                type: 'input',
-                name: 'response',
-                message: 'Enter agent response to process:',
-                default: 'We have laptops, phones, and tablets available.',
-            },
-        ]);
-        if (!responseAnswer)
-            return;
-        response = responseAnswer.response;
-        const channelAnswer = await safePrompt([
-            { type: 'input', name: 'channel', message: 'Enter channel:', default: 'web' },
-        ]);
-        if (!channelAnswer)
-            return;
-        channel = channelAnswer.channel;
-    }
-    // Execute
-    progress(asJson, '\n🚀 Executing postprocessor...');
-    progress(asJson, `Original message: ${message}`);
-    progress(asJson, `Agent response: ${response}`);
-    progress(asJson, `Channel: ${channel}`);
-    const { apiKey, agentId } = await loadAuthOrFail();
-    const postprocessorCode = loadArtifact(selected, process.cwd());
-    await withSandboxEnv(async () => {
-        try {
-            const result = await executePostProcessor({
-                processorCode: postprocessorCode,
-                message,
-                response,
-                channel,
-                apiKey,
-                agentId,
-            });
-            success(asJson, '\n✅ PostProcessor execution successful!');
-            if (asJson) {
-                printToolOutput('PostProcessor', result, true);
-            }
-            else if (typeof result === 'object' && result !== null) {
-                const resultObj = result;
-                if (resultObj.modifiedResponse) {
-                    console.log(`Processed response: ${resultObj.modifiedResponse}`);
-                }
-                else {
-                    printToolOutput('PostProcessor', result, false);
-                }
-            }
-            else {
-                console.log(`Processed response: ${result}`);
-            }
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Postprocessor works locally. To test in production:',
-                    lines: [
-                        { label: 'Send a message:', command: 'lua chat -e production -m "test message"' },
-                        { label: 'Inspect logs:', command: 'lua logs --type postprocessor --limit 5' },
-                    ],
-                    when: 'success',
-                });
-            }
-        }
-        catch (error) {
-            handleExecutionError(error, 'PostProcessor');
-            if (!asJson) {
-                writeHintBlock({
-                    headline: 'Postprocessor ran locally — no server logs exist for this execution.',
-                    lines: [
-                        { label: 'Try with --json:', command: `lua test postprocessor --name ${postprocessorName} --json` },
-                        { label: 'Test in production:', command: 'lua logs --type postprocessor --limit 5' },
-                    ],
-                    when: 'error',
-                });
-            }
-        }
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Utility Functions
-// ─────────────────────────────────────────────────────────────────────────────
-function formatSchedule(schedule) {
-    if (!schedule)
-        return 'Not configured';
-    switch (schedule.type) {
-        case 'cron':
-            return `Cron: ${schedule.expression}${schedule.timezone ? ` (${schedule.timezone})` : ''}`;
-        case 'once':
-            return `Once at: ${new Date(schedule.executeAt).toLocaleString()}`;
-        case 'interval':
-            return `Every ${schedule.seconds} seconds`;
-        default:
-            return 'Unknown schedule type';
-    }
-}
-//# sourceMappingURL=test.js.map