lua-cli 3.12.2 → 3.14.0

package/dist/commands/test.js

@@ -2,16 +2,18 @@
  * Test Command
  * Orchestrates the testing of individual tools in a local sandbox environment
  */
-import inquirer from "inquirer";
-import { compileCommand } from "./compile.js";
-import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } 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 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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -30,7 +32,7 @@ async function promptToolSelection(tools) {
         name: tool.skillName
             ? `${tool.name} (${tool.skillName}) - ${tool.description}`
             : `${tool.name} - ${tool.description}`,
-        value: tool
+        value: tool,
     }));
     const { selectedTool } = await inquirer.prompt([
         {
@@ -38,8 +40,8 @@ async function promptToolSelection(tools) {
             name: 'selectedTool',
             message: '🔧 Select a tool to test:',
             choices: toolChoices,
-            pageSize: 10
-        }
+            pageSize: 10,
+        },
     ]);
     return selectedTool;
 }
@@ -76,14 +78,14 @@ function parseJsonInputOrFail(inputJson, expectedFormat) {
  * Selects an entity by name (non-interactive) or prompts user (interactive).
  */
 async function selectEntityOrPrompt(options) {
-    const { items, entityName, entityType, idProperty, nameProperty, promptMessage, formatChoice } = 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}");
+            throw new Error(`${entityType} "${entityName}" not found`);
         }
