lua-cli 1.2.1 → 1.3.0

package/dist/commands/dev.js

@@ -0,0 +1,656 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import { compileCommand } from './compile.js';
+import { checkApiKey, loadApiKey } from '../services/auth.js';
+import { ApiService } from '../services/api.js';
+import { readSkillConfig, updateSkillYamlPersona } from '../utils/files.js';
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from '../utils/cli.js';
+import keytar from 'keytar';
+import { watch } from 'fs';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import open from 'open';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Constants for sandbox skill ID storage
+const SANDBOX_SERVICE = "lua-cli-sandbox";
+const SANDBOX_ACCOUNT = "sandbox-skill-id";
+// Function to get sandbox skill ID from secure storage
+async function getSandboxSkillId() {
+    try {
+        return await keytar.getPassword(SANDBOX_SERVICE, SANDBOX_ACCOUNT);
+    }
+    catch (error) {
+        return null;
+    }
+}
+// Function to store sandbox skill ID in secure storage
+async function setSandboxSkillId(skillId) {
+    try {
+        await keytar.setPassword(SANDBOX_SERVICE, SANDBOX_ACCOUNT, skillId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+// Function to send chat message to API
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona) {
+    try {
+        const chatRequest = {
+            messages: [
+                {
+                    type: "text",
+                    text: message
+                }
+            ],
+            navigate: true,
+            skillOverride: [
+                {
+                    skillId: skillId,
+                    sandboxId: sandboxId
+                }
+            ]
+        };
+        // Add persona override if provided
+        if (persona) {
+            chatRequest.personaOverride = persona;
+        }
+        const response = await ApiService.Chat.sendMessage(agentId, chatRequest, apiKey);
+        if (!response.success) {
+            console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
+            return null;
+        }
+        return response.data?.text || null;
+    }
+    catch (error) {
+        console.error("❌ Error sending chat message:", error);
+        return null;
+    }
+}
+// Function to create and start web server for chat interface
+function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
+    const server = createServer((req, res) => {
+        // Enable CORS
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/chat') {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk.toString();
+            });
+            req.on('end', async () => {
+                try {
+                    const { message, persona } = JSON.parse(body);
+                    const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        success: response !== null,
+                        text: response || 'Error sending message',
+                        error: response === null ? 'Failed to send message' : null
+                    }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'Invalid request' }));
+                }
+            });
+            return;
+        }
+        // Persona management endpoints
+        if (req.method === 'GET' && req.url === '/persona') {
+            try {
+                const config = readSkillConfig();
+                const persona = config?.agent?.persona || '';
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    success: true,
+                    persona: persona
+                }));
+            }
+            catch (error) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: 'Failed to read persona' }));
+            }
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/persona') {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk.toString();
+            });
+            req.on('end', async () => {
+                try {
+                    const { persona } = JSON.parse(body);
+                    // Update the YAML file
+                    updateSkillYamlPersona(persona);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        success: true,
+                        message: 'Persona updated successfully'
+                    }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'Failed to update persona' }));
+                }
+            });
+            return;
+        }
+        // Tools endpoints
+        if (req.method === 'GET' && req.url === '/tools') {
+            try {
+                // Read the deploy.json file to get tools
+                const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+                if (fs.existsSync(deployPath)) {
+                    const deployData = JSON.parse(fs.readFileSync(deployPath, 'utf8'));
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        success: true,
+                        tools: deployData.tools || []
+                    }));
+                }
+                else {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'deploy.json not found' }));
+                }
+            }
+            catch (error) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: 'Failed to load tools' }));
+            }
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/tools/test') {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk.toString();
+            });
+            req.on('end', async () => {
+                try {
+                    const { toolName, inputs } = JSON.parse(body);
+                    // Read deploy.json to get the tool's execute function
+                    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+                    if (!fs.existsSync(deployPath)) {
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: 'deploy.json not found' }));
+                        return;
+                    }
+                    const deployData = JSON.parse(fs.readFileSync(deployPath, 'utf8'));
+                    const tool = deployData.tools.find((t) => t.name === toolName);
+                    if (!tool) {
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: 'Tool not found' }));
+                        return;
+                    }
+                    // Decompress and execute the tool
+                    const { gunzipSync } = await import('zlib');
+                    const { Buffer } = await import('buffer');
+                    const { createRequire } = await import('module');
+                    const vm = await import('vm');
+                    function decompressCode(compressedCode) {
+                        const buffer = Buffer.from(compressedCode, 'base64');
+                        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);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        success: true,
+                        result: result
+                    }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        success: false,
+                        error: error.message || 'Tool execution failed'
+                    }));
+                }
+            });
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/') {
+            // Read the React app HTML template
+            const htmlTemplate = fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'web', 'index.html'), 'utf8');
+            // Replace placeholders with actual values
+            const html = htmlTemplate
+                .replace('{{API_KEY}}', apiKey)
+                .replace('{{AGENT_ID}}', agentId)
+                .replace('{{SKILL_ID}}', skillId)
+                .replace('{{SANDBOX_ID}}', sandboxId);
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(html);
+            return;
+        }
+        // Serve the React app bundle
+        if (req.method === 'GET' && req.url === '/app.js') {
+            try {
+                const appJs = fs.readFileSync(path.join(__dirname, '..', '..', 'dist', 'web', 'app.js'), 'utf8');
+                res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                res.end(appJs);
+            }
+            catch (error) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('React app not found. Please run the build process.');
+            }
+            return;
+        }
+        // Serve the CSS files
+        if (req.method === 'GET' && req.url === '/app.css') {
+            try {
+                const appCss = fs.readFileSync(path.join(__dirname, '..', '..', 'dist', 'web', 'app.css'), 'utf8');
+                res.writeHead(200, { 'Content-Type': 'text/css' });
+                res.end(appCss);
+            }
+            catch (error) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('CSS not found');
+            }
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/tools-page.css') {
+            try {
+                const toolsPageCss = fs.readFileSync(path.join(__dirname, '..', '..', 'dist', 'web', 'tools-page.css'), 'utf8');
+                res.writeHead(200, { 'Content-Type': 'text/css' });
+                res.end(toolsPageCss);
+            }
+            catch (error) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Tools page CSS not found');
+            }
+            return;
+        }
+        res.writeHead(404);
+        res.end('Not Found');
+    });
+    // Create WebSocket server for live reload
+    const wss = new WebSocketServer({ server });
+    wss.on('connection', (ws) => {
+        console.log('WebSocket client connected for live reload');
+        ws.on('close', () => {
+            console.log('WebSocket client disconnected');
+        });
+        ws.on('error', (error) => {
+            console.error('WebSocket error:', error);
+        });
+    });
+    server.listen(port, () => {
+        console.log('Chat interface available at: http://localhost:' + port);
+        console.log('Live reload WebSocket available at: ws://localhost:' + port);
+    });
+    return { server, wss };
+}
+// Function to update existing sandbox version
+export async function updateDevVersion(apiKey, agentId, skillId, sandboxVersionId, versionData) {
+    try {
+        const url = 'http://localhost:3022/developer/skills/' + agentId + '/' + skillId + '/version/sandbox/' + sandboxVersionId;
+        console.log('Calling UPDATE endpoint: ' + url);
+        const response = await ApiService.Skill.updateDevSkill(apiKey, agentId, skillId, sandboxVersionId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("Network error updating dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+// Function to create new sandbox version
+export async function pushDevVersion(apiKey, agentId, skillId, versionData) {
+    try {
+        const url = `http://localhost:3022/developer/skills/${agentId}/${skillId}/version/sandbox`;
+        console.log(`🔗 Calling CREATE endpoint: ${url}`);
+        const response = await ApiService.Skill.pushDevSkill(apiKey, agentId, skillId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("❌ Network error pushing dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+function readConfigSkillName() {
+    const config = readSkillConfig();
+    return config?.skill?.name || null;
+}
+function readConfigVersion() {
+    const config = readSkillConfig();
+    return config?.skill?.version || null;
+}
+function readDeployJson() {
+    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployPath)) {
+        return null;
+    }
+    const deployContent = fs.readFileSync(deployPath, 'utf8');
+    return JSON.parse(deployContent);
+}
+// 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 = {
+        ...deployData,
+        name: skillName || deployData.name || 'Unknown Skill'
+    };
+    if (sandboxSkillId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress("🔄 Updating existing sandbox version...");
+        }
+        const updateResult = await updateDevVersion(apiKey, agentId, skillId, sandboxSkillId, payloadWithName);
+        if (updateResult.success && updateResult.data) {
+            if (!isInitial) {
+                writeSuccess(`✅ Version ${updateResult.data.version} updated in sandbox successfully`);
+                writeSuccess(`🔑 Sandbox Skill ID: ${updateResult.data.skillId}`);
+            }
+            return true;
+        }
+        else if (updateResult.error) {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update existing sandbox, creating new one...");
+                console.error(`❌ Sandbox update failed: ${updateResult.error.message}`);
+                if (updateResult.error.error) {
+                    console.error(`   Details: ${updateResult.error.error}`);
+                }
+            }
+            // Fall through to create new sandbox
+        }
+    }
+    // Create new sandbox version (either no existing ID or update failed)
+    if (!isInitial) {
+        writeProgress("🔄 Creating new sandbox version...");
+    }
+    const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithName);
+    if (result.success && result.data) {
+        // Store the new sandbox skill ID
+        await setSandboxSkillId(result.data.skillId);
+        if (!isInitial) {
+            writeSuccess(`✅ Version ${result.data.version} pushed to sandbox successfully`);
+            writeSuccess(`🔑 Sandbox Skill ID: ${result.data.skillId}`);
+        }
+        return true;
+    }
+    else if (result.error) {
+        if (!isInitial) {
+            console.error(`❌ Sandbox creation failed: ${result.error.message}`);
+            if (result.error.error) {
+                console.error(`   Details: ${result.error.error}`);
+            }
+            if (result.error.statusCode) {
+                console.error(`   Status Code: ${result.error.statusCode}`);
+            }
+        }
+        return false;
+    }
+    else {
+        if (!isInitial) {
+            console.error("❌ Failed to push version to sandbox. Please try again.");
+        }
+        return false;
+    }
+}
+export async function devCommand() {
+    return withErrorHandling(async () => {
+        // Check if we're in a skill directory
+        const config = readSkillConfig();
+        if (!config) {
+            console.error("❌ No lua.skill.yaml found. Please run this command from a skill directory.");
+            process.exit(1);
+        }
+        // Read version from config
+        const version = config.skill?.version;
+        if (!version) {
+            console.error("❌ No version found in skill configuration");
+            process.exit(1);
+        }
+        // Confirm with user
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: `Are you sure you want to push version ${version} to sandbox?`,
+                default: false
+            }
+        ]);
+        // Clear the confirmation prompt lines
+        clearPromptLines(2);
+        if (!confirmed) {
+            console.log("❌ Dev push cancelled.");
+            process.exit(0);
+        }
+        // Load API key
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        // Validate API key
+        const userData = await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        // Compile the skill first
+        writeProgress("🔄 Compiling skill...");
+        await compileCommand();
+        // Read deploy.json
+        const deployData = readDeployJson();
+        if (!deployData) {
+            console.error("❌ No deploy.json found. Compilation may have failed.");
+            process.exit(1);
+        }
+        // Verify version matches
+        if (deployData.version !== version) {
+            console.error(`❌ Version mismatch: config has ${version}, deploy.json has ${deployData.version}`);
+            process.exit(1);
+        }
+        // Extract agentId and skillId from config
+        const agentId = config.agent?.agentId;
+        const skillId = config.skill?.skillId;
+        if (!agentId || !skillId) {
+            console.error("❌ Missing agentId or skillId in skill configuration");
+            process.exit(1);
+        }
+        // Initial push to sandbox
+        writeProgress("🔄 Pushing to sandbox...");
+        const initialSuccess = await pushToSandbox(apiKey, agentId, skillId, deployData, true);
+        if (!initialSuccess) {
+            console.error("❌ Failed to push to sandbox. Cannot start development mode.");
+            process.exit(1);
+        }
+        // Get the sandbox skill ID for chat
+        const sandboxSkillId = await getSandboxSkillId();
+        if (!sandboxSkillId) {
+            console.error("❌ No sandbox skill ID found. Cannot start chat interface.");
+            process.exit(1);
+        }
+        // Start web server for chat interface
+        const chatPort = 3000;
+        const { server, wss } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, chatPort);
+        // Open browser to chat interface
+        try {
+            await open(`http://localhost:${chatPort}`);
+            writeSuccess("🌐 Chat interface opened in your browser");
+        }
+        catch (error) {
+            writeSuccess(`🌐 Chat interface available at: http://localhost:${chatPort}`);
+        }
+        // Start file watching
+        writeSuccess("🔍 Watching for file changes... (Press Ctrl+C to stop)");
+        let isCompiling = false;
+        let pendingCompile = false;
+        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('node_modules/') ||
+                filename.includes('.git/') ||
+                filename.endsWith('.log') ||
+                filename.endsWith('.tmp'))) {
+                return;
+            }
+            // Debounce rapid changes
+            if (isCompiling) {
+                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");
+                    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");
+                }
+                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'}`);
+            }
+            finally {
+                isCompiling = false;
+                // Handle any pending compile
+                if (pendingCompile) {
+                    setTimeout(() => {
+                        if (!isCompiling) {
+                            watcher.emit('change', 'pending', 'pending');
+                        }
+                    }, 100);
+                }
+            }
+        });
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            writeSuccess("\n🛑 Stopping file watcher...");
+            watcher.close();
+            process.exit(0);
+        });
+        // Keep the process alive
+        return new Promise(() => { });
+    }, "dev push");
+}

package/dist/commands/index.d.ts

@@ -2,6 +2,8 @@ export { configureCommand } from "./configure.js";
 export { initCommand } from "./init.js";
 export { destroyCommand } from "./destroy.js";
 export { apiKeyCommand } from "./apiKey.js";
-export { agentsCommand } from "./agents.js";
-export { deployCommand } from "./deploy.js";
+export { compileCommand } from "./compile.js";
 export { testCommand } from "./test.js";
+export { pushCommand } from "./push.js";
+export { deployCommand } from "./deploy.js";
+export { devCommand } from "./dev.js";

package/dist/commands/index.js

@@ -2,6 +2,8 @@ export { configureCommand } from "./configure.js";
 export { initCommand } from "./init.js";
 export { destroyCommand } from "./destroy.js";
 export { apiKeyCommand } from "./apiKey.js";
-export { agentsCommand } from "./agents.js";
-export { deployCommand } from "./deploy.js";
+export { compileCommand } from "./compile.js";
 export { testCommand } from "./test.js";
+export { pushCommand } from "./push.js";
+export { deployCommand } from "./deploy.js";
+export { devCommand } from "./dev.js";