lua-cli 3.1.0-alpha.4 → 3.1.0

package/dist/utils/mcp-server-management.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MCP Server Management Utilities
+ * Handles MCP server configuration in lua.skill.yaml
+ */
+import { YamlConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected MCP servers exist in the YAML config and database.
+ * Uses upsert to create or update servers via API during compile (like skills).
+ * YAML only tracks name and ID - the full configuration stays in source code.
+ *
+ * @param mcpServersArray - Array of MCP servers detected from source code (with full config)
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated MCP servers array with IDs assigned
+ */
+export declare function ensureMCPServersExistInYaml(mcpServersArray: any[], config: YamlConfig): Promise<any[]>;
+/**
+ * Syncs the server MCP servers with the YAML configuration.
+ * Deletes MCP servers from the server that aren't in YAML (removed from source code).
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerMCPServersWithYaml(config: YamlConfig): Promise<string[]>;

package/dist/utils/mcp-server-management.js

@@ -0,0 +1,212 @@
+/**
+ * MCP Server Management Utilities
+ * Handles MCP server configuration in lua.skill.yaml
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { COMPILE_FILES, YAML_FORMAT, } from '../config/compile.constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { BASE_URLS } from '../config/constants.js';
+import DeveloperApi from '../api/developer.api.service.js';
+/**
+ * Ensures all detected MCP servers exist in the YAML config and database.
+ * Uses upsert to create or update servers via API during compile (like skills).
+ * YAML only tracks name and ID - the full configuration stays in source code.
+ *
+ * @param mcpServersArray - Array of MCP servers detected from source code (with full config)
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated MCP servers array with IDs assigned
+ */
+export async function ensureMCPServersExistInYaml(mcpServersArray, config) {
+    const existingServers = config?.mcpServers || [];
+    const existingServersMap = createMCPServersMap(existingServers);
+    const updatedServersArray = [];
+    let yamlUpdated = false;
+    // Process each detected MCP server from source code
+    for (const server of mcpServersArray) {
+        const existingServer = existingServersMap.get(server.name);
+        if (existingServer && existingServer.mcpServerId && existingServer.mcpServerId !== '') {
+            // Server exists with valid ID - reuse it
+            updatedServersArray.push({
+                ...server, // Full config from source code
+                mcpServerId: existingServer.mcpServerId // ID from YAML
+            });
+        }
+        else {
+            // Server doesn't exist or missing ID - upsert via API
+            const upsertedServer = await upsertMCPServerViaApi(server, config, existingServers, existingServer);
+            updatedServersArray.push(upsertedServer);
+            yamlUpdated = true;
+        }
+    }
+    // Update YAML file with tracking info (name + ID only)
+    if (yamlUpdated) {
+        await updateYamlWithMCPServers(updatedServersArray, config);
+    }
+    return updatedServersArray;
+}
+/**
+ * Creates a map of existing MCP servers for quick lookup by name.
+ */
+function createMCPServersMap(existingServers) {
+    const map = new Map();
+    existingServers.forEach((server) => {
+        map.set(server.name, server);
+    });
+    return map;
+}
+/**
+ * Creates or updates an MCP server via the Lua API (upsert by name).
+ *
+ * @param server - The MCP server to upsert (with full config)
+ * @param config - The skill configuration
+ * @param existingServers - Array of existing servers (mutated)
+ * @param existingServer - The existing server entry if one exists (may be without ID)
+ * @returns The server with its ID
+ */
+async function upsertMCPServerViaApi(server, config, existingServers, existingServer) {
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        }
+        // Prepare server data for upsert
+        const serverData = {
+            name: server.name,
+            transport: server.transport,
+            timeout: server.timeout,
+            ...(server.transport === 'stdio' ? {
+                command: server.command,
+                args: server.args,
+                env: server.env
+            } : {
+                url: server.url,
+                headers: server.headers
+            })
+        };
+        // Upsert server via API (creates if new, updates if exists by name)
+        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+        const result = await developerApi.upsertMCPServer(serverData);
+        if (!result.success || !result.data?.id) {
+            throw new Error(result.error?.message || 'Failed to upsert MCP server');
+        }
+        const mcpServerId = result.data.id;
+        // Update or add to existing servers array
+        if (existingServer) {
+            existingServer.mcpServerId = mcpServerId;
+        }
+        else {
+            existingServers.push({
+                name: server.name,
+                mcpServerId: mcpServerId
+            });
+        }
+        console.log(`  ✅ Synced MCP server "${server.name}" with ID: ${mcpServerId}`);
+        return {
+            ...server,
+            mcpServerId: mcpServerId
+        };
+    }
+    catch (error) {
+        console.error(`  ❌ Failed to sync MCP server "${server.name}":`, error.message);
+        throw error;
+    }
+}
+/**
+ * Updates the lua.skill.yaml file with MCP server tracking (name and ID only).
+ * IDs are assigned during compile via API (like skills).
+ * The full server configuration remains in the source code as the single source of truth.
+ */
+async function updateYamlWithMCPServers(mcpServers, config) {
+    const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
+    // Read existing content
+    let existingConfig = {};
+    if (fs.existsSync(yamlPath)) {
+        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+        existingConfig = yaml.load(yamlContent);
+    }
+    // Update MCP servers section - only track name and ID (like skills)
+    existingConfig.mcpServers = mcpServers.map(server => ({
+        name: server.name,
+        mcpServerId: server.mcpServerId // Always present after upsert during compile
+    }));
+    // Write updated YAML
+    const yamlContent = yaml.dump(existingConfig, {
+        indent: YAML_FORMAT.INDENT,
+        lineWidth: YAML_FORMAT.LINE_WIDTH,
+        noRefs: YAML_FORMAT.NO_REFS
+    });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
+/**
+ * Syncs the server MCP servers with the YAML configuration.
+ * Deletes MCP servers from the server that aren't in YAML (removed from source code).
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export async function syncServerMCPServersWithYaml(config) {
+    const messages = [];
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server MCP server sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found in lua.skill.yaml. Skipping server MCP server sync.");
+            return messages;
+        }
+        // Get MCP servers from server
+        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+        const serverMCPServersResponse = await developerApi.getMCPServers();
+        if (!serverMCPServersResponse.success || !serverMCPServersResponse.data) {
+            console.warn("⚠️  Could not retrieve server MCP servers. Skipping server MCP server sync.");
+            return messages;
+        }
+        const serverMCPServers = serverMCPServersResponse.data;
+        const yamlMCPServers = config?.mcpServers || [];
+        // Create map of YAML MCP servers by ID for efficient lookup
+        const yamlMCPServersMap = new Map(yamlMCPServers
+            .filter((server) => server.mcpServerId)
+            .map((server) => [server.mcpServerId, server]));
+        // Find MCP servers on server that aren't in YAML (removed from source code)
+        const serversToDelete = serverMCPServers.filter(serverMCP => !yamlMCPServersMap.has(serverMCP.id));
+        // Delete servers that are no longer in YAML
+        for (const server of serversToDelete) {
+            try {
+                const deleteResponse = await developerApi.deleteMCPServer(server.id);
+                if (deleteResponse.success) {
+                    const msg = `✅ Deleted MCP server "${server.name}" from server (removed from source code)`;
+                    messages.push(msg);
+                    console.log(msg);
+                }
+                else {
+                    const msg = `❌ Failed to delete MCP server "${server.name}": ${deleteResponse.error?.message || 'Unknown error'}`;
+                    messages.push(msg);
+                    console.error(msg);
+                }
+            }
+            catch (error) {
+                const msg = `❌ Error deleting MCP server "${server.name}": ${error}`;
+                messages.push(msg);
+                console.error(msg);
+            }
+        }
+        if (serversToDelete.length === 0) {
+            console.log("✅ Server MCP servers and YAML are fully in sync");
+        }
+    }
+    catch (error) {
+        console.error("❌ Error syncing server MCP servers:", error);
+    }
+    return messages;
+}

package/dist/utils/sandbox.d.ts

@@ -45,8 +45,10 @@ export declare function loadEnvironmentVariables(): Record<string, string>;
  * - Data: Custom data collections API
  * - Baskets: Shopping basket API
  * - Orders: Order management API
- * - Webhooks: Webhook management API (new)
- * - Jobs: Job scheduling API (new)
+ * - Templates: Template APIs (whatsapp)
+ * - CDN: File upload/retrieval API
+ * - Jobs: Job scheduling API
+ * - AI: AI generation API
  * - env(): Environment variable access function
  * - console, fetch, and other standard globals
  */

package/dist/utils/sandbox.js

@@ -12,6 +12,7 @@ import CustomDataApiService from "../api/custom.data.api.service.js";
 import WebhookApi from "../api/webhook.api.service.js";
 import JobApi from "../api/job.api.service.js";
 import WhatsAppTemplatesApiService from "../api/whatsapp-templates.api.service.js";
+import CdnApiService from "../api/cdn.api.service.js";
 import { BasketStatus } from "../interfaces/baskets.js";
 import { OrderStatus } from "../interfaces/orders.js";
 import { compressCode } from "./compile.js";
@@ -68,8 +69,10 @@ export function loadEnvironmentVariables() {
  * - Data: Custom data collections API
  * - Baskets: Shopping basket API
  * - Orders: Order management API
- * - Webhooks: Webhook management API (new)
- * - Jobs: Job scheduling API (new)
+ * - Templates: Template APIs (whatsapp)
+ * - CDN: File upload/retrieval API
+ * - Jobs: Job scheduling API
+ * - AI: AI generation API
  * - env(): Environment variable access function
  * - console, fetch, and other standard globals
  */
@@ -90,6 +93,7 @@ export function createSandbox(options) {
     const webhookService = new WebhookApi(BASE_URLS.API, apiKey, agentId);
     const jobService = new JobApi(BASE_URLS.API, apiKey, agentId);
     const whatsAppTemplatesService = new WhatsAppTemplatesApiService(BASE_URLS.API, apiKey, agentId);
+    const cdnService = new CdnApiService(BASE_URLS.CDN, apiKey);
     // Override User service methods if needed
     // Example: Override the update method
     // const originalUpdate = userService.update.bind(userService);
@@ -197,6 +201,8 @@ export function createSandbox(options) {
         Headers: globalThis.Headers,
         Request: globalThis.Request,
         Response: globalThis.Response,
+        File: globalThis.File,
+        Blob: globalThis.Blob,
         FormData: polyfills.FormData,
         AbortController: polyfills.AbortController,
         TextEncoder: polyfills.TextEncoder,
@@ -230,6 +236,8 @@ export function createSandbox(options) {
         Templates: {
             whatsapp: whatsAppTemplatesService
         },
+        // CDN API
+        CDN: cdnService,
         // Jobs API
         Jobs: {
             create: async (config) => {
@@ -258,7 +266,8 @@ export function createSandbox(options) {
                     activate: config.activate ?? true
                 });
             },
-            getJob: async (jobId) => jobService.getJob(jobId)
+            getJob: async (jobId) => jobService.getJob(jobId),
+            getAll: async (options = {}) => jobService.getAll(options)
         },
         // Environment variables function
         env: (key) => envVars[key],
@@ -327,6 +336,8 @@ try{
       global.Response = Response;
       global.URL = URL;
       global.URLSearchParams = URLSearchParams;
+      global.File = File;
+      global.Blob = Blob;
     }
   `, context);
     vm.runInContext(commonJsWrapper, context);
@@ -374,6 +385,8 @@ try{
       global.Response = Response;
       global.URL = URL;
       global.URLSearchParams = URLSearchParams;
+      global.File = File;
+      global.Blob = Blob;
     }
   `, context);
     vm.runInContext(commonJsWrapper, context);
@@ -449,6 +462,8 @@ try{
       global.Response = Response;
       global.URL = URL;
       global.URLSearchParams = URLSearchParams;
+      global.File = File;
+      global.Blob = Blob;
     }
   `, context);
     vm.runInContext(commonJsWrapper, context);
@@ -501,6 +516,8 @@ try{
       global.Response = Response;
       global.URL = URL;
       global.URLSearchParams = URLSearchParams;
+      global.File = File;
+      global.Blob = Blob;
     }
   `, context);
     vm.runInContext(commonJsWrapper, context);
@@ -553,6 +570,8 @@ try{
       global.Response = Response;
       global.URL = URL;
       global.URLSearchParams = URLSearchParams;
+      global.File = File;
+      global.Blob = Blob;
     }
   `, context);
     vm.runInContext(commonJsWrapper, context);