lua-cli 1.3.2-alpha.3 → 2.0.1

package/dist/commands/deploy.js

@@ -45,7 +45,7 @@ export async function deployCommand() {
         // Load API key
         const apiKey = await loadApiKey();
         if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua configure' to set up your API key.");
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
             process.exit(1);
         }
         // Validate API key

package/dist/commands/dev.js

@@ -1,13 +1,12 @@
 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 { executeTool, createBroadcastConsole } from '../utils/sandbox.js';
+import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from '../utils/sandbox.js';
 import { readSkillConfig, updateSkillYamlPersona } from '../utils/files.js';
-import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from '../utils/cli.js';
+import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import keytar from 'keytar';
 import { watch } from 'fs';
 import { createServer } from 'http';
@@ -19,26 +18,64 @@ const __dirname = path.dirname(__filename);
 const SANDBOX_SERVICE = "lua-cli-sandbox";
 const SANDBOX_ACCOUNT = "sandbox-skill-id";
 // Function to get sandbox skill ID from secure storage
-async function getSandboxSkillId() {
+async function getSandboxSkillId(skillName) {
     try {
-        return await keytar.getPassword(SANDBOX_SERVICE, SANDBOX_ACCOUNT);
+        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(skillId) {
+async function setSandboxSkillId(sandboxId, skillName) {
     try {
-        await keytar.setPassword(SANDBOX_SERVICE, SANDBOX_ACCOUNT, skillId);
+        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: [
                 {
@@ -47,12 +84,7 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 }
             ],
             navigate: true,
-            skillOverride: [
-                {
-                    skillId: skillId,
-                    sandboxId: sandboxId
-                }
-            ]
+            skillOverride: skillOverride
         };
         // Add persona override if provided
         if (persona) {
@@ -122,6 +154,120 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
             }
             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 => {
@@ -145,6 +291,50 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
             });
             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 {
@@ -152,10 +342,23 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                 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: deployData.tools || []
+                        tools: tools
                     }));
                 }
                 else {
@@ -185,20 +388,33 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                         return;
                     }
                     const deployData = JSON.parse(fs.readFileSync(deployPath, 'utf8'));
-                    const tool = deployData.tools.find((t) => t.name === toolName);
+                    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;
                     }
-                    // Extract environment variables from YAML config
-                    const config = readSkillConfig();
-                    const envVars = {};
-                    if (config?.skill?.env) {
-                        for (const [key, value] of Object.entries(config.skill.env)) {
-                            envVars[key] = value;
-                        }
-                    }
+                    // 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');
@@ -209,8 +425,21 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                         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));
@@ -225,6 +454,18 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
                         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,
@@ -337,8 +578,7 @@ function createChatServer(apiKey, agentId, skillId, sandboxId, port = 3000) {
 // 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);
+        // console.log('Calling UPDATE endpoint for sandbox version');
         const response = await ApiService.Skill.updateDevSkill(apiKey, agentId, skillId, sandboxVersionId, versionData);
         if (response.success) {
             return {
@@ -372,8 +612,7 @@ export async function updateDevVersion(apiKey, agentId, skillId, sandboxVersionI
 // 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}`);
+        // console.log(`🔗 Calling CREATE endpoint for sandbox version`);
         const response = await ApiService.Skill.pushDevSkill(apiKey, agentId, skillId, versionData);
         if (response.success) {
             return {
@@ -416,15 +655,42 @@ function readDeployJson() {
     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 and environment variables from config
-    const config = readSkillConfig();
-    const skillName = config?.skill?.name || deployData.name || 'Unknown Skill';
-    const envVars = config?.skill?.env || {};
+// 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 = {
-        ...deployData,
+        ...skillData,
         name: skillName,
         env: envVars
     };
@@ -436,8 +702,8 @@ async function pushToSandbox(apiKey, agentId, skillId, deployData, isInitial = f
         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}`);
+                // writeSuccess(`✅ Version ${updateResult.data.version} updated in sandbox successfully`);
+                // writeSuccess(`🔑 Sandbox Skill ID: ${updateResult.data.skillId}`);
             }
             return true;
         }
@@ -459,7 +725,7 @@ async function pushToSandbox(apiKey, agentId, skillId, deployData, isInitial = f
     const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithNameAndEnv);
     if (result.success && result.data) {
         // Store the new sandbox skill ID
-        await setSandboxSkillId(result.data.skillId);
+        await setSandboxSkillId(result.data.skillId, skillName);
         if (!isInitial) {
             writeSuccess(`✅ Version ${result.data.version} pushed to sandbox successfully`);
             writeSuccess(`🔑 Sandbox Skill ID: ${result.data.skillId}`);
@@ -493,26 +759,13 @@ export async function devCommand() {
             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);
+        // 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
         }
-        // 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);
+        if (!version) {
+            version = "1.0.0"; // Default version
         }
         // Load API key
         const apiKey = await loadApiKey();
@@ -526,33 +779,51 @@ export async function devCommand() {
         // Compile the skill first
         writeProgress("🔄 Compiling skill...");
         await compileCommand();
+        // Re-read config after compilation to get updated skillIds
+        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 version matches
-        if (deployData.version !== version) {
-            console.error(`❌ Version mismatch: config has ${version}, deploy.json has ${deployData.version}`);
+        // 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 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");
+        // 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
+        }
+        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
-        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.");
+        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);
         }
-        // Get the sandbox skill ID for chat
-        const sandboxSkillId = await getSandboxSkillId();
+        writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+        // Use the first skill's sandbox ID for the web interface
+        const firstSkillName = Object.keys(sandboxIds)[0];
+        const sandboxSkillId = sandboxIds[firstSkillName];
         if (!sandboxSkillId) {
             console.error("❌ No sandbox skill ID found. Cannot start chat interface.");
             process.exit(1);
@@ -620,20 +891,20 @@ export async function devCommand() {
                         writeProgress("❌ Compilation failed, skipping push");
                         return;
                     }
-                    // Verify version matches
-                    if (updatedDeployData.version !== version) {
-                        writeProgress("❌ Version mismatch, skipping push");
+                    // 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 to sandbox
-                    const pushSuccess = await pushToSandbox(apiKey, agentId, skillId, updatedDeployData, false);
-                    if (!pushSuccess) {
-                        writeProgress("❌ Failed to push to sandbox, will retry on next change");
-                        broadcastLog("❌ Failed to push to sandbox, will retry on next change", 'error');
+                    // 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 to sandbox");
-                        broadcastLog("✅ Successfully pushed to sandbox", 'info');
+                        // writeProgress(`✅ Successfully pushed ${Object.keys(updatedSandboxIds).length} skills to sandbox`);
+                        broadcastLog(`✅ Successfully pushed ${Object.keys(updatedSandboxIds).length} skills to sandbox`, 'info');
                     }
                 }
                 catch (error) {