lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/commands/test.js

@@ -2,102 +2,578 @@
  * Test Command
  * Orchestrates the testing of individual tools in a local sandbox environment
  */
+import fs from "fs";
+import path from "path";
 import { compileCommand } from "./compile.js";
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 import { loadApiKey } from "../services/auth.js";
-import { executeTool, loadEnvironmentVariables } from "../utils/sandbox.js";
+import { executeTool, executeWebhook, executeJob, executePreProcessor, executePostProcessor, loadEnvironmentVariables } from "../utils/sandbox.js";
 import { readSkillConfig } from "../utils/files.js";
+import { safePrompt } from "../utils/prompt-handler.js";
 import { decompressCode, readDeployJson, extractToolsFromDeployData, hasEnvFile, hasConfigEnvVars, } from "../utils/test-helpers.js";
 import { promptToolSelection, generatePromptsForObject } from "../utils/test-prompts.js";
 /**
- * Main test command - tests a tool in a local sandbox environment.
+ * Main test command - tests tools, webhooks, jobs, preprocessors, or postprocessors.
  *
- * This command performs the following steps:
- * 1. Compiles the skill to ensure latest code
- * 2. Loads deploy.json with tool definitions
- * 3. Extracts all available tools
- * 4. Prompts user to select a tool
- * 5. Collects input values based on tool's input schema
- * 6. Executes the tool in a sandboxed environment
- * 7. Displays the results
- *
- * Features:
- * - Interactive tool selection from compiled tools
- * - Dynamic input prompts based on tool schemas
- * - Support for nested object inputs
- * - Environment variable injection
- * - Secure sandbox execution
- * - Detailed error reporting
+ * 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() {
+export async function testCommand(type) {
     return withErrorHandling(async () => {
-        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();
-        if (hasEnvFile()) {
-            writeProgress(`📄 Loaded environment variables from .env file`);
-        }
-        if (hasConfigEnvVars(config)) {
-            writeProgress(`📄 Loaded environment variables from lua.skill.yaml`);
-        }
-        // 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
-        let inputValues = {};
-        const inputSchema = selectedTool.inputSchema;
-        if (inputSchema.properties) {
-            writeProgress("\n📝 Enter input values:");
-            inputValues = await generatePromptsForObject(inputSchema, '', inputSchema.required || []);
-        }
-        // Step 7: Execute the tool
-        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
-            });
-            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);
+        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') {
+                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');
+                process.exit(1);
+            }
+            selectedType = type;
+        }
+        else {
+            // Step 2: Prompt for type selection
+            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;
+        }
+        // Step 3: Route to appropriate function
+        if (selectedType === 'skill') {
+            await testSkill();
+        }
+        else if (selectedType === 'webhook') {
+            await testWebhook();
         }
-        finally {
-            // Restore original environment variables
-            process.env = originalEnv;
+        else if (selectedType === 'job') {
+            await testJob();
+        }
+        else if (selectedType === 'preprocessor') {
+            await testPreProcessor();
+        }
+        else if (selectedType === 'postprocessor') {
+            await testPostProcessor();
         }
     }, "testing");
 }
+/**
+ * Test a skill/tool interactively.
+ */
+async function testSkill() {
+    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();
+    if (hasEnvFile()) {
+        writeProgress(`📄 Loaded environment variables from .env file`);
+    }
+    if (hasConfigEnvVars(config)) {
+        writeProgress(`📄 Loaded environment variables from lua.skill.yaml`);
+    }
+    // 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
+    let inputValues = {};
+    const inputSchema = selectedTool.inputSchema;
+    if (inputSchema.properties) {
+        writeProgress("\n📝 Enter input values:");
+        inputValues = await generatePromptsForObject(inputSchema, '', inputSchema.required || []);
+    }
+    // Step 7: Execute the tool
+    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
+        });
+        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);
+        }
+    }
+    finally {
+        // Restore original environment variables
+        process.env = originalEnv;
+    }
+}
+/**
+ * Test a webhook interactively.
+ */
+async function testWebhook() {
+    writeProgress("🪝 Testing webhook...");
+    // Step 1: Compile the code
+    writeProgress("📦 Compiling code first...");
+    await compileCommand();
+    // Step 2: Load configuration
+    const config = readSkillConfig();
+    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) {
+        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.");
+    }
+    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
+    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 || []);
+    }
+    // Step 9: Execute webhook through sandbox
+    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);
+        }
+    }
+    finally {
+        // Restore original environment variables
+        process.env = originalEnv;
+    }
+}
+/**
+ * Test a job by manually triggering it.
+ */
+async function testJob() {
+    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 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) {
+        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;
+    }
+    // Step 5: Execute job through sandbox
+    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);
+        }
+    }
+    finally {
+        // Restore original environment variables
+        process.env = originalEnv;
+    }
+}
+/**
+ * Test a preprocessor interactively.
+ */
+async function testPreProcessor() {
+    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.");
+        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
+    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.");
+    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 {
+        const result = await executePreProcessor({
+            processorCode: preprocessorCode,
+            message: messageAnswer.message,
+            channel: channelAnswer.channel,
+            apiKey,
+            agentId
+        });
+        writeSuccess("\n✅ PreProcessor execution successful!");
+        console.log(`Processed message: ${result}`);
+    }
+    catch (error) {
+        console.error("\n❌ PreProcessor execution failed:");
+        console.error(error.message);
+    }
+    finally {
+        process.env = originalEnv;
+    }
+}
+/**
+ * Test a postprocessor interactively.
+ */
+async function testPostProcessor() {
+    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.");
+        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
+    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.");
+    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;
+    }
+}
+/**
+ * Format schedule for display
+ */
+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';
+    }
+}

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Webhooks Command
+ * Manages agent webhooks for sandbox and production environments
+ */
+/**
+ * Main webhooks command - manages agent webhooks
+ *
+ * Features:
+ * - View deployed webhooks
+ * - View webhook versions
+ * - Deploy webhook versions to production
+ * - Activate/deactivate webhooks
+ *
+ * Note: For local testing, use `lua test webhook`
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function webhooksCommand(): Promise<void>;