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

package/dist/utils/dev-server.js

@@ -0,0 +1,555 @@
+/**
+ * Dev Server Utilities
+ * Handles HTTP server, WebSocket connections, and all HTTP endpoints for dev mode
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { readSkillConfig, updateSkillYamlPersona } from './files.js';
+import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from './sandbox.js';
+import { getSandboxSkillId } from './sandbox-storage.js';
+import { sendChatMessage } from './dev-api.js';
+import { CORS_HEADERS, HTTP_STATUS, DEV_DEFAULTS } from '../config/dev.constants.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Reads the deploy.json file from .lua directory
+ *
+ * @returns Parsed deploy data or null if not found
+ */
+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);
+}
+/**
+ * Creates and starts the dev web server with chat interface and tool testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param port - Port to run server on
+ * @returns Server instance with WebSocket and broadcast function
+ */
+export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
+    const deployData = readDeployJson();
+    const server = createServer((req, res) => {
+        // Enable CORS
+        Object.entries(CORS_HEADERS).forEach(([key, value]) => {
+            res.setHeader(key, value);
+        });
+        if (req.method === 'OPTIONS') {
+            res.writeHead(HTTP_STATUS.OK);
+            res.end();
+            return;
+        }
+        // Route handlers
+        if (req.method === 'POST' && req.url === '/chat') {
+            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/persona') {
+            handleGetPersonaEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/persona') {
+            handlePostPersonaEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/api/config') {
+            handleGetConfigEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/api/skills') {
+            handleGetSkillsEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/env') {
+            handleGetEnvEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/env') {
+            handlePostEnvEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/tools') {
+            handleGetToolsEndpoint(req, res);
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/tools/test') {
+            handleToolTestEndpoint(req, res, apiKey, agentId, wss);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/') {
+            handleIndexEndpoint(req, res, apiKey, agentId, skillId, sandboxId);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/app.js') {
+            handleStaticFile(req, res, 'app.js', 'application/javascript');
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/app.css') {
+            handleStaticFile(req, res, 'app.css', 'text/css');
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/tools-page.css') {
+            handleStaticFile(req, res, 'tools-page.css', 'text/css');
+            return;
+        }
+        res.writeHead(HTTP_STATUS.NOT_FOUND);
+        res.end('Not Found');
+    });
+    // Create WebSocket server for log streaming
+    const wss = new WebSocketServer({ server });
+    wss.on('connection', (ws) => {
+        ws.on('close', () => {
+            // 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, () => {
+        // Server started
+    });
+    // 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 };
+}
+// ============================================================================
+// ENDPOINT HANDLERS
+// ============================================================================
+/**
+ * Handles POST /chat - Send chat messages
+ */
+function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData) {
+    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, deployData);
+            res.writeHead(HTTP_STATUS.OK, { '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(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Invalid request' }));
+        }
+    });
+}
+/**
+ * Handles GET /persona - Get current persona
+ */
+function handleGetPersonaEndpoint(req, res) {
+    try {
+        const config = readSkillConfig();
+        const persona = config?.agent?.persona || '';
+        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            persona: persona
+        }));
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'Failed to read persona' }));
+    }
+}
+/**
+ * Handles POST /persona - Update persona
+ */
+function handlePostPersonaEndpoint(req, res) {
+    let body = '';
+    req.on('data', (chunk) => {
+        body += chunk.toString();
+    });
+    req.on('end', async () => {
+        try {
+            const { persona } = JSON.parse(body);
+            updateSkillYamlPersona(persona);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                message: 'Persona updated successfully'
+            }));
+        }
+        catch (error) {
+            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Failed to update persona' }));
+        }
+    });
+}
+/**
+ * Handles GET /api/config - Get agent configuration
+ */
+function handleGetConfigEndpoint(req, res) {
+    try {
+        const config = readSkillConfig();
+        res.writeHead(HTTP_STATUS.OK, { '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(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Failed to read configuration' }));
+    }
+}
+/**
+ * Handles GET /api/skills - Get all skills information
+ */
+function handleGetSkillsEndpoint(req, res) {
+    (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 || DEV_DEFAULTS.SKILL_NAME,
+                            description: skill.description || DEV_DEFAULTS.DESCRIPTION,
+                            context: skill.context || '',
+                            version: skill.version || DEV_DEFAULTS.VERSION,
+                            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 || DEV_DEFAULTS.DESCRIPTION,
+                        context: deployData.context || '',
+                        version: deployData.version || DEV_DEFAULTS.VERSION,
+                        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 || DEV_DEFAULTS.SKILL_NAME,
+                            description: DEV_DEFAULTS.NOT_COMPILED_DESCRIPTION,
+                            context: DEV_DEFAULTS.NOT_COMPILED_CONTEXT,
+                            version: skill.version || DEV_DEFAULTS.VERSION,
+                            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: DEV_DEFAULTS.NOT_COMPILED_DESCRIPTION,
+                        context: DEV_DEFAULTS.NOT_COMPILED_CONTEXT,
+                        version: config.skill.version || DEV_DEFAULTS.VERSION,
+                        skillId: config.skill.skillId || '',
+                        sandboxId: sandboxId || '',
+                        tools: toolNames
+                    });
+                }
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                skills: skillsData
+            }));
+        }
+        catch (error) {
+            console.error('Error reading skills:', error);
+            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: 'Failed to read skills configuration'
+            }));
+        }
+    })();
+}
+/**
+ * Handles GET /env - Get environment variables
+ */
+function handleGetEnvEndpoint(req, res) {
+    try {
+        const envPath = path.join(process.cwd(), '.env');
+        let envContent = '';
+        if (fs.existsSync(envPath)) {
+            envContent = fs.readFileSync(envPath, 'utf8');
+        }
+        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            content: envContent
+        }));
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'Failed to read .env file' }));
+    }
+}
+/**
+ * Handles POST /env - Update environment variables
+ */
+function handlePostEnvEndpoint(req, res) {
+    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(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                message: 'Environment variables updated successfully'
+            }));
+        }
+        catch (error) {
+            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Failed to update .env file' }));
+        }
+    });
+}
+/**
+ * Handles GET /tools - Get all tools
+ */
+function handleGetToolsEndpoint(req, res) {
+    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(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                tools: tools
+            }));
+        }
+        else {
+            res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'deploy.json not found' }));
+        }
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'Failed to load tools' }));
+    }
+}
+/**
+ * Handles POST /tools/test - Test a tool
+ */
+function handleToolTestEndpoint(req, res, apiKey, agentId, wss) {
+    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(HTTP_STATUS.NOT_FOUND, { '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(HTTP_STATUS.NOT_FOUND, { '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');
+            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) => {
+                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(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                result: result
+            }));
+        }
+        catch (error) {
+            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: error.message || 'Tool execution failed'
+            }));
+        }
+    });
+}
+/**
+ * Handles GET / - Serve main HTML page
+ */
+function handleIndexEndpoint(req, res, apiKey, agentId, skillId, sandboxId) {
+    // 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(HTTP_STATUS.OK, { 'Content-Type': 'text/html' });
+    res.end(html);
+}
+/**
+ * Handles static file serving (JS, CSS)
+ */
+function handleStaticFile(req, res, filename, contentType) {
+    try {
+        const content = fs.readFileSync(path.join(__dirname, '..', 'web', filename), 'utf8');
+        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': contentType });
+        res.end(content);
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'text/plain' });
+        res.end(`${filename} not found`);
+    }
+}

