lua-cli 3.1.0-alpha.4 → 3.1.0

package/dist/commands/mcp.js

@@ -0,0 +1,393 @@
+/**
+ * MCP Command
+ * Manages Model Context Protocol (MCP) servers for agents
+ */
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
+import { BASE_URLS } from '../config/constants.js';
+import { safePrompt } from '../utils/prompt-handler.js';
+import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+import DeveloperApi from '../api/developer.api.service.js';
+/**
+ * Main MCP command - manages MCP servers
+ *
+ * Subcommands:
+ * - lua mcp list       - List all MCP servers
+ * - lua mcp activate   - Activate an MCP server
+ * - lua mcp deactivate - Deactivate an MCP server
+ * - lua mcp delete     - Delete an MCP server
+ *
+ * @param action - Optional action ('list', 'activate', 'deactivate', 'delete')
+ * @param serverName - Optional server name for actions
+ * @returns Promise that resolves when command completes
+ */
+export async function mcpCommand(action, serverName) {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // 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);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+        const context = {
+            agentId,
+            apiKey,
+            developerApi,
+        };
+        // Step 3: Handle action or show interactive menu
+        if (action) {
+            const normalizedAction = action.toLowerCase();
+            switch (normalizedAction) {
+                case 'list':
+                case 'ls':
+                    await listMCPServers(context);
+                    break;
+                case 'activate':
+                case 'enable':
+                    await activateMCPServer(context, serverName);
+                    break;
+                case 'deactivate':
+                case 'disable':
+                    await deactivateMCPServer(context, serverName);
+                    break;
+                case 'delete':
+                case 'rm':
+                    await deleteMCPServer(context, serverName);
+                    break;
+                default:
+                    console.error(`❌ Unknown action: "${action}"`);
+                    showUsage();
+                    process.exit(1);
+            }
+        }
+        else {
+            // Interactive mode
+            await interactiveMCPManagement(context);
+        }
+    }, "mcp");
+}
+/**
+ * Show usage information
+ */
+function showUsage() {
+    console.log('\nUsage:');
+    console.log('  lua mcp                        - Interactive MCP server management');
+    console.log('  lua mcp list                   - List all MCP servers');
+    console.log('  lua mcp activate [name]        - Activate an MCP server');
+    console.log('  lua mcp deactivate [name]      - Deactivate an MCP server');
+    console.log('  lua mcp delete [name]          - Delete an MCP server');
+    console.log('\nAliases:');
+    console.log('  list → ls');
+    console.log('  activate → enable');
+    console.log('  deactivate → disable');
+    console.log('  delete → rm');
+}
+/**
+ * Interactive MCP management
+ */
+async function interactiveMCPManagement(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🔌 MCP Server Management");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '📋 List MCP servers', value: 'list' },
+                    { name: '✅ Activate a server', value: 'activate' },
+                    { name: '⏸️  Deactivate a server', value: 'deactivate' },
+                    { name: '🗑️  Delete a server', value: 'delete' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'list':
+                await listMCPServers(context);
+                break;
+            case 'activate':
+                await activateMCPServer(context);
+                break;
+            case 'deactivate':
+                await deactivateMCPServer(context);
+                break;
+            case 'delete':
+                await deleteMCPServer(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * List all MCP servers
+ */
+async function listMCPServers(context) {
+    writeProgress("🔄 Loading MCP servers...");
+    try {
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        console.log("\n" + "=".repeat(60));
+        console.log("🔌 MCP Servers");
+        console.log("=".repeat(60) + "\n");
+        if (servers.length === 0) {
+            console.log("ℹ️  No MCP servers found.");
+            console.log("💡 Define MCP servers in your LuaAgent configuration and run 'lua push all'.\n");
+            return;
+        }
+        // Separate active and inactive servers
+        const activeServers = servers.filter((s) => s.active);
+        const inactiveServers = servers.filter((s) => !s.active);
+        if (activeServers.length > 0) {
+            console.log("✅ Active Servers:\n");
+            activeServers.forEach((server) => {
+                printServerInfo(server);
+            });
+        }
+        if (inactiveServers.length > 0) {
+            if (activeServers.length > 0)
+                console.log("─".repeat(40) + "\n");
+            console.log("⏸️  Inactive Servers:\n");
+            inactiveServers.forEach((server) => {
+                printServerInfo(server);
+            });
+        }
+        console.log("=".repeat(60) + "\n");
+    }
+    catch (error) {
+        console.error('\n❌ Error loading MCP servers:', error.message);
+    }
+}
+/**
+ * Print server information
+ */
+function printServerInfo(server) {
+    const statusIcon = server.active ? '🟢' : '⚪';
+    console.log(`${statusIcon} ${server.name}`);
+    console.log(`   Transport: ${server.transport}`);
+    if (server.transport === 'stdio') {
+        console.log(`   Command: ${server.command} ${(server.args || []).join(' ')}`);
+    }
+    else {
+        console.log(`   URL: ${server.url}`);
+    }
+    console.log(`   ID: ${server.id}`);
+    console.log();
+}
+/**
+ * Activate an MCP server
+ */
+async function activateMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        const inactiveServers = servers.filter((s) => !s.active);
+        if (inactiveServers.length === 0) {
+            console.log("\nℹ️  All MCP servers are already active.\n");
+            return;
+        }
+        let serverToActivate;
+        if (serverName) {
+            // Find by name
+            const server = inactiveServers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ Inactive MCP server "${serverName}" not found.\n`);
+                console.log("Available inactive servers:");
+                inactiveServers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToActivate = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to activate:',
+                    choices: inactiveServers.map((s) => ({
+                        name: `${s.name} (${s.transport})`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToActivate = answer.server;
+        }
+        writeProgress(`🔄 Activating ${serverToActivate.name}...`);
+        const activateResult = await context.developerApi.activateMCPServer(serverToActivate.id);
+        if (activateResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToActivate.name}" activated successfully!\n`);
+            writeInfo("💡 The server's tools are now available to your agent.");
+        }
+        else {
+            console.error(`\n❌ Failed to activate: ${activateResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error activating MCP server:', error.message);
+    }
+}
+/**
+ * Deactivate an MCP server
+ */
+async function deactivateMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        const activeServers = servers.filter((s) => s.active);
+        if (activeServers.length === 0) {
+            console.log("\nℹ️  No active MCP servers to deactivate.\n");
+            return;
+        }
+        let serverToDeactivate;
+        if (serverName) {
+            // Find by name
+            const server = activeServers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ Active MCP server "${serverName}" not found.\n`);
+                console.log("Available active servers:");
+                activeServers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToDeactivate = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to deactivate:',
+                    choices: activeServers.map((s) => ({
+                        name: `${s.name} (${s.transport})`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToDeactivate = answer.server;
+        }
+        writeProgress(`🔄 Deactivating ${serverToDeactivate.name}...`);
+        const deactivateResult = await context.developerApi.deactivateMCPServer(serverToDeactivate.id);
+        if (deactivateResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToDeactivate.name}" deactivated successfully!\n`);
+            writeInfo("💡 The server's tools are no longer available to your agent.");
+        }
+        else {
+            console.error(`\n❌ Failed to deactivate: ${deactivateResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error deactivating MCP server:', error.message);
+    }
+}
+/**
+ * Delete an MCP server
+ */
+async function deleteMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        if (servers.length === 0) {
+            console.log("\nℹ️  No MCP servers to delete.\n");
+            return;
+        }
+        let serverToDelete;
+        if (serverName) {
+            // Find by name
+            const server = servers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ MCP server "${serverName}" not found.\n`);
+                console.log("Available servers:");
+                servers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToDelete = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to delete:',
+                    choices: servers.map((s) => ({
+                        name: `${s.name} (${s.transport}) ${s.active ? '🟢' : '⚪'}`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToDelete = answer.server;
+        }
+        // Confirm deletion
+        console.log(`\n⚠️  You are about to delete MCP server: ${serverToDelete.name}`);
+        if (serverToDelete.active) {
+            console.log("⚠️  WARNING: This server is currently ACTIVE!");
+        }
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you sure you want to delete this MCP server?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deletion cancelled.\n");
+            return;
+        }
+        writeProgress(`🔄 Deleting ${serverToDelete.name}...`);
+        const deleteResult = await context.developerApi.deleteMCPServer(serverToDelete.id);
+        if (deleteResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToDelete.name}" deleted successfully!\n`);
+        }
+        else {
+            console.error(`\n❌ Failed to delete: ${deleteResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error deleting MCP server:', error.message);
+    }
+}

package/dist/commands/push.js

@@ -16,6 +16,7 @@ import { fetchVersions, publishVersion, } from '../utils/deploy-api.js';
 import { BASE_URLS } from '../config/constants.js';
 import PreProcessorApi from '../api/preprocessor.api.service.js';
 import PostProcessorApi from '../api/postprocessor.api.service.js';
+import DeveloperApi from '../api/developer.api.service.js';
 /**
  * Main push command - pushes a skill or persona version to the server.
  *
@@ -57,8 +58,8 @@ export async function pushCommand(type, cmdObj) {
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
-            if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", or "all".`);
+            if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor' && type !== 'mcp') {
+                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", "mcp", or "all".`);
                 console.log('\nUsage:');
                 console.log('  lua push                - Interactive selection');
                 console.log('  lua push skill          - Push a skill directly');
@@ -67,6 +68,7 @@ export async function pushCommand(type, cmdObj) {
                 console.log('  lua push job            - Push a job directly');
                 console.log('  lua push preprocessor   - Push a preprocessor directly');
                 console.log('  lua push postprocessor  - Push a postprocessor directly');
+                console.log('  lua push mcp            - Push an MCP server directly');
                 console.log('  lua push all --force    - Push all components without prompts');
                 process.exit(1);
             }
@@ -85,6 +87,7 @@ export async function pushCommand(type, cmdObj) {
                         { name: '⏰ Job', value: 'job' },
                         { name: '📥 PreProcessor', value: 'preprocessor' },
                         { name: '📤 PostProcessor', value: 'postprocessor' },
+                        { name: '🔌 MCP Server', value: 'mcp' },
                         { name: '🌙 Persona', value: 'persona' }
                     ]
                 }
@@ -111,6 +114,9 @@ export async function pushCommand(type, cmdObj) {
         else if (selectedType === 'postprocessor') {
             await pushPostProcessorVersion();
         }
+        else if (selectedType === 'mcp') {
+            await pushMCPServerVersion();
+        }
         else {
             await pushPersonaVersion();
         }
@@ -133,8 +139,9 @@ export async function pushCommand(type, cmdObj) {
  */
 async function pushSkillVersion() {
     // Step 1: Validate configuration
-    const config = readSkillConfig();
-    validatePushConfig(config);
+    const yamlConfig = readSkillConfig();
+    validatePushConfig(yamlConfig);
+    const config = yamlConfig;
     // Step 2: Get available skills and prompt for selection
     const availableSkills = getAvailableSkills(config);
     if (availableSkills.length === 0) {
@@ -912,8 +919,7 @@ async function pushPostProcessorVersion() {
                 description: bundledData.description || selected.description,
                 postprocessorId: selected.postprocessorId,
                 code: bundledData.code,
-                executeFunction: bundledData.executeFunction,
-                async: Boolean(bundledData.async ?? false) // Ensure boolean type
+                executeFunction: bundledData.executeFunction
             };
             writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
             const api = new PostProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);
@@ -1001,6 +1007,120 @@ function updateProcessorVersionInYaml(processorType, processorName, newVersion)
         console.warn('⚠️  Could not update processor version in YAML:', error);
     }
 }
+/**
+ * Push MCP Server to the server
+ */
+async function pushMCPServerVersion() {
+    try {
+        // Step 1: Run compilation
+        writeProgress("📦 Compiling project...");
+        await compileCommand();
+        writeSuccess("✅ Compilation complete");
+        // 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);
+        }
+        await checkApiKey(apiKey);
+        writeSuccess("✅ Authentication verified");
+        // Step 3: Read configuration
+        const config = readSkillConfig();
+        if (!config?.agent?.agentId) {
+            console.error("❌ No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
+            process.exit(1);
+        }
+        const mcpServers = config.mcpServers || [];
+        if (mcpServers.length === 0) {
+            console.error("❌ No MCP servers found in lua.skill.yaml.");
+            console.log("💡 Make sure you have defined MCP servers in your LuaAgent configuration.");
+            process.exit(1);
+        }
+        // Step 4: Load bundled MCP server data first (has full config)
+        const bundledServersPath = path.join(process.cwd(), 'dist', 'mcp-servers.json');
+        let bundledServers = [];
+        if (fs.existsSync(bundledServersPath)) {
+            bundledServers = JSON.parse(fs.readFileSync(bundledServersPath, 'utf8'));
+        }
+        else {
+            console.error('❌ Bundled MCP server data not found.');
+            console.log("💡 Please ensure your MCP servers are properly compiled.");
+            process.exit(1);
+        }
+        // Step 5: Select MCP server to push (use bundled data for display, YAML for ID tracking)
+        const serverAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedServer',
+                message: 'Select an MCP server to push:',
+                choices: bundledServers.map((server) => {
+                    const yamlEntry = mcpServers.find((s) => s.name === server.name);
+                    return {
+                        name: `${server.name} (${server.transport})`,
+                        value: { ...server, mcpServerId: yamlEntry?.mcpServerId }
+                    };
+                })
+            }
+        ]);
+        if (!serverAnswer) {
+            console.log("Push cancelled.");
+            return;
+        }
+        const selectedServer = serverAnswer.selectedServer;
+        const bundledServerData = selectedServer;
+        // Step 6: Prepare server data for push
+        const serverData = {
+            name: bundledServerData.name,
+            transport: bundledServerData.transport,
+            timeout: bundledServerData.timeout,
+            ...(bundledServerData.transport === 'stdio' ? {
+                command: bundledServerData.command,
+                args: bundledServerData.args,
+                env: bundledServerData.env
+            } : {
+                url: bundledServerData.url,
+                headers: bundledServerData.headers
+            })
+        };
+        // Step 7: Push to server (upsert)
+        writeProgress(`\n🚀 Pushing MCP server "${selectedServer.name}" to server...`);
+        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, config.agent.agentId);
+        const result = await developerApi.upsertMCPServer(serverData);
+        if (result.success && result.data) {
+            writeSuccess(`\n✅ MCP server "${selectedServer.name}" pushed successfully\n`);
+            // Ask if user wants to activate now
+            const activateAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'activateNow',
+                    message: 'Would you like to activate this MCP server now?',
+                    default: false
+                }
+            ]);
+            if (activateAnswer && activateAnswer.activateNow) {
+                writeProgress("🔄 Activating MCP server...");
+                const activateResult = await developerApi.activateMCPServer(result.data.id);
+                if (activateResult.success) {
+                    writeSuccess(`\n✅ MCP server "${selectedServer.name}" activated successfully\n`);
+                    writeInfo("💡 The server's tools are now available to your agent.");
+                }
+                else {
+                    console.error(`❌ Failed to activate: ${activateResult.error?.message}`);
+                }
+            }
+            else {
+                writeInfo("💡 You can activate this server later using: lua mcp activate");
+            }
+        }
+        else {
+            console.error(`❌ Failed to push: ${result.error?.message}`);
+        }
+    }
+    catch (error) {
+        console.error('❌ Error pushing MCP server:', error);
+        process.exit(1);
+    }
+}
 /**
  * Deploy a version immediately after pushing
  */
