lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/utils/sandbox.d.ts

@@ -8,6 +8,27 @@ export interface ExecuteToolOptions extends SandboxOptions {
     toolCode: string;
     inputs: any;
 }
+export interface ExecuteWebhookOptions extends SandboxOptions {
+    webhookCode: string;
+    query: any;
+    headers: any;
+    body: any;
+}
+export interface ExecuteJobOptions extends SandboxOptions {
+    jobCode: string;
+    jobData?: any;
+}
+export interface ExecutePreProcessorOptions extends SandboxOptions {
+    processorCode: string;
+    message: string;
+    channel: string;
+}
+export interface ExecutePostProcessorOptions extends SandboxOptions {
+    processorCode: string;
+    message: string;
+    response: string;
+    channel: string;
+}
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
@@ -16,13 +37,52 @@ export interface ExecuteToolOptions extends SandboxOptions {
  */
 export declare function loadEnvironmentVariables(): Record<string, string>;
 /**
- * Creates a VM sandbox context with all necessary globals and utilities
+ * Creates a VM sandbox context with all necessary globals and utilities.
+ *
+ * Available globals in the sandbox:
+ * - User: User data API
+ * - Products: Product catalog API
+ * - Data: Custom data collections API
+ * - Baskets: Shopping basket API
+ * - Orders: Order management API
+ * - Webhooks: Webhook management API (new)
+ * - Jobs: Job scheduling API (new)
+ * - env(): Environment variable access function
+ * - console, fetch, and other standard globals
  */
 export declare function createSandbox(options: SandboxOptions): any;
 /**
  * Executes a tool in a VM sandbox
  */
 export declare function executeTool(options: ExecuteToolOptions): Promise<any>;
+/**
+ * Executes a webhook in a sandboxed environment.
+ *
+ * @param options - Webhook execution options including code and request data
+ * @returns Result from webhook execution
+ */
+export declare function executeWebhook(options: ExecuteWebhookOptions): Promise<any>;
+/**
+ * Executes a job in a sandboxed environment.
+ *
+ * @param options - Job execution options including code and job data
+ * @returns Result from job execution
+ */
+export declare function executeJob(options: ExecuteJobOptions): Promise<any>;
+/**
+ * Executes a preprocessor in a sandboxed environment.
+ *
+ * @param options - PreProcessor execution options
+ * @returns Processed message string
+ */
+export declare function executePreProcessor(options: ExecutePreProcessorOptions): Promise<string>;
+/**
+ * Executes a postprocessor in a sandboxed environment.
+ *
+ * @param options - PostProcessor execution options
+ * @returns Processed response string
+ */
+export declare function executePostProcessor(options: ExecutePostProcessorOptions): Promise<string>;
 /**
  * Creates a custom console that broadcasts logs via WebSocket
  */

package/dist/utils/sandbox.js

@@ -9,6 +9,10 @@ import ProductApiService from "../api/products.api.service.js";
 import BasketApiService from "../api/basket.api.service.js";
 import OrderApiService from "../api/order.api.service.js";
 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 { BasketStatus } from "../interfaces/baskets.js";
+import { OrderStatus } from "../interfaces/orders.js";
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
@@ -54,7 +58,18 @@ export function loadEnvironmentVariables() {
     return envVars;
 }
 /**
- * Creates a VM sandbox context with all necessary globals and utilities
+ * Creates a VM sandbox context with all necessary globals and utilities.
+ *
+ * Available globals in the sandbox:
+ * - User: User data API
+ * - Products: Product catalog API
+ * - Data: Custom data collections API
+ * - Baskets: Shopping basket API
+ * - Orders: Order management API
+ * - Webhooks: Webhook management API (new)
+ * - Jobs: Job scheduling API (new)
+ * - env(): Environment variable access function
+ * - console, fetch, and other standard globals
  */
 export function createSandbox(options) {
     const { apiKey, agentId, customConsole, broadcastLog } = options;
@@ -62,73 +77,6 @@ export function createSandbox(options) {
     const envVars = loadEnvironmentVariables();
     // Create a CommonJS context for execution
     const require = createRequire(process.cwd() + '/package.json');
-    // const updateUserData = async (data: any) => {
-    //   return await UserDataApi.updateUserData(apiKey, agentId, data);
-    // };
-    // const getUserData = async () => {
-    //   return await UserDataApi.getUserData(apiKey, agentId);
-    // };
-    // const linkUserData = async (data: any) => {
-    //   return await UserDataApi.createUserData(apiKey, agentId, data);
-    // };
-    // const createProduct = async (data: any) => {
-    //   return await ProductApi.createProduct(apiKey, agentId, data);
-    // };
-    // const getProducts = async (page: number = 1, limit: number = 10) => {
-    //   return await ProductApi.getProducts(apiKey, agentId, page, limit);
-    // };
-    // const updateProduct = async (data: any, productId: string) => {
-    //   return await ProductApi.updateProduct(apiKey, agentId, { ...data, id: productId });
-    // };
-    // const deleteProduct = async (productId: string) => {
-    //   return await ProductApi.deleteProduct(apiKey, agentId, productId);
-    // };
-    // const createBasket = async (data: any) => {
-    //   return await ProductApi.createBasket(apiKey, agentId, data);
-    // };
-    // const getBaskets = async (status?: BasketStatus) => {
-    //   return await ProductApi.getUserBaskets(apiKey, agentId, status);
-    // };
-    // const addItemToBasket = async (basketId: string, data: any) => {
-    //   return await ProductApi.addItemToBasket(apiKey, agentId, basketId, data);
-    // };
-    // const removeItemFromBasket = async (basketId: string, itemId: string) => {
-    //   return await ProductApi.removeItemFromBasket(apiKey, agentId, basketId, itemId);
-    // };
-    // const clearBasket = async (basketId: string) => {
-    //   return await ProductApi.clearBasket(apiKey, agentId, basketId);
-    // };
-    // const updateBasketStatus = async (basketId: string, status: BasketStatus) => {
-    //   return await ProductApi.updateBasketStatus(apiKey, agentId, basketId, status);
-    // };
-    // const createOrder = async (data: any) => {
-    //   return await ProductApi.createOrder(apiKey, agentId, data);
-    // };
-    // const updateOrderStatus = async (orderId: string, status: OrderStatus) => {
-    //   return await ProductApi.updateOrderStatus(apiKey, agentId, orderId, status);
-    // };
-    // const getUserOrders = async (userId: string) => {
-    //   return await ProductApi.getUserOrders(apiKey, agentId, userId);
-    // };
-    // // Custom Data API functions
-    // const createCustomData = async (collectionName: string, data: any) => {
-    //   return await CustomDataApi.createCustomData(apiKey, agentId, collectionName, data);
-    // };
-    // const getCustomData = async (collectionName: string, filter?: any, page: number = 1, limit: number = 10) => {
-    //   return await CustomDataApi.getCustomData(apiKey, agentId, collectionName, filter, page, limit);
-    // };
-    // const getCustomDataEntry = async (collectionName: string, entryId: string) => {
-    //   return await CustomDataApi.getCustomDataEntry(apiKey, agentId, collectionName, entryId);
-    // };
-    // const updateCustomData = async (collectionName: string, entryId: string, data: any) => {
-    //   return await CustomDataApi.updateCustomData(apiKey, agentId, collectionName, entryId, data);
-    // };
-    // const searchCustomData = async (collectionName: string, searchText: string, limit: number = 10, scoreThreshold: number = 0.6) => {
-    //   return await CustomDataApi.searchCustomData(apiKey, agentId, collectionName, searchText, limit, scoreThreshold);
-    // };
-    // const deleteCustomData = async (collectionName: string, entryId: string) => {
-    //   return await CustomDataApi.deleteCustomData(apiKey, agentId, collectionName, entryId);
-    // };
     // Create console object (use custom console if provided, otherwise default)
     const consoleObj = customConsole || console;
     // Create API service instances
@@ -137,6 +85,8 @@ export function createSandbox(options) {
     const dataService = new CustomDataApiService(BASE_URLS.API, apiKey, agentId);
     const basketsService = new BasketApiService(BASE_URLS.API, apiKey, agentId);
     const orderService = new OrderApiService(BASE_URLS.API, apiKey, agentId);
+    const webhookService = new WebhookApi(BASE_URLS.API, apiKey, agentId);
+    const jobService = new JobApi(BASE_URLS.API, apiKey, agentId);
     // Override User service methods if needed
     // Example: Override the update method
     // const originalUpdate = userService.update.bind(userService);
@@ -232,9 +182,6 @@ export function createSandbox(options) {
         setInterval,
         clearTimeout,
         clearInterval,
-        process: {
-            env: envVars
-        },
         global: globalThis,
         __dirname: process.cwd(),
         __filename: path.join(process.cwd(), 'index.ts'),
@@ -275,8 +222,52 @@ export function createSandbox(options) {
         Data: dataService,
         Baskets: basketsService,
         Orders: orderService,
+        // Jobs API
+        Jobs: {
+            create: async (config) => {
+                // Convert execute function to string
+                const executeString = typeof config.execute === 'function'
+                    ? config.execute.toString()
+                    : config.execute;
+                // Create job
+                return await jobService.createJobInstance({
+                    name: config.name,
+                    description: config.description,
+                    context: config.description || '',
+                    schedule: config.schedule,
+                    timeout: config.timeout,
+                    retry: config.retry
+                });
+            },
+            get: async (jobId) => jobService.getJob(jobId)
+        },
         // Environment variables function
-        env: (key) => envVars[key]
+        env: (key) => envVars[key],
+        // Enums for status values
+        BasketStatus: BasketStatus,
+        OrderStatus: OrderStatus,
+        // AI Generation API
+        AI: {
+            generate: async (context, messages, targetAgentId) => {
+                const ChatApi = (await import('../api/chat.api.service.js')).default;
+                const chatService = new ChatApi(BASE_URLS.API, apiKey);
+                // Use provided agentId or default to current agent
+                const useAgentId = targetAgentId || 'luaAgent';
+                const result = await chatService.sendMessage(useAgentId, {
+                    messages,
+                    navigate: false,
+                    skillOverride: [],
+                    runtimeContext: context
+                });
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'AI generation failed');
+                }
+                return result.data?.text || '';
+            }
+        },
+        process: {
+            env: envVars
+        }
     };
     return sandbox;
 }
@@ -324,6 +315,226 @@ try{
     const executeFunction = context.module.exports;
     return await executeFunction(inputs);
 }
+/**
+ * Executes a webhook in a sandboxed environment.
+ *
+ * @param options - Webhook execution options including code and request data
+ * @returns Result from webhook execution
+ */
+export async function executeWebhook(options) {
+    const { webhookCode, query, headers, body } = options;
+    // Create sandbox
+    const sandbox = createSandbox(options);
+    // Create the CommonJS wrapper code
+    const commonJsWrapper = `
+const executeFunction = ${webhookCode};
+
+// Export the function for testing
+module.exports = async (input) => {
+try{
+  return await executeFunction(input);
+}catch(e){
+  console.error(e);
+  return { status: 'error', error: e.message };
+}
+};
+`;
+    // Execute the code in the sandbox
+    const context = vm.createContext(sandbox);
+    // Add polyfills
+    vm.runInContext(`
+    if (typeof global !== 'undefined') {
+      global.AbortController = AbortController;
+      global.FormData = FormData;
+      global.TextEncoder = TextEncoder;
+      global.TextDecoder = TextDecoder;
+      global.crypto = crypto;
+      global.fetch = fetch;
+      global.Headers = Headers;
+      global.Request = Request;
+      global.Response = Response;
+      global.URL = URL;
+      global.URLSearchParams = URLSearchParams;
+    }
+  `, context);
+    vm.runInContext(commonJsWrapper, context);
+    // Get the exported function and execute with webhook input structure
+    const executeFunction = context.module.exports;
+    return await executeFunction({ query, headers, body });
+}
+/**
+ * Executes a job in a sandboxed environment.
+ *
+ * @param options - Job execution options including code and job data
+ * @returns Result from job execution
+ */
+export async function executeJob(options) {
+    const { jobCode, jobData, apiKey, agentId } = options;
+    // Create sandbox
+    const sandbox = createSandbox(options);
+    // Create the CommonJS wrapper code that creates JobInstance from jobData
+    const commonJsWrapper = `
+const executeFunction = ${jobCode};
+
+// Export the function for testing
+module.exports = async (jobData) => {
+try{
+  // Create job instance from jobData if provided
+  let jobInstance = undefined;
+  if (jobData) {
+    jobInstance = {
+      id: jobData.id || jobData.jobId,
+      jobId: jobData.jobId || jobData.id,
+      name: jobData.name,
+      schedule: jobData.schedule,
+      metadata: jobData.metadata || {},
+      data: jobData,
+      updateMetadata: async (newMetadata) => {
+        jobInstance.metadata = { ...jobInstance.metadata, ...newMetadata };
+        console.log('✅ Metadata updated:', jobInstance.metadata);
+      },
+      delete: async () => {
+        console.log('🗑️  Job.delete() called for:', jobInstance.jobId);
+        // Note: In production, this would call Jobs.deactivate(jobId)
+      },
+      toJSON: () => jobData
+    };
+  }
+  
+  return await executeFunction(jobInstance);
+}catch(e){
+  console.error(e);
+  return { status: 'error', error: e.message };
+}
+};
+`;
+    // Execute the code in the sandbox
+    const context = vm.createContext(sandbox);
+    // Add polyfills
+    vm.runInContext(`
+    if (typeof global !== 'undefined') {
+      global.AbortController = AbortController;
+      global.FormData = FormData;
+      global.TextEncoder = TextEncoder;
+      global.TextDecoder = TextDecoder;
+      global.crypto = crypto;
+      global.fetch = fetch;
+      global.Headers = Headers;
+      global.Request = Request;
+      global.Response = Response;
+      global.URL = URL;
+      global.URLSearchParams = URLSearchParams;
+    }
+  `, context);
+    vm.runInContext(commonJsWrapper, context);
+    // Get the exported function and execute with jobData
+    const executeFunction = context.module.exports;
+    return await executeFunction(jobData);
+}
+/**
+ * Executes a preprocessor in a sandboxed environment.
+ *
+ * @param options - PreProcessor execution options
+ * @returns Processed message string
+ */
+export async function executePreProcessor(options) {
+    const { processorCode, message, channel, apiKey, agentId } = options;
+    // Create sandbox
+    const sandbox = createSandbox(options);
+    // Get user instance first (outside VM)
+    const UserDataApi = (await import('../api/user.data.api.service.js')).default;
+    const userService = new UserDataApi(BASE_URLS.API, apiKey, agentId);
+    const userInstance = await userService.get();
+    // Create the CommonJS wrapper code
+    const commonJsWrapper = `
+const executeFunction = ${processorCode};
+
+// Export the function for testing
+module.exports = async (input) => {
+try{
+  // userInstance is passed as parameter
+  return await executeFunction(input.user, input.message, input.channel);
+}catch(e){
+  console.error(e);
+  return { status: 'error', error: e.message };
+}
+};
+`;
+    // Execute the code in the sandbox
+    const context = vm.createContext(sandbox);
+    // Add polyfills
+    vm.runInContext(`
+    if (typeof global !== 'undefined') {
+      global.AbortController = AbortController;
+      global.FormData = FormData;
+      global.TextEncoder = TextEncoder;
+      global.TextDecoder = TextDecoder;
+      global.crypto = crypto;
+      global.fetch = fetch;
+      global.Headers = Headers;
+      global.Request = Request;
+      global.Response = Response;
+      global.URL = URL;
+      global.URLSearchParams = URLSearchParams;
+    }
+  `, context);
+    vm.runInContext(commonJsWrapper, context);
+    // Get the exported function and execute with user instance
+    const executeFunction = context.module.exports;
+    return await executeFunction({ user: userInstance, message, channel });
+}
+/**
+ * Executes a postprocessor in a sandboxed environment.
+ *
+ * @param options - PostProcessor execution options
+ * @returns Processed response string
+ */
+export async function executePostProcessor(options) {
+    const { processorCode, message, response, channel, apiKey, agentId } = options;
+    // Create sandbox
+    const sandbox = createSandbox(options);
+    // Get user instance first (outside VM)
+    const UserDataApi = (await import('../api/user.data.api.service.js')).default;
+    const userService = new UserDataApi(BASE_URLS.API, apiKey, agentId);
+    const userInstance = await userService.get();
+    // Create the CommonJS wrapper code
+    const commonJsWrapper = `
+const executeFunction = ${processorCode};
+
+// Export the function for testing
+module.exports = async (input) => {
+try{
+  // userInstance is passed as parameter
+  return await executeFunction(input.user, input.message, input.response, input.channel);
+}catch(e){
+  console.error(e);
+  return { status: 'error', error: e.message };
+}
+};
+`;
+    // Execute the code in the sandbox
+    const context = vm.createContext(sandbox);
+    // Add polyfills
+    vm.runInContext(`
+    if (typeof global !== 'undefined') {
+      global.AbortController = AbortController;
+      global.FormData = FormData;
+      global.TextEncoder = TextEncoder;
+      global.TextDecoder = TextDecoder;
+      global.crypto = crypto;
+      global.fetch = fetch;
+      global.Headers = Headers;
+      global.Request = Request;
+      global.Response = Response;
+      global.URL = URL;
+      global.URLSearchParams = URLSearchParams;
+    }
+  `, context);
+    vm.runInContext(commonJsWrapper, context);
+    // Get the exported function and execute with user instance
+    const executeFunction = context.module.exports;
+    return await executeFunction({ user: userInstance, message, response, channel });
+}
 /**
  * Creates a custom console that broadcasts logs via WebSocket
  */

package/dist/utils/tool-detection.d.ts

@@ -6,13 +6,14 @@ import { Project } from "ts-morph";
 import { ToolInfo } from '../interfaces/compile.js';
 import { TypeScriptSourceFile } from '../types/compile.types.js';
 /**
- * Detects all tools in the project by analyzing the index file.
+ * Detects all tools in the project by analyzing the index file and skill files.
  * Searches for tools in two places:
  * 1. LuaSkill constructor's tools array
  * 2. skill.addTools() or skill.addTool() method calls
  *
  * @param indexFile - The main index TypeScript source file
  * @param project - The ts-morph Project instance
+ * @param skillFilePaths - Optional array of skill file paths to scan for tools (for LuaAgent)
  * @returns Promise resolving to array of detected tool information
  */
-export declare function detectTools(indexFile: TypeScriptSourceFile, project: Project): Promise<ToolInfo[]>;
+export declare function detectTools(indexFile: TypeScriptSourceFile, project: Project, skillFilePaths?: string[]): Promise<ToolInfo[]>;

package/dist/utils/tool-detection.js

@@ -5,21 +5,35 @@
 import { Node } from "ts-morph";
 import { extractToolFromNewExpressionSync, } from './compile.js';
 /**
- * Detects all tools in the project by analyzing the index file.
+ * Detects all tools in the project by analyzing the index file and skill files.
  * Searches for tools in two places:
  * 1. LuaSkill constructor's tools array
  * 2. skill.addTools() or skill.addTool() method calls
  *
  * @param indexFile - The main index TypeScript source file
  * @param project - The ts-morph Project instance
+ * @param skillFilePaths - Optional array of skill file paths to scan for tools (for LuaAgent)
  * @returns Promise resolving to array of detected tool information
  */
-export async function detectTools(indexFile, project) {
+export async function detectTools(indexFile, project, skillFilePaths) {
     const tools = [];
-    // Search strategy 1: Find tools in LuaSkill constructor's tools array
+    // Search strategy 1: Find tools in LuaSkill constructor's tools array in index file
     detectToolsFromConstructor(indexFile, project, tools);
-    // Search strategy 2: Find tools from skill.addTools() or skill.addTool() method calls
+    // Search strategy 2: Find tools from skill.addTools() or skill.addTool() method calls in index file
     detectToolsFromMethodCalls(indexFile, project, tools);
+    // Search strategy 3: If skill files are provided (from LuaAgent), scan those too
+    if (skillFilePaths && skillFilePaths.length > 0) {
+        for (const skillFilePath of skillFilePaths) {
+            try {
+                const skillFile = project.addSourceFileAtPath(skillFilePath);
+                detectToolsFromConstructor(skillFile, project, tools);
+                detectToolsFromMethodCalls(skillFile, project, tools);
+            }
+            catch (error) {
+                console.warn(`Warning: Could not scan skill file ${skillFilePath} for tools:`, error);
+            }
+        }
+    }
     return tools;
 }
 /**

package/dist/utils/webhook-management.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Webhook Management Utilities
+ * Handles webhook creation via API and YAML configuration management
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected webhooks exist in the YAML config with valid webhook IDs.
+ * If a webhook doesn't exist or has no ID, creates it via the API.
+ *
+ * @param webhooksArray - Array of webhooks detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated webhooks array with valid webhook IDs
+ */
+export declare function ensureWebhooksExistInYaml(webhooksArray: any[], config: SkillConfig): Promise<any[]>;
+/**
+ * Syncs the server webhooks with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates webhooks from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerWebhooksWithYaml(config: SkillConfig): Promise<string[]>;