package/dist/utils/dev-watcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Dev File Watcher Utilities
+ * Handles file system watching and automatic recompilation
+ */
+/**
+ * Configuration for file watcher
+ */
+export interface FileWatcherConfig {
+    apiKey: string;
+    agentId: string;
+    readDeployJson: () => any | null;
+    broadcastLog: (message: string, subType?: 'info' | 'warn' | 'error' | 'debug') => void;
+}
+/**
+ * Checks if a file should be ignored during watching.
+ *
+ * @param filename - The filename to check
+ * @returns True if file should be ignored, false otherwise
+ */
+export declare function shouldIgnoreFile(filename: string | null): boolean;
+/**
+ * Creates and starts a file watcher for development mode.
+ * Watches for file changes and automatically recompiles and pushes to sandbox.
+ *
+ * @param config - File watcher configuration
+ * @returns The watcher instance
+ */
+export declare function createFileWatcher(config: FileWatcherConfig): {
+    watcher: import("fs").FSWatcher;
+    cleanup: () => void;
+};

package/dist/utils/dev-watcher.js

@@ -0,0 +1,110 @@
+/**
+ * Dev File Watcher Utilities
+ * Handles file system watching and automatic recompilation
+ */
+import { watch } from 'fs';
+import { compileCommand } from '../commands/compile.js';
+import { pushSkillsToSandbox } from './dev-api.js';
+import { writeProgress } from './cli.js';
+import { FILE_WATCH_CONFIG, WATCH_IGNORE_PATTERNS, WATCH_IGNORE_EXTENSIONS, } from '../config/dev.constants.js';
+/**
+ * Checks if a file should be ignored during watching.
+ *
+ * @param filename - The filename to check
+ * @returns True if file should be ignored, false otherwise
+ */
+export function shouldIgnoreFile(filename) {
+    if (!filename) {
+        return true;
+    }
+    // Check ignore patterns
+    for (const pattern of WATCH_IGNORE_PATTERNS) {
+        if (filename.includes(pattern)) {
+            return true;
+        }
+    }
+    // Check ignore extensions
+    for (const ext of WATCH_IGNORE_EXTENSIONS) {
+        if (filename.endsWith(ext)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Creates and starts a file watcher for development mode.
+ * Watches for file changes and automatically recompiles and pushes to sandbox.
+ *
+ * @param config - File watcher configuration
+ * @returns The watcher instance
+ */
+export function createFileWatcher(config) {
+    const { apiKey, agentId, readDeployJson, broadcastLog } = config;
+    let isCompiling = false;
+    let pendingCompile = false;
+    let compileTimeout = null;
+    const watcher = watch(process.cwd(), { recursive: FILE_WATCH_CONFIG.RECURSIVE }, async (eventType, filename) => {
+        // Ignore changes in build artifacts and dependencies
+        if (shouldIgnoreFile(filename)) {
+            return;
+        }
+        // Debounce rapid changes
+        if (isCompiling) {
+            pendingCompile = true;
+            return;
+        }
+        // Clear any existing timeout
+        if (compileTimeout) {
+            clearTimeout(compileTimeout);
+        }
+        // Debounce file changes with configured 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 {
+                    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;
+            }
+        }, FILE_WATCH_CONFIG.DEBOUNCE_DELAY);
+    });
+    // Handle graceful shutdown
+    const cleanup = () => {
+        if (compileTimeout) {
+            clearTimeout(compileTimeout);
+        }
+        watcher.close();
+    };
+    return { watcher, cleanup };
+}