lua-cli 2.2.8-alpha.1 → 2.3.0-alpha.1

package/dist/commands/dev.js

@@ -1,821 +1,75 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+/**
+ * Dev Command
+ * Orchestrates the development mode with live reloading, chat interface, and tool testing
+ */
+import open from 'open';
 import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
-import { ApiService } from '../services/api.js';
-import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from '../utils/sandbox.js';
-import { readSkillConfig, updateSkillYamlPersona } from '../utils/files.js';
+import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, 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(skillName) {
-    try {
-        const account = skillName ? `${SANDBOX_ACCOUNT}_${skillName}` : SANDBOX_ACCOUNT;
-        return await keytar.getPassword(SANDBOX_SERVICE, account);
-    }
-    catch (error) {
-        return null;
-    }
-}
-// Function to store sandbox skill ID in secure storage
-async function setSandboxSkillId(sandboxId, skillName) {
-    try {
-        const account = skillName ? `${SANDBOX_ACCOUNT}_${skillName}` : SANDBOX_ACCOUNT;
-        await keytar.setPassword(SANDBOX_SERVICE, account, sandboxId);
-    }
-    catch (error) {
-        // Ignore storage errors
-    }
-}
-// Function to get all sandbox skill IDs for all skills
-async function getAllSandboxSkillIds() {
-    const skillOverrides = [];
-    try {
-        // Read deploy.json to get all skills
-        const deployData = readDeployJson();
-        if (!deployData || !deployData.skills || !Array.isArray(deployData.skills)) {
-            return skillOverrides;
-        }
-        // For each skill, get its sandbox ID
-        for (const skill of deployData.skills) {
-            if (skill.skillId && skill.name) {
-                const sandboxId = await getSandboxSkillId(skill.name);
-                if (sandboxId) {
-                    skillOverrides.push({
-                        skillId: skill.skillId,
-                        sandboxId: sandboxId
-                    });
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error('Error getting sandbox skill IDs:', error);
-    }
-    return skillOverrides;
-}
-// Function to send chat message to API
-export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona) {
-    try {
-        // Get all sandbox skill IDs for skill override
-        const allSkillOverrides = await getAllSandboxSkillIds();
-        // If no skills found, fallback to the provided skillId and sandboxId
-        const skillOverride = allSkillOverrides.length > 0 ? allSkillOverrides : [
-            {
-                skillId: skillId,
-                sandboxId: sandboxId
-            }
-        ];
-        const chatRequest = {
-            messages: [
-                {
-                    type: "text",
-                    text: message
-                }
-            ],
-            navigate: true,
-            skillOverride: skillOverride
-        };
-        // 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 === 'GET' && req.url === '/api/config') {
-            try {
-                const config = readSkillConfig();
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    agent: {
-                        agentId: config?.agent?.agentId || '',
-                        orgId: config?.agent?.orgId || ''
-                    }
-                }));
-            }
-            catch (error) {
-                console.error('Error reading config:', error);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Failed to read configuration' }));
-            }
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/api/skills') {
-            (async () => {
-                try {
-                    const skillsData = [];
-                    // First try to read from deploy.json in the .lua directory
-                    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
-                    if (fs.existsSync(deployPath)) {
-                        // Read from compiled deploy.json
-                        const deployData = JSON.parse(fs.readFileSync(deployPath, 'utf8'));
-                        if (deployData.skills && Array.isArray(deployData.skills)) {
-                            // New format with skills array
-                            for (const skill of deployData.skills) {
-                                const sandboxId = await getSandboxSkillId(skill.name);
-                                skillsData.push({
-                                    name: skill.name || 'Unnamed Skill',
-                                    description: skill.description || 'A Lua skill for AI automation',
-                                    context: skill.context || '',
-                                    version: skill.version || '1.0.0',
-                                    skillId: skill.skillId || '',
-                                    sandboxId: sandboxId || '',
-                                    tools: skill.tools ? skill.tools.map((tool) => tool.name) : []
-                                });
-                            }
-                        }
-                        else {
-                            // Legacy format fallback
-                            const toolNames = Object.keys(deployData.tools || {});
-                            const sandboxId = await getSandboxSkillId(); // Legacy uses no skill name
-                            skillsData.push({
-                                name: deployData.name || 'Current Skill',
-                                description: deployData.description || 'A Lua skill for AI automation',
-                                context: deployData.context || '',
-                                version: deployData.version || '1.0.0',
-                                skillId: deployData.skillId || '',
-                                sandboxId: sandboxId || '',
-                                tools: toolNames
-                            });
-                        }
-                    }
-                    else {
-                        // Fallback: Read from YAML and scan tools directory
-                        const config = readSkillConfig();
-                        const toolsDir = path.join(process.cwd(), 'src', 'tools');
-                        let toolNames = [];
-                        if (fs.existsSync(toolsDir)) {
-                            const toolFiles = fs.readdirSync(toolsDir)
-                                .filter((file) => file.endsWith('.ts'))
-                                .map((file) => file.replace('.ts', ''));
-                            toolNames = toolFiles;
-                        }
-                        if (config?.skills && Array.isArray(config.skills)) {
-                            // New format: multiple skills
-                            for (const skill of config.skills) {
-                                const sandboxId = await getSandboxSkillId(skill.name);
-                                skillsData.push({
-                                    name: skill.name || 'Unnamed Skill',
-                                    description: 'A Lua skill for AI automation (not compiled)',
-                                    context: 'This skill has not been compiled yet. Run "lua compile" to see full context information.',
-                                    version: skill.version || '1.0.0',
-                                    skillId: skill.skillId || '',
-                                    sandboxId: sandboxId || '',
-                                    tools: toolNames // All tools for now since not compiled
-                                });
-                            }
-                        }
-                        else if (config?.skill) {
-                            // Legacy format: single skill
-                            const sandboxId = await getSandboxSkillId(); // Legacy uses no skill name
-                            skillsData.push({
-                                name: config.skill.name || 'Current Skill',
-                                description: 'A Lua skill for AI automation (not compiled)',
-                                context: 'This skill has not been compiled yet. Run "lua compile" to see full context information.',
-                                version: config.skill.version || '1.0.0',
-                                skillId: config.skill.skillId || '',
-                                sandboxId: sandboxId || '',
-                                tools: toolNames
-                            });
-                        }
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        success: true,
-                        skills: skillsData
-                    }));
-                }
-                catch (error) {
-                    console.error('Error reading skills:', error);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        success: false,
-                        error: 'Failed to read skills configuration'
-                    }));
-                }
-            })();
-            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;
-        }
-        // Environment variables endpoints
-        if (req.method === 'GET' && req.url === '/env') {
-            try {
-                const envPath = path.join(process.cwd(), '.env');
-                let envContent = '';
-                if (fs.existsSync(envPath)) {
-                    envContent = fs.readFileSync(envPath, 'utf8');
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    success: true,
-                    content: envContent
-                }));
-            }
-            catch (error) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, error: 'Failed to read .env file' }));
-            }
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/env') {
-            let body = '';
-            req.on('data', chunk => {
-                body += chunk.toString();
-            });
-            req.on('end', async () => {
-                try {
-                    const { content } = JSON.parse(body);
-                    const envPath = path.join(process.cwd(), '.env');
-                    // Write the .env file
-                    fs.writeFileSync(envPath, content || '', 'utf8');
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        success: true,
-                        message: 'Environment variables updated successfully'
-                    }));
-                }
-                catch (error) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ success: false, error: 'Failed to update .env file' }));
-                }
-            });
-            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'));
-                    // Handle both new skills array format and legacy tools format
-                    let tools = deployData.tools || {};
-                    if (deployData.skills && Array.isArray(deployData.skills)) {
-                        // New format: merge all tools from all skills
-                        tools = {};
-                        deployData.skills.forEach((skill) => {
-                            if (skill.tools && Array.isArray(skill.tools)) {
-                                skill.tools.forEach((tool) => {
-                                    tools[tool.name] = tool;
-                                });
-                            }
-                        });
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        success: true,
-                        tools: 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'));
-                    let tool = null;
-                    if (deployData.skills && Array.isArray(deployData.skills)) {
-                        // New format: search through skills array
-                        for (const skill of deployData.skills) {
-                            if (skill.tools && Array.isArray(skill.tools)) {
-                                tool = skill.tools.find((t) => t.name === toolName);
-                                if (tool)
-                                    break;
-                            }
-                        }
-                    }
-                    else {
-                        // Legacy format: search in tools object
-                        if (deployData.tools && deployData.tools[toolName]) {
-                            tool = {
-                                name: toolName,
-                                ...deployData.tools[toolName]
-                            };
-                        }
-                    }
-                    if (!tool) {
-                        res.writeHead(404, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ success: false, error: 'Tool not found' }));
-                        return;
-                    }
-                    // Load environment variables from all sources (.env + yaml)
-                    const envVars = loadEnvironmentVariables();
-                    // 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);
-                    // Broadcast tool test start
-                    wss.clients.forEach((client) => {
-                        if (client.readyState === 1) {
-                            client.send(JSON.stringify({
-                                type: 'log',
-                                subType: 'info',
-                                message: `🧪 Testing tool: ${toolName}`,
-                                timestamp: new Date().toISOString(),
-                                id: Date.now().toString()
-                            }));
-                        }
-                    });
-                    // Create custom console that captures output and sends via WebSocket
-                    const customConsole = createBroadcastConsole((logData) => {
-                        console.log('Broadcasting tool log:', 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
-                    });
-                    // Broadcast tool test completion
-                    wss.clients.forEach((client) => {
-                        if (client.readyState === 1) {
-                            client.send(JSON.stringify({
-                                type: 'log',
-                                subType: 'info',
-                                message: `✅ Tool test completed: ${toolName}`,
-                                timestamp: new Date().toISOString(),
-                                id: (Date.now() + 1).toString()
-                            }));
-                        }
-                    });
-                    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 from dist directory
-            const htmlTemplate = fs.readFileSync(path.join(__dirname, '..', '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, '..', '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, '..', '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, '..', '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 log streaming
-    const wss = new WebSocketServer({ server });
-    wss.on('connection', (ws) => {
-        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('Log streaming WebSocket available at: ws://localhost:' + port);
-    });
-    // 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) {
-    try {
-        // console.log('Calling UPDATE endpoint for sandbox version');
-        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 {
-        // console.log(`🔗 Calling CREATE endpoint for sandbox version`);
-        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 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 multiple skills to sandbox
-async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial = false) {
-    const sandboxIds = {};
-    if (!deployData.skills || !Array.isArray(deployData.skills)) {
-        throw new Error("No skills found in deploy data");
-    }
-    for (const skill of deployData.skills) {
-        if (!skill.skillId) {
-            console.warn(`⚠️  Skipping skill ${skill.name} - no skillId found`);
-            continue;
-        }
-        try {
-            const success = await pushSingleSkillToSandbox(apiKey, agentId, skill.skillId, skill, isInitial);
-            if (success) {
-                // Get the sandbox ID for this skill (stored in .lua directory)
-                const sandboxId = await getSandboxSkillId(skill.name);
-                if (sandboxId) {
-                    sandboxIds[skill.name] = sandboxId;
-                }
-            }
-        }
-        catch (error) {
-            console.error(`❌ Failed to push skill ${skill.name}:`, error);
-        }
-    }
-    return sandboxIds;
-}
-// Function to push a single skill to sandbox (extracted for reuse)
-async function pushSingleSkillToSandbox(apiKey, agentId, skillId, skillData, isInitial = false) {
-    const skillName = skillData.name || 'Unknown Skill';
-    const sandboxSkillId = await getSandboxSkillId(skillName);
-    // Load environment variables
-    const envVars = loadEnvironmentVariables();
-    // console.log(skillData);
-    const payloadWithNameAndEnv = {
-        ...skillData,
-        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, payloadWithNameAndEnv);
-        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, payloadWithNameAndEnv);
-    if (result.success && result.data) {
-        // Store the new sandbox skill ID
-        await setSandboxSkillId(result.data.skillId, skillName);
-        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;
-    }
-}
+import { pushSkillsToSandbox } from '../utils/dev-api.js';
+import { createChatServer } from '../utils/dev-server.js';
+import { createFileWatcher } from '../utils/dev-watcher.js';
+import { readConfigVersion, readDeployJson, extractSkillId, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
+import { DEV_SERVER_PORT } from '../config/dev.constants.js';
+/**
+ * Main dev command - starts development mode with live reloading.
+ *
+ * This command performs the following steps:
+ * 1. Validates configuration and authentication
+ * 2. Compiles the skill
+ * 3. Pushes all skills to sandbox environment
+ * 4. Starts web server with chat interface and tool testing
+ * 5. Opens browser to chat interface
+ * 6. Watches for file changes and auto-recompiles
+ *
+ * Features:
+ * - Live chat interface for testing skills
+ * - Real-time tool testing with WebSocket log streaming
+ * - Automatic recompilation and push on file changes
+ * - Environment variable management
+ * - Persona configuration
+ * - Multi-skill support
+ *
+ * @returns Promise that resolves when dev mode is stopped (never resolves normally)
+ */
 export async function devCommand() {
     return withErrorHandling(async () => {
-        // Check if we're in a skill directory
+        // Step 1: Validate configuration
         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 (handle both old and new formats)
-        let version = config.skill?.version; // Legacy format
-        if (!version && config.skills && config.skills.length > 0) {
-            version = config.skills[0].version; // New format - use first skill's version
-        }
-        if (!version) {
-            version = "1.0.0"; // Default version
-        }
-        // Load API key
+        validateConfig(config);
+        const version = readConfigVersion(config);
+        // Step 2: Authenticate
         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
+        // Step 3: Compile the skill
         writeProgress("🔄 Compiling skill...");
         await compileCommand();
-        // Re-read config after compilation to get updated skillIds
+        // Step 4: Read and validate compiled output
         const updatedConfig = readSkillConfig();
         if (!updatedConfig) {
             console.error("❌ Failed to read updated skill configuration after compilation.");
             process.exit(1);
         }
-        // Read deploy.json
         const deployData = readDeployJson();
-        if (!deployData) {
-            console.error("❌ No deploy.json found. Compilation may have failed.");
-            process.exit(1);
-        }
-        // Verify deploy.json has skills
-        if (!deployData.skills || !Array.isArray(deployData.skills) || deployData.skills.length === 0) {
-            console.error("❌ No skills found in deploy.json. Compilation may have failed.");
-            process.exit(1);
-        }
-        // Extract agentId from updated config
-        const agentId = updatedConfig.agent?.agentId;
-        if (!agentId) {
-            console.error("❌ Missing agentId in skill configuration");
-            process.exit(1);
-        }
-        // For multi-skill projects, we'll use the first skill's ID for sandbox
-        let skillId = updatedConfig.skill?.skillId; // Legacy format
-        if (!skillId && updatedConfig.skills && updatedConfig.skills.length > 0) {
-            skillId = updatedConfig.skills[0].skillId; // New format - use first skill
-        }
+        validateDeployData(deployData);
+        // Step 5: Extract configuration values
+        validateAgentConfig(updatedConfig);
+        const agentId = updatedConfig.agent.agentId;
+        const skillId = extractSkillId(updatedConfig);
         if (!skillId) {
             console.error("❌ No skillId found after compilation. Skill creation may have failed.");
             console.error("Available skills:", updatedConfig.skills);
             process.exit(1);
         }
-        // Initial push to sandbox
+        // Step 6: Push skills to sandbox
         writeProgress("🔄 Pushing skills to sandbox...");
         const sandboxIds = await pushSkillsToSandbox(apiKey, agentId, deployData, true);
-        // console.log(sandboxIds);
         if (Object.keys(sandboxIds).length === 0) {
             console.error("❌ Failed to push any skills to sandbox. Cannot start development mode.");
             process.exit(1);
@@ -828,100 +82,31 @@ export async function devCommand() {
             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, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, chatPort);
-        // Open browser to chat interface
+        // Step 7: Start web server for chat interface
+        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, DEV_SERVER_PORT);
+        // Step 8: Open browser to chat interface
         try {
-            await open(`http://localhost:${chatPort}`);
+            await open(`http://localhost:${DEV_SERVER_PORT}`);
             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');
+            writeSuccess(`🌐 Chat interface available at: http://localhost:${DEV_SERVER_PORT}`);
+            broadcastLog(`🌐 Chat interface available at: http://localhost:${DEV_SERVER_PORT}`, 'info');
         }
-        // Start file watching
+        // Step 9: 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('.js') ||
-                filename.endsWith('.map') ||
-                filename.includes('dist/') ||
-                filename.includes('dist\\'))) {
-                return;
-            }
-            // Debounce rapid changes
-            if (isCompiling) {
-                pendingCompile = true;
-                return;
-            }
-            // Clear any existing timeout
-            if (compileTimeout) {
-                clearTimeout(compileTimeout);
-            }
-            // Debounce file changes with a 500ms delay
-            compileTimeout = setTimeout(async () => {
-                if (isCompiling) {
-                    return;
-                }
-                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 updated deploy.json has skills
-                    if (!updatedDeployData.skills || !Array.isArray(updatedDeployData.skills) || updatedDeployData.skills.length === 0) {
-                        writeProgress("❌ No skills found in updated deploy.json, skipping push");
-                        return;
-                    }
-                    // Push all skills to sandbox
-                    const updatedSandboxIds = await pushSkillsToSandbox(apiKey, agentId, updatedDeployData, false);
-                    if (Object.keys(updatedSandboxIds).length === 0) {
-                        writeProgress("❌ Failed to push any skills to sandbox, will retry on next change");
-                        broadcastLog("❌ Failed to push skills to sandbox, will retry on next change", 'error');
-                    }
-                    else {
-                        // writeProgress(`✅ Successfully pushed ${Object.keys(updatedSandboxIds).length} skills to sandbox`);
-                        broadcastLog(`✅ Successfully pushed ${Object.keys(updatedSandboxIds).length} skills to sandbox`, 'info');
-                    }
-                }
-                catch (error) {
-                    writeProgress(`❌ Error during auto-compile: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                }
-                finally {
-                    isCompiling = false;
-                }
-            }, 500); // 500ms debounce delay
+        const { watcher, cleanup } = createFileWatcher({
+            apiKey,
+            agentId,
+            readDeployJson,
+            broadcastLog,
         });
-        // Handle graceful shutdown
+        // Step 10: Handle graceful shutdown
         process.on('SIGINT', () => {
             writeSuccess("\n🛑 Stopping file watcher...");
-            if (compileTimeout) {
-                clearTimeout(compileTimeout);
-            }
-            watcher.close();
+            cleanup();
             process.exit(0);
         });
         // Keep the process alive