lua-cli 1.3.1 → 1.3.2-alpha.2

package/dist/commands/dev.js

@@ -5,6 +5,7 @@ import inquirer from 'inquirer';
 import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { ApiService } from '../services/api.js';
+import { executeTool, createBroadcastConsole } from '../utils/sandbox.js';
 import { readSkillConfig, updateSkillYamlPersona } from '../utils/files.js';
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from '../utils/cli.js';
 import keytar from 'keytar';
@@ -190,6 +191,14 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                         res.end(JSON.stringify({ success: false, error: 'Tool not found' }));
                         return;
                     }
+                    // Extract environment variables from YAML config
+                    const config = readSkillConfig();
+                    const envVars = {};
+                    if (config?.skill?.env) {
+                        for (const [key, value] of Object.entries(config.skill.env)) {
+                            envVars[key] = value;
+                        }
+                    }
                     // Decompress and execute the tool
                     const { gunzipSync } = await import('zlib');
                     const { Buffer } = await import('buffer');
@@ -200,64 +209,22 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                         return gunzipSync(buffer).toString('utf8');
                     }
                     const toolCode = decompressCode(tool.execute);
-                    // Create a CommonJS context for execution
-                    const require = createRequire(process.cwd() + '/package.json');
-                    // Create a sandbox context
-                    const sandbox = {
-                        require,
-                        console,
-                        Buffer,
-                        setTimeout,
-                        setInterval,
-                        clearTimeout,
-                        clearInterval,
-                        process,
-                        global: globalThis,
-                        __dirname: process.cwd(),
-                        __filename: path.join(process.cwd(), 'index.ts'),
-                        module: { exports: {} },
-                        exports: {},
-                        // Web APIs
-                        fetch: globalThis.fetch,
-                        URLSearchParams: globalThis.URLSearchParams,
-                        URL: globalThis.URL,
-                        Headers: globalThis.Headers,
-                        Request: globalThis.Request,
-                        Response: globalThis.Response,
-                        // Additional globals
-                        Object,
-                        Array,
-                        String,
-                        Number,
-                        Boolean,
-                        Date,
-                        Math,
-                        JSON,
-                        Error,
-                        TypeError,
-                        ReferenceError,
-                        SyntaxError,
-                        globalThis,
-                        undefined: undefined,
-                        null: null,
-                        Infinity: Infinity,
-                        NaN: NaN
-                    };
-                    // Create the CommonJS wrapper code
-                    const commonJsWrapper = `
-const executeFunction = ${toolCode};
-
-// Export the function for testing
-module.exports = async (input) => {
-  return await executeFunction(input);
-};
-`;
-                    // Execute the code in the sandbox
-                    const context = vm.createContext(sandbox);
-                    vm.runInContext(commonJsWrapper, context);
-                    // Get the exported function and execute it
-                    const executeFunction = context.module.exports;
-                    const result = await executeFunction(inputs);
+                    // Create custom console that captures output and sends via WebSocket
+                    const customConsole = createBroadcastConsole((logData) => {
+                        wss.clients.forEach((client) => {
+                            if (client.readyState === 1) { // WebSocket.OPEN
+                                client.send(JSON.stringify(logData));
+                            }
+                        });
+                    });
+                    // Execute the tool using the common utility
+                    const result = await executeTool({
+                        toolCode,
+                        inputs,
+                        apiKey,
+                        agentId,
+                        customConsole
+                    });
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({
                         success: true,
@@ -328,22 +295,44 @@ module.exports = async (input) => {
         res.writeHead(404);
         res.end('Not Found');
     });
-    // Create WebSocket server for live reload
+    // Create WebSocket server for log streaming
     const wss = new WebSocketServer({ server });
     wss.on('connection', (ws) => {
-        console.log('WebSocket client connected for live reload');
+        console.log('WebSocket client connected for log streaming');
         ws.on('close', () => {
             console.log('WebSocket client disconnected');
         });
         ws.on('error', (error) => {
             console.error('WebSocket error:', error);
         });
+        // Send initial connection message
+        ws.send(JSON.stringify({
+            type: 'log',
+            subType: 'info',
+            message: 'Connected to CLI dev server',
+            timestamp: new Date().toISOString()
+        }));
     });
     server.listen(port, () => {
         console.log('Chat interface available at: http://localhost:' + port);
-        console.log('Live reload WebSocket available at: ws://localhost:' + port);
+        console.log('Log streaming WebSocket available at: ws://localhost:' + port);
     });
-    return { server, wss };
+    // Function to broadcast logs to all connected clients
+    const broadcastLog = (message, subType = 'info') => {
+        const logMessage = {
+            type: 'log',
+            subType,
+            message,
+            timestamp: new Date().toISOString(),
+            id: Date.now().toString()
+        };
+        wss.clients.forEach((client) => {
+            if (client.readyState === 1) { // WebSocket.OPEN
+                client.send(JSON.stringify(logMessage));
+            }
+        });
+    };
+    return { server, wss, broadcastLog };
 }
 // Function to update existing sandbox version
 export async function updateDevVersion(apiKey, agentId, skillId, sandboxVersionId, versionData) {
@@ -415,10 +404,6 @@ export async function pushDevVersion(apiKey, agentId, skillId, versionData) {
         };
     }
 }