@@ -1189,7 +1309,7 @@ async function pushAllCommand(options) {
                 const pushData = {
                     name: webhookConfig.name,
                     version: newVersion,
-                    description: webhookData.description || webhookConfig.description || '',
+                    description: webhookData.description || '',
                     webhookId: webhookConfig.webhookId,
                     querySchema: webhookData.querySchema,
                     headerSchema: webhookData.headerSchema,
@@ -1249,14 +1369,14 @@ async function pushAllCommand(options) {
                 const pushData = {
                     name: jobConfig.name,
                     version: newVersion,
-                    description: jobData.description || jobConfig.description || '',
+                    description: jobData.description || '',
                     jobId: jobConfig.jobId,
                     schedule: jobData.schedule || jobConfig.schedule,
                     timeout: jobData.timeout,
                     retry: jobData.retry,
                     code: jobData.code,
                     executeFunction: jobData.executeFunction,
-                    metadata: jobData.metadata || jobConfig.metadata
+                    metadata: jobData.metadata
                 };
                 // Push version using fetch
                 const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/version`, {
@@ -1313,7 +1433,7 @@ async function pushAllCommand(options) {
                 const versionData = {
                     name: processorConfig.name,
                     version: newVersion,
-                    description: processorData.description || processorConfig.description || '',
+                    description: processorData.description || '',
                     preprocessorId: preprocessorId,
                     code: processorData.code,
                     executeFunction: processorData.executeFunction,
@@ -1367,11 +1487,10 @@ async function pushAllCommand(options) {
                 const versionData = {
                     name: processorConfig.name,
                     version: newVersion,
-                    description: processorData.description || processorConfig.description || '',
+                    description: processorData.description || '',
                     postprocessorId: postprocessorId,
                     code: processorData.code,
-                    executeFunction: processorData.executeFunction,
-                    async: Boolean(processorData.async ?? false)
+                    executeFunction: processorData.executeFunction
                 };
                 // Push version
                 const result = await postprocessorService.pushPostProcessor(postprocessorId, versionData);
@@ -1392,7 +1511,46 @@ async function pushAllCommand(options) {
             }
         }
     }
-    // Step 9: Deploy all components if autoDeploy is enabled
+    // Step 9: Push MCP server configurations
+    const mcpServersJsonPath = path.join(process.cwd(), 'dist', 'mcp-servers.json');
+    if (fs.existsSync(mcpServersJsonPath)) {
+        const mcpServers = JSON.parse(fs.readFileSync(mcpServersJsonPath, 'utf8'));
+        if (mcpServers.length > 0) {
+            writeProgress(`\n🔌 Pushing ${mcpServers.length} MCP server(s)...`);
+            try {
+                const DeveloperApi = (await import('../api/developer.api.service.js')).default;
+                const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+                for (const serverConfig of mcpServers) {
+                    try {
+                        // Upsert the MCP server (create or update by name)
+                        const result = await developerApi.upsertMCPServer(serverConfig);
+                        if (result.success && result.data) {
+                            const mcpServerId = result.data.id;
+                            const isActive = result.data.active;
+                            writeSuccess(`  ✅ ${serverConfig.name} (${serverConfig.transport}) - ${isActive ? 'active' : 'inactive'}`);
+                            // Auto-activate if autoDeploy is enabled
+                            if (options.autoDeploy && !isActive) {
+                                const activateResult = await developerApi.activateMCPServer(mcpServerId);
+                                if (activateResult.success) {
+                                    writeSuccess(`     🔌 Auto-activated`);
+                                }
+                            }
+                        }
+                        else {
+                            console.error(`  ❌ Failed to push ${serverConfig.name}:`, result.error?.message);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`  ❌ Failed to push ${serverConfig.name}:`, error.message);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push MCP servers:`, error.message);
+            }
+        }
+    }
+    // Step 10: Deploy all components if autoDeploy is enabled
     if (options.autoDeploy && (toDeploySkills.length > 0 || toDeployWebhooks.length > 0 || toDeployJobs.length > 0 || toDeployPreprocessors.length > 0 || toDeployPostprocessors.length > 0)) {
         writeProgress('\n🚀 Deploying all pushed versions to production...');
         writeInfo('⏱️  Waiting for server to process versions (5 seconds)...\n');

package/dist/common/data.entry.instance.d.ts

@@ -32,7 +32,7 @@ export default class DataEntryInstance {
      * @returns Promise resolving to the updated data
      * @throws Error if the update fails
      */
-    update(data: Record<string, any>, searchText?: string): Promise<any>;
+    update(data: Record<string, any>, searchText?: string): Promise<Record<string, any>>;
     /**
      * Deletes the custom data entry
      * @returns Promise resolving to true if deletion was successful