-        writeProgress(`✅ Selected ${entityType.toLowerCase()}: ${selected[nameProperty]}`);
+        progress(asJson ?? false, `✅ Selected ${entityType.toLowerCase()}: ${selected[nameProperty]}`);
         return selected;
     }
     const answer = await safePrompt([
@@ -93,14 +95,63 @@ async function selectEntityOrPrompt(options) {
             message: promptMessage,
             choices: items.map((item) => ({
                 name: formatChoice ? formatChoice(item) : `${item[nameProperty]}`,
-                value: item
-            }))
-        }
+                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.
  */
@@ -124,7 +175,7 @@ function extractToolsFromManifest(manifest) {
             toolToSkill.set(toolName, skill.name);
         }
     }
-    return tools.map(tool => ({
+    return tools.map((tool) => ({
         ...tool,
         id: tool.name,
         skillName: toolToSkill.get(tool.name) || 'unknown',
@@ -140,19 +191,10 @@ 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) {
-            if (!['skill', 'webhook', 'job', 'preprocessor', 'postprocessor'].includes(type)) {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "webhook", "job", "preprocessor", or "postprocessor".`);
-                console.log('\nUsage:');
-                console.log('  lua test                - Interactive selection');
-                console.log('  lua test skill          - Test a skill/tool directly');
-                console.log('  lua test webhook        - Test a webhook directly');
-                console.log('  lua test job            - Test a job directly');
-                console.log('  lua test preprocessor   - Test a preprocessor directly');
-                console.log('  lua test postprocessor  - Test a postprocessor directly');
-                throw new Error("Invalid type:");
-            }
+            type = validateOrSuggest('test.type', type);
             selectedType = type;
         }
         else if (entityName) {
@@ -160,7 +202,7 @@ export async function testCommand(type, cmdObj) {
             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.");
+            throw new Error('Type must be specified when using the --name option.');
         }
         else {
             const typeAnswer = await safePrompt([
@@ -173,31 +215,31 @@ export async function testCommand(type, cmdObj) {
                         { name: '🪝 Webhook', value: 'webhook' },
                         { name: '⏰ Job', value: 'job' },
                         { name: '📥 PreProcessor', value: 'preprocessor' },
-                        { name: '📤 PostProcessor', value: 'postprocessor' }
-                    ]
-                }
+                        { name: '📤 PostProcessor', value: 'postprocessor' },
+                    ],
+                },
             ]);
             if (!typeAnswer) {
-                console.log("Test cancelled.");
+                console.log('Test cancelled.');
                 return;
             }
             selectedType = typeAnswer.type;
         }
         switch (selectedType) {
             case 'skill':
-                await testSkill(entityName, inputJson);
+                await testSkill(entityName, inputJson, asJson);
                 break;
             case 'webhook':
-                await testWebhook(entityName, inputJson);
+                await testWebhook(entityName, inputJson, asJson);
                 break;
             case 'job':
-                await testJob(entityName);
+                await testJob(entityName, asJson);
                 break;
             case 'preprocessor':
-                await testPreProcessor(entityName, inputJson);
+                await testPreProcessor(entityName, inputJson, asJson);
                 break;
             case 'postprocessor':
-                await testPostProcessor(entityName, inputJson);
+                await testPostProcessor(entityName, inputJson, asJson);
                 break;
         }
         trackEvent('cli_test_executed', {
@@ -206,24 +248,24 @@ export async function testCommand(type, cmdObj) {
             input_provided_json: !!inputJson,
             non_interactive: !!type,
         });
-    }, "testing");
+    }, 'testing');
 }
 // ─────────────────────────────────────────────────────────────────────────────
 // Test Functions
 // ─────────────────────────────────────────────────────────────────────────────
-async function testSkill(entityName, inputJson) {
-    writeProgress("🧪 Testing Lua skill...");
-    writeProgress("📦 Compiling code first...");
-    await compileCommand();
+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()) {
-        writeProgress(`📄 Loaded environment variables from .env file`);
+        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.");
+        console.error('❌ No tools found in compiled output.');
+        throw new Error('No tools found in compiled output.');
     }
     // Select tool
     let selectedTool;
@@ -231,25 +273,25 @@ async function testSkill(entityName, inputJson) {
         selectedTool = allTools.find((t) => t.id === entityName || t.name === entityName);
         if (!selectedTool) {
             console.error(`❌ Tool "${entityName}" not found`);
-            throw new Error("Tool");
+            throw new Error('Tool');
         }
-        writeProgress(`✅ Selected tool: ${selectedTool.name}`);
+        progress(asJson, `✅ Selected tool: ${selectedTool.name}`);
     }
     else {
         selectedTool = await promptToolSelection(allTools);
         clearPromptLines(2);
-        writeProgress(`✅ Selected tool: ${selectedTool.name}`);
+        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", ...}');
-        writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
+        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: '{}' }
+            { type: 'input', name: 'input', message: 'Enter input JSON (or empty for {}):', default: '{}' },
         ]);
         if (inputAnswer) {
             try {
@@ -261,7 +303,7 @@ async function testSkill(entityName, inputJson) {
         }
     }
     // Execute - load uncompressed code from dist-v2
-    writeProgress("\n🚀 Executing tool...");
+    progress(asJson, '\n🚀 Executing tool...');
     const toolCode = loadArtifact(selectedTool, process.cwd());
     await withSandboxEnv(async () => {
         try {
@@ -272,24 +314,42 @@ async function testSkill(entityName, inputJson) {
                 agentId,
                 channel: 'dev',
             });
-            writeSuccess("✅ Tool execution successful!");
-            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
+            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) {
-    writeProgress("🪝 Testing webhook...");
-    writeProgress("📦 Compiling code first...");
-    await compileCommand();
+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.");
+        console.error('❌ No webhooks found in compiled output.');
+        console.log('💡 Create a webhook using LuaWebhook in your code.');
         return;
     }
     // Select webhook
@@ -300,12 +360,14 @@ async function testWebhook(entityName, inputJson) {
         idProperty: 'name',
         nameProperty: 'name',
         promptMessage: 'Select a webhook to test:',
-        formatChoice: (w) => `${w.name}`
+        formatChoice: (w) => `${w.name}`,
+        asJson,
     });
     if (!selectedWebhook) {
-        console.log("Test cancelled.");
+        console.log('Test cancelled.');
         return;
     }
+    const webhookName = selectedWebhook.name;
     // Get inputs
     let query = {};
     let headers = {};
@@ -319,48 +381,69 @@ async function testWebhook(entityName, inputJson) {
     else {
         // Simple JSON input prompts
         const queryAnswer = await safePrompt([
-            { type: 'input', name: 'query', message: 'Enter query params JSON (or empty):', default: '{}' }
+            { 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: '{}' }
+            { 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: '{}' }
+            { type: 'input', name: 'body', message: 'Enter body JSON (or empty):', default: '{}' },
         ]);
         if (bodyAnswer)
             body = JSON.parse(bodyAnswer.body || '{}');
     }
     // Execute
-    writeProgress("\n🚀 Executing webhook...");
-    writeProgress(`Query: ${JSON.stringify(query, null, 2)}`);
-    writeProgress(`Headers: ${JSON.stringify(headers, null, 2)}`);
-    writeProgress(`Body: ${JSON.stringify(body, null, 2)}`);
+    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 });
-            writeSuccess("\n✅ Webhook execution successful!");
-            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
+            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) {
-    writeProgress("⏰ Testing job...");
-    writeProgress("📦 Compiling code first...");
-    await compileCommand();
+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.");
+        console.error('❌ No jobs found in compiled output.');
+        console.log('💡 Create a job using LuaJob in your code.');
         return;
     }
     // Select job
@@ -371,19 +454,21 @@ async function testJob(entityName) {
         idProperty: 'name',
         nameProperty: 'name',
         promptMessage: 'Select a job to test:',
-        formatChoice: (j) => `${j.name} - ${formatSchedule(j.schedule)}`
+        formatChoice: (j) => `${j.name} - ${formatSchedule(j.schedule)}`,
+        asJson,
     });
     if (!selectedJob) {
-        console.log("Test cancelled.");
+        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
-    writeProgress(`\n🚀 Executing job: ${selectedJob.name}...`);
-    writeProgress(`📅 Schedule: ${formatSchedule(selectedJob.schedule)}`);
+    progress(asJson, `\n🚀 Executing job: ${selectedJob.name}...`);
+    progress(asJson, `📅 Schedule: ${formatSchedule(selectedJob.schedule)}`);
     const jobCode = loadArtifact(selectedJob, process.cwd());
     await withSandboxEnv(async () => {
         try {
@@ -396,25 +481,46 @@ async function testJob(entityName) {
                     jobId: jobId,
                     name: selectedJob.name,
                     schedule: selectedJob.schedule,
-                    metadata: {}
-                }
+                    metadata: {},
+                },
             });
-            writeSuccess("\n✅ Job execution successful!");
-            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
+            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) {
-    writeProgress("📥 Testing preprocessor...");
-    writeProgress("📦 Compiling code first...");
-    await compileCommand();
+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.");
+        console.error('❌ No preprocessors found in compiled output.');
         return;
     }
     // Select preprocessor
@@ -425,10 +531,12 @@ async function testPreProcessor(entityName, inputJson) {
         idProperty: 'name',
         nameProperty: 'name',
         promptMessage: 'Select a preprocessor to test:',
-        formatChoice: (p) => `${p.name}`
+        formatChoice: (p) => `${p.name}`,
+        asJson,
     });
     if (!selected)
         return;
+    const preprocessorName = selected.name;
     // Get inputs
     let message;
     let channel;
@@ -439,22 +547,22 @@ async function testPreProcessor(entityName, inputJson) {
     }
     else {
         const messageAnswer = await safePrompt([
-            { type: 'input', name: 'message', message: 'Enter test message:', default: 'Hello, I need help with my order' }
+            { 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' }
+            { type: 'input', name: 'channel', message: 'Enter channel:', default: 'web' },
         ]);
         if (!channelAnswer)
             return;
         channel = channelAnswer.channel;
     }
     // Execute
-    writeProgress("\n🚀 Executing preprocessor...");
-    writeProgress(`Input message: ${message}`);
-    writeProgress(`Channel: ${channel}`);
+    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 () => {
@@ -465,9 +573,9 @@ async function testPreProcessor(entityName, inputJson) {
                 messages,
                 channel,
                 apiKey,
-                agentId
+                agentId,
             });
-            writeSuccess("\n✅ PreProcessor execution successful!");
+            success(asJson, '\n✅ PreProcessor execution successful!');
             // Helper to display messages
             const displayMessages = (outputMessages) => {
                 console.log(`Processed messages (${outputMessages.length}):`);
@@ -486,7 +594,10 @@ async function testPreProcessor(entityName, inputJson) {
                     }
                 });
             };
-            if (result.action === 'block') {
+            if (asJson) {
+                printToolOutput('PreProcessor', result, true);
+            }
+            else if (result.action === 'block') {
                 console.log(`\nAction: BLOCK`);
                 console.log(`Response: ${result.response}`);
                 if (result.metadata) {
@@ -504,22 +615,43 @@ async function testPreProcessor(entityName, inputJson) {
             else {
                 console.log(`\nAction: PROCEED (no valid action returned, messages unchanged)`);
                 displayMessages(messages);
-                console.log(`\nRaw result: ${JSON.stringify(result, null, 2)}`);
+                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) {
-    writeProgress("📤 Testing postprocessor...");
-    writeProgress("📦 Compiling code first...");
-    await compileCommand();
+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.");
+        console.error('❌ No postprocessors found in compiled output.');
         return;
     }
     // Select postprocessor
@@ -530,10 +662,12 @@ async function testPostProcessor(entityName, inputJson) {
         idProperty: 'name',
         nameProperty: 'name',
         promptMessage: 'Select a postprocessor to test:',
-        formatChoice: (p) => `${p.name}`
+        formatChoice: (p) => `${p.name}`,
+        asJson,
     });
     if (!selected)
         return;
+    const postprocessorName = selected.name;
     // Get inputs
     let message;
     let response;
@@ -546,29 +680,39 @@ async function testPostProcessor(entityName, inputJson) {
     }
     else {
         const messageAnswer = await safePrompt([
-            { type: 'input', name: 'message', message: 'Enter original user message:', default: 'What products do you have?' }
+            {
+                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.' }
+            {
+                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' }
+            { type: 'input', name: 'channel', message: 'Enter channel:', default: 'web' },
         ]);
         if (!channelAnswer)
             return;
         channel = channelAnswer.channel;
     }
     // Execute
-    writeProgress("\n🚀 Executing postprocessor...");
-    writeProgress(`Original message: ${message}`);
-    writeProgress(`Agent response: ${response}`);
-    writeProgress(`Channel: ${channel}`);
+    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 () => {
@@ -579,21 +723,47 @@ async function testPostProcessor(entityName, inputJson) {
                 response,
                 channel,
                 apiKey,
-                agentId
+                agentId,
             });
-            writeSuccess("\n✅ PostProcessor execution successful!");
-            // Result is a string, but handle both cases for robustness
-            if (typeof result === 'object' && result !== null) {
+            success(asJson, '\n✅ PostProcessor execution successful!');
+            if (asJson) {
+                printToolOutput('PostProcessor', result, true);
+            }
+            else if (typeof result === 'object' && result !== null) {
                 const resultObj = result;
-                const text = resultObj.modifiedResponse || JSON.stringify(result, null, 2);
-                console.log(`Processed response: ${text}`);
+                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',
+                });
+            }
         }
     });
 }