-function readConfigSkillName() {
-    const config = readSkillConfig();
-    return config?.skill?.name || null;
-}
 function readConfigVersion() {
     const config = readSkillConfig();
     return config?.skill?.version || null;
@@ -434,18 +419,21 @@ function readDeployJson() {
 // Function to push to sandbox (extracted for reuse)
 async function pushToSandbox(apiKey, agentId, skillId, deployData, isInitial = false) {
     const sandboxSkillId = await getSandboxSkillId();
-    // Read skill name from config and add to payload
-    const skillName = readConfigSkillName();
-    const payloadWithName = {
+    // Read skill name and environment variables from config
+    const config = readSkillConfig();
+    const skillName = config?.skill?.name || deployData.name || 'Unknown Skill';
+    const envVars = config?.skill?.env || {};
+    const payloadWithNameAndEnv = {
         ...deployData,
-        name: skillName || deployData.name || 'Unknown Skill'
+        name: skillName,
+        env: envVars
     };
     if (sandboxSkillId) {
         // Try to update existing sandbox version
         if (!isInitial) {
             writeProgress("🔄 Updating existing sandbox version...");
         }
-        const updateResult = await updateDevVersion(apiKey, agentId, skillId, sandboxSkillId, payloadWithName);
+        const updateResult = await updateDevVersion(apiKey, agentId, skillId, sandboxSkillId, payloadWithNameAndEnv);
         if (updateResult.success && updateResult.data) {
             if (!isInitial) {
                 writeSuccess(`✅ Version ${updateResult.data.version} updated in sandbox successfully`);
@@ -468,7 +456,7 @@ async function pushToSandbox(apiKey, agentId, skillId, deployData, isInitial = f
     if (!isInitial) {
         writeProgress("🔄 Creating new sandbox version...");
     }
-    const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithName);
+    const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithNameAndEnv);
     if (result.success && result.data) {
         // Store the new sandbox skill ID
         await setSandboxSkillId(result.data.skillId);
@@ -571,26 +559,37 @@ export async function devCommand() {
         }
         // Start web server for chat interface
         const chatPort = 3000;
-        const { server, wss } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, chatPort);
+        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, chatPort);
         // Open browser to chat interface
         try {
             await open(`http://localhost:${chatPort}`);
             writeSuccess("🌐 Chat interface opened in your browser");
+            broadcastLog("🌐 Chat interface opened in your browser", 'info');
         }
         catch (error) {
             writeSuccess(`🌐 Chat interface available at: http://localhost:${chatPort}`);
+            broadcastLog(`🌐 Chat interface available at: http://localhost:${chatPort}`, 'info');
         }
         // Start file watching
         writeSuccess("🔍 Watching for file changes... (Press Ctrl+C to stop)");
+        broadcastLog("🔍 Watching for file changes... (Press Ctrl+C to stop)", 'info');
         let isCompiling = false;
         let pendingCompile = false;
+        let compileTimeout = null;
         const watcher = watch(process.cwd(), { recursive: true }, async (eventType, filename) => {
             // Ignore changes in .lua directory and other build artifacts
             if (filename && (filename.includes('.lua/') ||
+                filename.includes('.lua\\') ||
                 filename.includes('node_modules/') ||
+                filename.includes('node_modules\\') ||
                 filename.includes('.git/') ||
+                filename.includes('.git\\') ||
                 filename.endsWith('.log') ||
-                filename.endsWith('.tmp'))) {
+                filename.endsWith('.tmp') ||
+                filename.endsWith('.js') ||
+                filename.endsWith('.map') ||
+                filename.includes('dist/') ||
+                filename.includes('dist\\'))) {
                 return;
             }
             // Debounce rapid changes
@@ -598,55 +597,59 @@ export async function devCommand() {
                 pendingCompile = true;
                 return;
             }
-            isCompiling = true;
-            pendingCompile = false;
-            try {
-                writeProgress(`🔄 File changed: ${filename} - Compiling and pushing...`);
-                // Compile the skill
-                await compileCommand();
-                // Read updated deploy.json
-                const updatedDeployData = readDeployJson();
-                if (!updatedDeployData) {
-                    writeProgress("❌ Compilation failed, skipping push");
-                    return;
-                }
-                // Verify version matches
-                if (updatedDeployData.version !== version) {
-                    writeProgress("❌ Version mismatch, skipping push");
+            // Clear any existing timeout
+            if (compileTimeout) {
+                clearTimeout(compileTimeout);
+            }
+            // Debounce file changes with a 500ms delay
+            compileTimeout = setTimeout(async () => {
+                if (isCompiling) {
                     return;
                 }
-                // Push to sandbox
-                const pushSuccess = await pushToSandbox(apiKey, agentId, skillId, updatedDeployData, false);
-                if (!pushSuccess) {
-                    writeProgress("❌ Failed to push to sandbox, will retry on next change");
+                isCompiling = true;
+                pendingCompile = false;
+                try {
+                    writeProgress(`🔄 File changed: ${filename} - Compiling and pushing...`);
+                    broadcastLog(`🔄 File changed: ${filename} - Compiling and pushing...`, 'info');
+                    // Compile the skill
+                    await compileCommand();
+                    broadcastLog("✅ Compilation completed", 'info');
+                    // Read updated deploy.json
+                    const updatedDeployData = readDeployJson();
+                    if (!updatedDeployData) {
+                        writeProgress("❌ Compilation failed, skipping push");
+                        return;
+                    }
+                    // Verify version matches
+                    if (updatedDeployData.version !== version) {
+                        writeProgress("❌ Version mismatch, skipping push");
+                        return;
+                    }
+                    // Push to sandbox
+                    const pushSuccess = await pushToSandbox(apiKey, agentId, skillId, updatedDeployData, false);
+                    if (!pushSuccess) {
+                        writeProgress("❌ Failed to push to sandbox, will retry on next change");
+                        broadcastLog("❌ Failed to push to sandbox, will retry on next change", 'error');
+                    }
+                    else {
+                        writeProgress("✅ Successfully pushed to sandbox");
+                        broadcastLog("✅ Successfully pushed to sandbox", 'info');
+                    }
                 }
-                else {
-                    // Broadcast reload message to all connected WebSocket clients
-                    wss.clients.forEach((client) => {
-                        if (client.readyState === 1) { // WebSocket.OPEN
-                            client.send(JSON.stringify({ type: 'reload', message: 'Files changed, reloading...' }));
-                        }
-                    });
+                catch (error) {
+                    writeProgress(`❌ Error during auto-compile: ${error instanceof Error ? error.message : 'Unknown error'}`);
                 }
-            }
-            catch (error) {
-                writeProgress(`❌ Error during auto-compile: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-            finally {
-                isCompiling = false;
-                // Handle any pending compile
-                if (pendingCompile) {
-                    setTimeout(() => {
-                        if (!isCompiling) {
-                            watcher.emit('change', 'pending', 'pending');
-                        }
-                    }, 100);
+                finally {
+                    isCompiling = false;
                 }
-            }
+            }, 500); // 500ms debounce delay
         });
         // Handle graceful shutdown
         process.on('SIGINT', () => {
             writeSuccess("\n🛑 Stopping file watcher...");
+            if (compileTimeout) {
+                clearTimeout(compileTimeout);
+            }
             watcher.close();
             process.exit(0);
         });

package/dist/commands/test.js

@@ -4,9 +4,10 @@ import inquirer from "inquirer";
 import { compileCommand } from "./compile.js";
 import { gunzipSync } from "zlib";
 import { Buffer } from "buffer";
-import { createRequire } from "module";
-import vm from "vm";
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
+import { loadApiKey } from "../services/auth.js";
+import { executeTool } from "../utils/sandbox.js";
+import { readSkillConfig } from "../utils/files.js";
 // Decompression utility
 function decompressCode(compressedCode) {
     const buffer = Buffer.from(compressedCode, 'base64');
@@ -32,6 +33,24 @@ export async function testCommand() {
         if (!deployData.tools || deployData.tools.length === 0) {
             throw new Error("No tools found in deploy.json");
         }
+        // Get API key from keystore and agent ID from YAML
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            throw new Error("No API key found. Please run 'lua auth configure' first.");
+        }
+        // Extract environment variables from YAML config
+        const config = readSkillConfig();
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua skill init' first.");
+        }
+        // Extract environment variables from YAML config
+        const envVars = {};
+        if (config?.skill?.env) {
+            for (const [key, value] of Object.entries(config.skill.env)) {
+                envVars[key] = value;
+            }
+        }
         // Let user select a tool using picker
         const toolChoices = deployData.tools.map((tool) => ({
             name: `${tool.name} - ${tool.description}`,
@@ -50,66 +69,122 @@ export async function testCommand() {
         clearPromptLines(2);
         writeProgress(`✅ Selected tool: ${selectedTool.name}`);
         // Get input values for each required parameter using inquirer
-        const inputValues = {};
+        let inputValues = {};
         const inputSchema = selectedTool.inputSchema;
         if (inputSchema.properties) {
             writeProgress("\n📝 Enter input values:");
-            const inputPrompts = [];
-            for (const [key, value] of Object.entries(inputSchema.properties)) {
-                const property = value;
-                const isRequired = inputSchema.required?.includes(key) || false;
-                let promptType = 'input';
-                let validate = undefined;
-                // Set up validation and input type based on schema
-                switch (property.type) {
-                    case "string":
-                        if (isRequired) {
-                            validate = (input) => input.trim() !== "" || `${key} is required`;
+            // Recursive function to generate prompts for nested objects
+            async function generatePromptsForObject(schema, prefix = '', required = []) {
+                const prompts = [];
+                const result = {};
+                for (const [key, value] of Object.entries(schema.properties || {})) {
+                    const property = value;
+                    const fullKey = prefix ? `${prefix}.${key}` : key;
+                    const isRequired = required.includes(key);
+                    if (property.type === "object" && property.properties) {
+                        // Handle nested object - use fullKey to maintain proper prompt names
+                        writeProgress(`\n📋 Entering values for ${key}:`);
+                        const nestedResult = await generatePromptsForObject(property, fullKey, property.required || []);
+                        // Extract the nested values from the nested result
+                        result[key] = nestedResult[key] || nestedResult;
+                    }
+                    else {
+                        // Handle primitive types
+                        let promptType = 'input';
+                        let validate = undefined;
+                        switch (property.type) {
+                            case "string":
+                                if (isRequired) {
+                                    validate = (input) => input.trim() !== "" || `${key} is required`;
+                                }
+                                break;
+                            case "number":
+                                promptType = 'number';
+                                if (isRequired) {
+                                    validate = (input) => !isNaN(input) || `${key} must be a valid number`;
+                                }
+                                break;
+                            case "boolean":
+                                promptType = 'confirm';
+                                break;
+                            default:
+                                if (isRequired) {
+                                    validate = (input) => input.trim() !== "" || `${key} is required`;
+                                }
                         }
-                        break;
-                    case "number":
-                        promptType = 'number';
-                        if (isRequired) {
-                            validate = (input) => !isNaN(input) || `${key} must be a valid number`;
+                        const prompt = {
+                            type: promptType,
+                            name: fullKey,
+                            message: `${key}${isRequired ? " (required)" : " (optional)"}:`,
+                            validate: validate,
+                        };
+                        prompts.push(prompt);
+                    }
+                }
+                if (prompts.length > 0) {
+                    const answers = await inquirer.prompt(prompts);
+                    // Convert answers to proper types and structure
+                    for (const [key, value] of Object.entries(answers)) {
+                        const keyParts = key.split('.');
+                        const propertyKey = keyParts[keyParts.length - 1];
+                        // For nested properties, we need to find the property in the original schema
+                        let currentSchema = inputSchema; // Use the original inputSchema
+                        let currentProperty = null;
+                        // Navigate through nested schemas to find the property
+                        for (let i = 0; i < keyParts.length; i++) {
+                            const part = keyParts[i];
+                            if (currentSchema.properties && currentSchema.properties[part]) {
+                                currentProperty = currentSchema.properties[part];
+                                if (i < keyParts.length - 1) {
+                                    // Move to nested schema
+                                    currentSchema = currentProperty;
+                                }
+                            }
                         }
-                        break;
-                    case "boolean":
-                        promptType = 'confirm';
-                        break;
-                    default:
-                        if (isRequired) {
-                            validate = (input) => input.trim() !== "" || `${key} is required`;
+                        if (currentProperty) {
+                            let convertedValue = value;
+                            switch (currentProperty.type) {
+                                case "number":
+                                    convertedValue = parseFloat(value);
+                                    break;
+                                case "boolean":
+                                    convertedValue = value;
+                                    break;
+                                default:
+                                    convertedValue = value;
+                            }
+                            // Check if field is optional and value is empty - skip if so
+                            // For nested properties, check the parent schema's required fields
+                            const parentSchema = keyParts.length > 1 ? currentSchema : schema;
+                            const isOptional = !parentSchema.required || !parentSchema.required.includes(propertyKey);
+                            const isEmpty = convertedValue === '' || convertedValue === null || convertedValue === undefined;
+                            if (isOptional && isEmpty) {
+                                // Skip optional empty fields
+                                continue;
+                            }
+                            // Build nested structure
+                            if (keyParts.length === 1) {
+                                // Top-level property
+                                result[propertyKey] = convertedValue;
+                            }
+                            else {
+                                // Nested property - build the nested structure
+                                let current = result;
+                                for (let i = 0; i < keyParts.length - 1; i++) {
+                                    const part = keyParts[i];
+                                    if (!current[part]) {
+                                        current[part] = {};
+                                    }
+                                    current = current[part];
+                                }
+                                current[propertyKey] = convertedValue;
+                            }
                         }
-                }
-                inputPrompts.push({
-                    type: promptType,
-                    name: key,
-                    message: `${key}${isRequired ? " (required)" : " (optional)"}:`,
-                    validate: validate,
-                    when: isRequired ? true : (answers) => {
-                        // For optional fields, ask if user wants to provide a value
-                        return true;
                     }
-                });
-            }
-            const answers = await inquirer.prompt(inputPrompts);
-            // Convert answers to proper types
-            for (const [key, value] of Object.entries(answers)) {
-                const property = inputSchema.properties[key];
-                switch (property.type) {
-                    case "string":
-                        inputValues[key] = value;
-                        break;
-                    case "number":
-                        inputValues[key] = parseFloat(value);
-                        break;
-                    case "boolean":
-                        inputValues[key] = value;
-                        break;
-                    default:
-                        inputValues[key] = value;
                 }
+                return result;
             }
+            inputValues = await generatePromptsForObject(inputSchema, '', inputSchema.required || []);
         }
         writeProgress("\n🚀 Executing tool...");
         writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
@@ -117,66 +192,12 @@ export async function testCommand() {
         const toolCode = decompressCode(selectedTool.execute);
         // Execute the tool
         try {
-            // Create a CommonJS context for execution
-            const require = createRequire(process.cwd() + '/package.json');
-            // Create a sandbox context with require and other necessary globals
-            const sandbox = {
-                require,
-                console,
-                Buffer,
-                setTimeout,
-                setInterval,
-                clearTimeout,
-                clearInterval,
-                process,
-                global: globalThis,
-                __dirname: process.cwd(),
-                __filename: path.join(process.cwd(), 'index.ts'),
-                module: { exports: {} },
-                exports: {},
-                // Web APIs
-                fetch: globalThis.fetch,
-                URLSearchParams: globalThis.URLSearchParams,
-                URL: globalThis.URL,
-                Headers: globalThis.Headers,
-                Request: globalThis.Request,
-                Response: globalThis.Response,
-                // Additional Node.js globals that might be needed
-                Object,
-                Array,
-                String,
-                Number,
-                Boolean,
-                Date,
-                Math,
-                JSON,
-                Error,
-                TypeError,
-                ReferenceError,
-                SyntaxError,
-                // Node.js specific globals
-                globalThis,
-                // Additional globals that might be referenced
-                undefined: undefined,
-                null: null,
-                Infinity: Infinity,
-                NaN: NaN
-            };
-            // Create the CommonJS wrapper code
-            const commonJsWrapper = `
-const executeFunction = ${toolCode};
-
-// Export the function for testing
-module.exports = async (input) => {
-  return await executeFunction(input);
-};
-`;
-            // Execute the code in the sandbox
-            const context = vm.createContext(sandbox);
-            vm.runInContext(commonJsWrapper, context);
-            // Get the exported function
-            const executeFunction = context.module.exports;
-            const result = await executeFunction(inputValues);
+            const result = await executeTool({
+                toolCode,
+                inputs: inputValues,
+                apiKey,
+                agentId
+            });
             writeSuccess("✅ Tool execution successful!");
             console.log(`Output: ${JSON.stringify(result, null, 2)}`);
         }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { user, createUserDataAPI, UserDataAPI } from './user-data-api.js';
+export { user, UserDataAPI } from './user-data-api.js';

package/dist/index.js

@@ -46,4 +46,4 @@ skillCommand
     .action(devCommand);
 program.parse(process.argv);
 // Export user data API for use in projects
-export { user, createUserDataAPI, UserDataAPI } from './user-data-api.js';
+export { user, UserDataAPI } from './user-data-api.js';

package/dist/services/api.d.ts

@@ -183,6 +183,12 @@ export declare class ToolApi {
     static deleteTool(url: string, apiKey: string): Promise<ApiResponse<any>>;
     static patchTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
 }
+export declare class UserDataApi {
+    static getUserData(apiKey: string, agentId: string): Promise<any>;
+    static createUserData(apiKey: string, agentId: string, data: any): Promise<any>;
+    static updateUserData(apiKey: string, agentId: string, data: any): Promise<ApiResponse<any>>;
+    static deleteUserData(apiKey: string, agentId: string): Promise<ApiResponse<any>>;
+}
 /**
  * Main API service that exports all API classes
  */