lua-cli 3.2.0-alpha.2 → 3.3.0

package/dist/commands/test.js

@@ -12,26 +12,121 @@ import { readSkillConfig } from "../utils/files.js";
 import { safePrompt } from "../utils/prompt-handler.js";
 import { decompressCode, readDeployJson, extractToolsFromDeployData, hasEnvFile, } from "../utils/test-helpers.js";
 import { promptToolSelection, generatePromptsForObject } from "../utils/test-prompts.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Loads API key and agent ID, failing with clear error if not configured.
+ */
+async function loadAuthOrFail() {
+    const apiKey = await loadApiKey();
+    if (!apiKey) {
+        throw new Error("No API key found. Please run 'lua auth configure' first.");
+    }
+    const config = readSkillConfig();
+    const agentId = config?.agent?.agentId;
+    if (!agentId) {
+        throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
+    }
+    return { apiKey, agentId, config };
+}
+/**
+ * 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;
+    }
+}
+/**
+ * Loads bundled JSON data from dist folder, failing with clear error if not found.
+ */
+function loadBundledJsonOrFail(filename, entityType) {
+    const filePath = path.join(process.cwd(), 'dist', filename);
+    if (!fs.existsSync(filePath)) {
+        console.error(`❌ Bundled ${entityType} data not found. Please run compilation first.`);
+        process.exit(1);
+    }
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (Array.isArray(data) && data.length === 0) {
+        console.error(`❌ No ${entityType}s found.`);
+        process.exit(1);
+    }
+    return data;
+}
+/**
+ * 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}`);
+        process.exit(1);
+    }
+}
+/**
+ * Selects an entity by name (non-interactive) or prompts user (interactive).
+ */
+async function selectEntityOrPrompt(options) {
+    const { items, entityName, entityType, idProperty, nameProperty, promptMessage, formatChoice } = options;
+    if (entityName) {
+        const selected = items.find((item) => item[idProperty] === entityName || item[nameProperty] === entityName);
+        if (!selected) {
+            console.error(`❌ ${entityType} "${entityName}" not found`);
+            process.exit(1);
+        }
+        writeProgress(`✅ 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;
+}
+/**
+ * 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);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Command
+// ─────────────────────────────────────────────────────────────────────────────
 /**
  * Main test command - tests tools, webhooks, jobs, preprocessors, or postprocessors.
- *
- * This command can test:
- * - Skills/Tools: Interactive tool execution with input prompts
- * - Webhooks: Test webhook with query params, headers, and body
- * - Jobs: Trigger job execution manually
- * - PreProcessors: Test message preprocessing
- * - PostProcessors: Test response postprocessing
- *
- * @param type - Optional type argument ('skill', 'webhook', 'job', 'preprocessor', 'postprocessor')
- * @returns Promise that resolves when test completes
  */
-export async function testCommand(type) {
+export async function testCommand(type, cmdObj) {
     return withErrorHandling(async () => {
+        const entityName = cmdObj?.name || null;
+        const inputJson = cmdObj?.input || null;
         let selectedType;
-        // Step 1: Check if type was provided as argument
         if (type) {
-            // Validate the provided type
-            if (type !== 'skill' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
+            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');
@@ -44,8 +139,14 @@ export async function testCommand(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');
+            process.exit(1);
+        }
         else {
-            // Step 2: Prompt for type selection
             const typeAnswer = await safePrompt([
                 {
                     type: 'list',
@@ -66,517 +167,373 @@ export async function testCommand(type) {
             }
             selectedType = typeAnswer.type;
         }
-        // Step 3: Route to appropriate function
-        if (selectedType === 'skill') {
-            await testSkill();
-        }
-        else if (selectedType === 'webhook') {
-            await testWebhook();
-        }
-        else if (selectedType === 'job') {
-            await testJob();
-        }
-        else if (selectedType === 'preprocessor') {
-            await testPreProcessor();
-        }
-        else if (selectedType === 'postprocessor') {
-            await testPostProcessor();
+        switch (selectedType) {
+            case 'skill':
+                await testSkill(entityName, inputJson);
+                break;
+            case 'webhook':
+                await testWebhook(entityName, inputJson);
+                break;
+            case 'job':
+                await testJob(entityName);
+                break;
+            case 'preprocessor':
+                await testPreProcessor(entityName, inputJson);
+                break;
+            case 'postprocessor':
+                await testPostProcessor(entityName, inputJson);
+                break;
         }
     }, "testing");
 }
-/**
- * Test a skill/tool interactively.
- */
-async function testSkill() {
+// ─────────────────────────────────────────────────────────────────────────────
+// Test Functions
+// ─────────────────────────────────────────────────────────────────────────────
+async function testSkill(entityName, inputJson) {
     writeProgress("🧪 Testing Lua skill...");
-    // Step 1: Compile the code
     writeProgress("📦 Compiling code first...");
     await compileCommand();
-    // Step 2: Load deploy data and extract tools
     const deployData = readDeployJson();
     const allTools = extractToolsFromDeployData(deployData);
-    // Step 3: Load authentication and configuration
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        throw new Error("No API key found. Please run 'lua auth configure' first.");
-    }
-    const config = readSkillConfig();
-    const agentId = config?.agent?.agentId;
-    if (!agentId) {
-        throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
-    }
-    // Step 4: Load environment variables
-    const envVars = loadEnvironmentVariables();
+    const { apiKey, agentId } = await loadAuthOrFail();
     if (hasEnvFile()) {
         writeProgress(`📄 Loaded environment variables from .env file`);
     }
-    // Step 5: Let user select a tool
-    const selectedTool = await promptToolSelection(allTools);
-    clearPromptLines(2);
-    writeProgress(`✅ Selected tool: ${selectedTool.name}`);
-    // Step 6: Collect input values based on schema
+    // Select tool
+    let selectedTool;
+    if (entityName) {
+        selectedTool = allTools.find((t) => t.id === entityName || t.name === entityName);
+        if (!selectedTool) {
+            console.error(`❌ Tool "${entityName}" not found`);
+            process.exit(1);
+        }
+        writeProgress(`✅ Selected tool: ${selectedTool.name}`);
+    }
+    else {
+        selectedTool = await promptToolSelection(allTools);
+        clearPromptLines(2);
+        writeProgress(`✅ Selected tool: ${selectedTool.name}`);
+    }
+    // Get input values
     let inputValues = {};
     const inputSchema = selectedTool.inputSchema;
-    if (inputSchema.properties) {
+    if (inputJson) {
+        inputValues = parseJsonInputOrFail(inputJson, '{"param1": "value1", ...}');
+        writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
+    }
+    else if (inputSchema && inputSchema.properties) {
         writeProgress("\n📝 Enter input values:");
         inputValues = await generatePromptsForObject(inputSchema, '', inputSchema.required || []);
     }
-    // Step 7: Execute the tool
+    // Execute
     writeProgress("\n🚀 Executing tool...");
-    writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
     const toolCode = decompressCode(selectedTool.execute);
-    // Set environment variables for sandbox
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        const result = await executeTool({
-            toolCode,
-            inputs: inputValues,
-            apiKey,
-            agentId,
-            channel: 'dev',
-        });
-        writeSuccess("✅ Tool execution successful!");
-        console.log(`Output: ${JSON.stringify(result, null, 2)}`);
-    }
-    catch (executionError) {
-        console.error("\n❌ Tool execution failed:");
-        console.error(executionError.message);
-        if (executionError.stack) {
-            console.error(executionError.stack);
+    await withSandboxEnv(async () => {
+        try {
+            const result = await executeTool({
+                toolCode,
+                inputs: inputValues,
+                apiKey,
+                agentId,
+                channel: 'dev',
+            });
+            writeSuccess("✅ Tool execution successful!");
+            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
         }
-    }
-    finally {
-        // Restore original environment variables
-        process.env = originalEnv;
-    }
+        catch (error) {
+            handleExecutionError(error, 'Tool');
+        }
+    });
 }
-/**
- * Test a webhook interactively.
- */
-async function testWebhook() {
+async function testWebhook(entityName, inputJson) {
     writeProgress("🪝 Testing webhook...");
-    // Step 1: Compile the code
     writeProgress("📦 Compiling code first...");
     await compileCommand();
-    // Step 2: Load configuration
-    const config = readSkillConfig();
+    const { apiKey, agentId, config } = await loadAuthOrFail();
     const webhooks = config.webhooks || [];
     if (webhooks.length === 0) {
         console.error("❌ No webhooks found in configuration.");
         console.log("💡 Create a webhook using LuaWebhook in your code.");
         return;
     }
-    // Step 3: Load bundled webhook data
-    const bundledWebhooksPath = path.join(process.cwd(), 'dist', 'webhooks.json');
-    if (!fs.existsSync(bundledWebhooksPath)) {
-        console.error("❌ Bundled webhook data not found. Please run compilation first.");
-        return;
-    }
-    const bundledWebhooks = JSON.parse(fs.readFileSync(bundledWebhooksPath, 'utf8'));
-    // Step 4: Select webhook to test
-    const webhookAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selectedWebhook',
-            message: 'Select a webhook to test:',
-            choices: webhooks.map((webhook) => ({
-                name: `${webhook.name} (v${webhook.version})`,
-                value: webhook
-            }))
-        }
-    ]);
-    if (!webhookAnswer) {
+    const bundledWebhooks = loadBundledJsonOrFail('webhooks.json', 'webhook');
+    // Select webhook
+    const selectedWebhook = await selectEntityOrPrompt({
+        items: webhooks,
+        entityName,
+        entityType: 'Webhook',
+        idProperty: 'webhookId',
+        nameProperty: 'name',
+        promptMessage: 'Select a webhook to test:',
+        formatChoice: (w) => `${w.name} (v${w.version})`
+    });
+    if (!selectedWebhook) {
         console.log("Test cancelled.");
         return;
     }
-    const selectedWebhook = webhookAnswer.selectedWebhook;
-    // Find bundled webhook data
     const bundledWebhook = bundledWebhooks.find((w) => w.name === selectedWebhook.name);
     if (!bundledWebhook || !bundledWebhook.code) {
-        console.error("❌ Bundled webhook code not found.");
-        return;
-    }
-    // Step 5: Load authentication
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        throw new Error("No API key found. Please run 'lua auth configure' first.");
+        console.error(`❌ Bundled webhook code not found for "${selectedWebhook.name}"`);
+        process.exit(1);
     }
-    const agentId = config?.agent?.agentId;
-    if (!agentId) {
-        throw new Error("No agent ID found in lua.skill.yaml.");
-    }
-    // Step 6: Collect query parameters based on schema
+    // Get inputs
     let query = {};
-    if (bundledWebhook.querySchema && bundledWebhook.querySchema.properties) {
-        writeProgress("\n📝 Enter query parameters:");
-        query = await generatePromptsForObject(bundledWebhook.querySchema, '', bundledWebhook.querySchema.required || []);
-    }
-    // Step 7: Collect headers based on schema
     let headers = {};
-    if (bundledWebhook.headerSchema && bundledWebhook.headerSchema.properties) {
-        writeProgress("\n📝 Enter headers:");
-        headers = await generatePromptsForObject(bundledWebhook.headerSchema, '', bundledWebhook.headerSchema.required || []);
-    }
-    // Step 8: Collect body based on schema
     let body = {};
-    if (bundledWebhook.bodySchema && bundledWebhook.bodySchema.properties) {
-        writeProgress("\n📝 Enter request body:");
-        body = await generatePromptsForObject(bundledWebhook.bodySchema, '', bundledWebhook.bodySchema.required || []);
+    if (inputJson) {
+        const input = parseJsonInputOrFail(inputJson, '{"query": {}, "headers": {}, "body": {}}');
+        query = input.query || {};
+        headers = input.headers || {};
+        body = input.body || {};
+    }
+    else {
+        if (bundledWebhook.querySchema?.properties) {
+            writeProgress("\n📝 Enter query parameters:");
+            query = await generatePromptsForObject(bundledWebhook.querySchema, '', bundledWebhook.querySchema.required || []);
+        }
+        if (bundledWebhook.headerSchema?.properties) {
+            writeProgress("\n📝 Enter headers:");
+            headers = await generatePromptsForObject(bundledWebhook.headerSchema, '', bundledWebhook.headerSchema.required || []);
+        }
+        if (bundledWebhook.bodySchema?.properties) {
+            writeProgress("\n📝 Enter request body:");
+            body = await generatePromptsForObject(bundledWebhook.bodySchema, '', bundledWebhook.bodySchema.required || []);
+        }
     }
-    // Step 9: Execute webhook through sandbox
+    // 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)}`);
     const webhookCode = decompressCode(bundledWebhook.code);
-    // Load environment variables
-    const envVars = loadEnvironmentVariables();
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        const result = await executeWebhook({
-            webhookCode,
-            query,
-            headers,
-            body,
-            apiKey,
-            agentId
-        });
-        writeSuccess("\n✅ Webhook execution successful!");
-        console.log(`Output: ${JSON.stringify(result, null, 2)}`);
-    }
-    catch (executionError) {
-        console.error("\n❌ Webhook execution failed:");
-        console.error(executionError.message);
-        if (executionError.stack) {
-            console.error(executionError.stack);
+    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)}`);
         }
-    }
-    finally {
-        // Restore original environment variables
-        process.env = originalEnv;
-    }
+        catch (error) {
+            handleExecutionError(error, 'Webhook');
+        }
+    });
 }
-/**
- * Test a job by manually triggering it.
- */
-async function testJob() {
+async function testJob(entityName) {
     writeProgress("⏰ Testing job...");
-    // Step 1: Compile the code
     writeProgress("📦 Compiling code first...");
     await compileCommand();
-    // Step 2: Load configuration
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        throw new Error("No API key found. Please run 'lua auth configure' first.");
-    }
-    const config = readSkillConfig();
-    const agentId = config?.agent?.agentId;
-    if (!agentId) {
-        throw new Error("No agent ID found in lua.skill.yaml.");
-    }
+    const { apiKey, agentId, config } = await loadAuthOrFail();
     const jobs = config.jobs || [];
     if (jobs.length === 0) {
         console.error("❌ No jobs found in configuration.");
         console.log("💡 Create a job using LuaJob in your code.");
         return;
     }
-    // Step 3: Load bundled job data
-    const bundledJobsPath = path.join(process.cwd(), 'dist', 'jobs.json');
-    if (!fs.existsSync(bundledJobsPath)) {
-        console.error("❌ Bundled job data not found. Please run compilation first.");
-        return;
-    }
-    const bundledJobs = JSON.parse(fs.readFileSync(bundledJobsPath, 'utf8'));
-    // Step 4: Select job to test
-    const jobAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selectedJob',
-            message: 'Select a job to test:',
-            choices: jobs.map((job) => ({
-                name: `${job.name} (v${job.version}) - ${formatSchedule(job.schedule)}`,
-                value: job
-            }))
-        }
-    ]);
-    if (!jobAnswer) {
+    const bundledJobs = loadBundledJsonOrFail('jobs.json', 'job');
+    // Select job
+    const selectedJob = await selectEntityOrPrompt({
+        items: jobs,
+        entityName,
+        entityType: 'Job',
+        idProperty: 'jobId',
+        nameProperty: 'name',
+        promptMessage: 'Select a job to test:',
+        formatChoice: (j) => `${j.name} (v${j.version}) - ${formatSchedule(j.schedule)}`
+    });
+    if (!selectedJob) {
         console.log("Test cancelled.");
         return;
     }
-    const selectedJob = jobAnswer.selectedJob;
-    // Find bundled job data
     const bundledJob = bundledJobs.find((j) => j.name === selectedJob.name);
     if (!bundledJob || !bundledJob.code) {
-        console.error("❌ Bundled job code not found.");
-        return;
+        console.error(`❌ Bundled job code not found for "${selectedJob.name}"`);
+        process.exit(1);
     }
-    // Step 5: Execute job through sandbox
+    // Execute
     writeProgress(`\n🚀 Executing job: ${selectedJob.name}...`);
     writeProgress(`📅 Schedule: ${formatSchedule(selectedJob.schedule)}`);
     const jobCode = decompressCode(bundledJob.code);
-    // Load environment variables
-    const envVars = loadEnvironmentVariables();
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        const result = await executeJob({
-            jobCode,
-            apiKey,
-            agentId,
-            jobData: {
-                id: selectedJob.jobId,
-                jobId: selectedJob.jobId,
-                name: selectedJob.name,
-                schedule: selectedJob.schedule,
-                metadata: bundledJob.metadata || selectedJob.metadata || {}
-            }
-        });
-        writeSuccess("\n✅ Job execution successful!");
-        console.log(`Output: ${JSON.stringify(result, null, 2)}`);
-    }
-    catch (executionError) {
-        console.error("\n❌ Job execution failed:");
-        console.error(executionError.message);
-        if (executionError.stack) {
-            console.error(executionError.stack);
+    await withSandboxEnv(async () => {
+        try {
+            const result = await executeJob({
+                jobCode,
+                apiKey,
+                agentId,
+                jobData: {
+                    id: selectedJob.jobId,
+                    jobId: selectedJob.jobId,
+                    name: selectedJob.name,
+                    schedule: selectedJob.schedule,
+                    metadata: bundledJob.metadata || selectedJob.metadata || {}
+                }
+            });
+            writeSuccess("\n✅ Job execution successful!");
+            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
         }
-    }
-    finally {
-        // Restore original environment variables
-        process.env = originalEnv;
-    }
+        catch (error) {
+            handleExecutionError(error, 'Job');
+        }
+    });
 }
-/**
- * Test a preprocessor interactively.
- */
-async function testPreProcessor() {
+async function testPreProcessor(entityName, inputJson) {
     writeProgress("📥 Testing preprocessor...");
-    // Step 1: Compile the code
     writeProgress("📦 Compiling code first...");
     await compileCommand();
-    // Step 2: Load bundled preprocessor data
-    const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
-    if (!fs.existsSync(preprocessorsPath)) {
-        console.error("❌ No preprocessors found. Create a PreProcessor in your code.");
-        return;
-    }
-    const preprocessors = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
-    if (preprocessors.length === 0) {
-        console.error("❌ No preprocessors found.");
+    const preprocessors = loadBundledJsonOrFail('preprocessors.json', 'preprocessor');
+    // Select preprocessor
+    const selected = await selectEntityOrPrompt({
+        items: preprocessors,
+        entityName,
+        entityType: 'Preprocessor',
+        idProperty: 'preprocessorId',
+        nameProperty: 'name',
+        promptMessage: 'Select a preprocessor to test:',
+        formatChoice: (p) => `${p.name} (v${p.version})`
+    });
+    if (!selected)
         return;
-    }
-    // Step 3: Select preprocessor to test
-    const preprocessorAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selected',
-            message: 'Select a preprocessor to test:',
-            choices: preprocessors.map((p) => ({
-                name: `${p.name} (v${p.version})`,
-                value: p
-            }))
-        }
-    ]);
-    if (!preprocessorAnswer)
-        return;
-    const selected = preprocessorAnswer.selected;
     if (!selected.code) {
         console.error("❌ Preprocessor code not found.");
         return;
     }
-    // Step 4: Collect test inputs
-    const messageAnswer = await safePrompt([
-        {
-            type: 'input',
-            name: 'message',
-            message: 'Enter test message:',
-            default: 'Hello, I need help with my order'
-        }
-    ]);
-    if (!messageAnswer)
-        return;
-    const channelAnswer = await safePrompt([
-        {
-            type: 'input',
-            name: 'channel',
-            message: 'Enter channel:',
-            default: 'web'
-        }
-    ]);
-    if (!channelAnswer)
-        return;
-    // Step 5: Execute preprocessor
+    // 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
     writeProgress("\n🚀 Executing preprocessor...");
-    writeProgress(`Input message: ${messageAnswer.message}`);
-    writeProgress(`Channel: ${channelAnswer.channel}`);
-    const apiKey = await loadApiKey();
-    if (!apiKey)
-        throw new Error("No API key found.");
-    const config = readSkillConfig();
-    const agentId = config?.agent?.agentId;
-    if (!agentId)
-        throw new Error("No agent ID found.");
+    writeProgress(`Input message: ${message}`);
+    writeProgress(`Channel: ${channel}`);
+    const { apiKey, agentId } = await loadAuthOrFail();
     const preprocessorCode = decompressCode(selected.code);
-    // Load environment variables
-    const envVars = loadEnvironmentVariables();
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        // Convert string message to ChatMessage array
-        const messages = [{ type: 'text', text: messageAnswer.message }];
-        const result = await executePreProcessor({
-            processorCode: preprocessorCode,
-            messages: messages, // Pass array instead of string
-            channel: channelAnswer.channel,
-            apiKey,
-            agentId
-        });
-        writeSuccess("\n✅ PreProcessor execution successful!");
-        console.log(`\nProcessed messages (${result.length}):`);
-        result.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);
-            }
-        });
-    }
-    catch (error) {
-        console.error("\n❌ PreProcessor execution failed:");
-        console.error(error.message);
-    }
-    finally {
-        process.env = originalEnv;
-    }
+    await withSandboxEnv(async () => {
+        try {
+            const messages = [{ type: 'text', text: message }];
+            const result = await executePreProcessor({
+                processorCode: preprocessorCode,
+                messages,
+                channel,
+                apiKey,
+                agentId
+            });
+            writeSuccess("\n✅ PreProcessor execution successful!");
+            console.log(`\nProcessed messages (${result.length}):`);
+            result.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);
+                }
+            });
+        }
+        catch (error) {
+            handleExecutionError(error, 'PreProcessor');
+        }
+    });
 }
-/**
- * Test a postprocessor interactively.
- */
-async function testPostProcessor() {
+async function testPostProcessor(entityName, inputJson) {
     writeProgress("📤 Testing postprocessor...");
-    // Step 1: Compile the code
     writeProgress("📦 Compiling code first...");
     await compileCommand();
-    // Step 2: Load bundled postprocessor data
-    const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
-    if (!fs.existsSync(postprocessorsPath)) {
-        console.error("❌ No postprocessors found. Create a PostProcessor in your code.");
-        return;
-    }
-    const postprocessors = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
-    if (postprocessors.length === 0) {
-        console.error("❌ No postprocessors found.");
+    const postprocessors = loadBundledJsonOrFail('postprocessors.json', 'postprocessor');
+    // Select postprocessor
+    const selected = await selectEntityOrPrompt({
+        items: postprocessors,
+        entityName,
+        entityType: 'Postprocessor',
+        idProperty: 'postprocessorId',
+        nameProperty: 'name',
+        promptMessage: 'Select a postprocessor to test:',
+        formatChoice: (p) => `${p.name} (v${p.version})`
+    });
+    if (!selected)
         return;
-    }
-    // Step 3: Select postprocessor to test
-    const postprocessorAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selected',
-            message: 'Select a postprocessor to test:',
-            choices: postprocessors.map((p) => ({
-                name: `${p.name} (v${p.version})`,
-                value: p
-            }))
-        }
-    ]);
-    if (!postprocessorAnswer)
-        return;
-    const selected = postprocessorAnswer.selected;
     if (!selected.code) {
         console.error("❌ Postprocessor code not found.");
         return;
     }
-    // Step 4: Collect test inputs
-    const messageAnswer = await safePrompt([
-        {
-            type: 'input',
-            name: 'message',
-            message: 'Enter original user message:',
-            default: 'What products do you have?'
-        }
-    ]);
-    if (!messageAnswer)
-        return;
-    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;
-    const channelAnswer = await safePrompt([
-        {
-            type: 'input',
-            name: 'channel',
-            message: 'Enter channel:',
-            default: 'web'
-        }
-    ]);
-    if (!channelAnswer)
-        return;
-    // Step 5: Execute postprocessor
+    // 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
     writeProgress("\n🚀 Executing postprocessor...");
-    writeProgress(`Original message: ${messageAnswer.message}`);
-    writeProgress(`Agent response: ${responseAnswer.response}`);
-    writeProgress(`Channel: ${channelAnswer.channel}`);
-    const apiKey = await loadApiKey();
-    if (!apiKey)
-        throw new Error("No API key found.");
-    const config = readSkillConfig();
-    const agentId = config?.agent?.agentId;
-    if (!agentId)
-        throw new Error("No agent ID found.");
+    writeProgress(`Original message: ${message}`);
+    writeProgress(`Agent response: ${response}`);
+    writeProgress(`Channel: ${channel}`);
+    const { apiKey, agentId } = await loadAuthOrFail();
     const postprocessorCode = decompressCode(selected.code);
-    // Load environment variables
-    const envVars = loadEnvironmentVariables();
-    const originalEnv = { ...process.env };
-    for (const [key, value] of Object.entries(envVars)) {
-        process.env[key] = value;
-    }
-    try {
-        const result = await executePostProcessor({
-            processorCode: postprocessorCode,
-            message: messageAnswer.message,
-            response: responseAnswer.response,
-            channel: channelAnswer.channel,
-            apiKey,
-            agentId
-        });
-        writeSuccess("\n✅ PostProcessor execution successful!");
-        console.log(`Processed response: ${result}`);
-    }
-    catch (error) {
-        console.error("\n❌ PostProcessor execution failed:");
-        console.error(error.message);
-    }
-    finally {
-        process.env = originalEnv;
-    }
+    await withSandboxEnv(async () => {
+        try {
+            const result = await executePostProcessor({
+                processorCode: postprocessorCode,
+                message,
+                response,
+                channel,
+                apiKey,
+                agentId
+            });
+            writeSuccess("\n✅ PostProcessor execution successful!");
+            console.log(`Processed response: ${result}`);
+        }
+        catch (error) {
+            handleExecutionError(error, 'PostProcessor');
+        }
+    });
 }
-/**
- * Format schedule for display
- */
+// ─────────────────────────────────────────────────────────────────────────────
+// Utility Functions
+// ─────────────────────────────────────────────────────────────────────────────
 function formatSchedule(schedule) {
     if (!schedule)
         return 'Not configured';
@@ -591,3 +548,4 @@ function formatSchedule(schedule) {
             return 'Unknown schedule type';
     }
 }
+//# sourceMappingURL=test.js.map