lua-cli 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/utils/dev-server.js

@@ -42,7 +42,7 @@ function readDeployJson() {
  * @param port - Port to run server on
  * @returns Server instance with WebSocket and broadcast function
  */
-export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
+export function createChatServer(apiKey, agentId, skillId, sandboxId, port, config) {
     const deployData = readDeployJson();
     const server = createServer((req, res) => {
         // Enable CORS
@@ -56,7 +56,7 @@ export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
         }
         // Route handlers
         if (req.method === 'POST' && req.url === '/chat') {
-            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData);
+            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData, config);
             return;
         }
         if (req.method === 'GET' && req.url === '/persona') {
@@ -173,7 +173,7 @@ export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
 /**
  * Handles POST /chat - Send chat messages
  */
-function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData) {
+function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData, config) {
     let body = '';
     req.on('data', (chunk) => {
         body += chunk.toString();
@@ -181,7 +181,7 @@ function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deplo
     req.on('end', async () => {
         try {
             const { message, persona } = JSON.parse(body);
-            const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData);
+            const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData, config);
             res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: response !== null,

package/dist/utils/dynamic-job-bundler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dynamic Job Bundler
+ * Handles detection and bundling of Jobs.create() calls within execute functions
+ */
+/**
+ * Detects if code contains Jobs.create() calls
+ */
+export declare function containsJobsCreate(code: string): boolean;
+/**
+ * Extracts Jobs.create() execute functions and bundles them with dependencies.
+ * Finds execute functions in the code and creates standalone bundles.
+ */
+export declare function bundleNestedJobs(code: string, parentName: string, distDir: string): Promise<string>;
+/**
+ * Cleans up temporary bundling directory
+ */
+export declare function cleanupTempDir(distDir: string): void;

package/dist/utils/dynamic-job-bundler.js

@@ -0,0 +1,143 @@
+/**
+ * Dynamic Job Bundler
+ * Handles detection and bundling of Jobs.create() calls within execute functions
+ */
+import { build } from 'esbuild';
+import fs from 'fs';
+import path from 'path';
+import { compressCode } from './compile.js';
+import { sandboxGlobalsPlugin } from './bundling.js';
+/**
+ * Detects if code contains Jobs.create() calls
+ */
+export function containsJobsCreate(code) {
+    const found = /Jobs\.create\s*\(/i.test(code);
+    if (found) {
+        console.log('[DynamicJobs] ✅ Detected Jobs.create() in code');
+    }
+    return found;
+}
+/**
+ * Extracts Jobs.create() execute functions and bundles them with dependencies.
+ * Finds execute functions in the code and creates standalone bundles.
+ */
+export async function bundleNestedJobs(code, parentName, distDir) {
+    if (!containsJobsCreate(code)) {
+        return code;
+    }
+    console.log(`[DynamicJobs] ⚠️  Jobs.create() with external dependencies not yet fully supported`);
+    console.log(`[DynamicJobs] 💡 Recommendation: Use fetch() or lua-cli APIs in job execute functions`);
+    console.log(`[DynamicJobs] 📋 Full bundling support planned for v3.1.0`);
+    // Return original code as-is
+    // The job will have access to lua-cli globals but external packages won't be bundled
+    return code;
+}
+/**
+ * Helper to extract job execute function from code
+ */
+function extractJobExecuteFromCode(code) {
+    // This extracts the execute function body
+    // For now, return a placeholder that indicates the limitation
+    return `
+    // Note: This job execute function runs with limited context
+    // Use fetch() for external APIs or lua-cli globals (User, Data, Products)
+    console.log('Job execute running with user:', user);
+    return { executed: true };
+  `;
+}
+/**
+ * Bundles a job's execute function independently
+ */
+async function bundleJobExecuteFunction(executeFunction, jobName, distDir) {
+    const tempDir = path.join(distDir, '.temp');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const tempFile = path.join(tempDir, `${jobName}.js`);
+    const tempOutput = path.join(tempDir, `${jobName}-bundled.js`);
+    try {
+        // Extract imports that the execute function might need
+        // Common ones: Stripe, axios, etc.
+        const moduleCode = `
+// Job execute function for ${jobName}
+// Import dependencies that might be used
+import Stripe from 'stripe';
+import { env, User, Data, Products, Baskets, Orders } from 'lua-cli';
+
+// The execute function with all dependencies available
+const executeFunc = ${executeFunction};
+
+// Export as default for esbuild to bundle
+export default executeFunc;
+`;
+        fs.writeFileSync(tempFile, moduleCode);
+        // Bundle with esbuild - bundle ALL dependencies (including Stripe, axios, etc.)
+        await build({
+            entryPoints: [tempFile],
+            bundle: true,
+            platform: 'node',
+            target: 'node16',
+            format: 'cjs',
+            minify: true,
+            outfile: tempOutput,
+            external: [], // Bundle everything except lua-cli APIs (handled by plugin)
+            plugins: [sandboxGlobalsPlugin], // This handles lua-cli globals
+            // Important: Don't externalize packages like stripe, axios, etc.
+            // They need to be included in the bundle
+        });
+        // Read bundled code (includes all dependencies like Stripe, axios, etc.)
+        let bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        // Log bundle size for debugging
+        console.log(`[DynamicJobs] Bundled size for ${jobName}: ${(bundledCode.length / 1024).toFixed(2)}KB`);
+        // Wrap for VM execution - the bundled code includes ALL dependencies
+        const wrappedCode = `(async (job) => {
+ 
+  ${bundledCode}
+  
+  // Get the execute function from exports
+  const executeFunction = module.exports || module.exports.default;
+  
+  // Execute with job
+  return await executeFunction(job);
+})`;
+        // Compress the wrapped code
+        const compressed = compressCode(wrappedCode);
+        // Clean up temp files
+        try {
+            fs.unlinkSync(tempFile);
+            fs.unlinkSync(tempOutput);
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        return compressed;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not bundle job execute function ${jobName}:`, error);
+        // Clean up on error
+        try {
+            if (fs.existsSync(tempFile))
+                fs.unlinkSync(tempFile);
+            if (fs.existsSync(tempOutput))
+                fs.unlinkSync(tempOutput);
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        return '';
+    }
+}
+/**
+ * Cleans up temporary bundling directory
+ */
+export function cleanupTempDir(distDir) {
+    const tempDir = path.join(distDir, '.temp');
+    if (fs.existsSync(tempDir)) {
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            // Ignore cleanup errors
+        }
+    }
+}

package/dist/utils/pre-bundle-jobs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pre-Bundle Jobs - Extract and bundle Jobs.create() before tool bundling
+ *
+ * Flow:
+ * 1. Detect Jobs.create() in source
+ * 2. Extract execute function
+ * 3. Bundle execute with ALL dependencies
+ * 4. Replace execute with placeholder
+ * 5. Bundle tool/webhook/job
+ * 6. Replace placeholder with bundled job code
+ * 7. Compress
+ */
+import { Project } from 'ts-morph';
+/**
+ * Pre-processes source file to extract and bundle Jobs.create() execute functions
+ * Returns modified source code with placeholders
+ */
+export declare function preBundleJobsInSource(sourceFilePath: string, project: Project, distDir: string): Promise<{
+    modifiedSource: string;
+    jobBundles: Map<string, string>;
+}>;
+/**
+ * Replaces placeholders in bundled code with actual job bundles
+ * The bundled job code is NOT compressed - it's JavaScript that will be part of the tool
+ */
+export declare function replaceJobPlaceholders(bundledCode: string, jobBundles: Map<string, string>): string;

package/dist/utils/pre-bundle-jobs.js

@@ -0,0 +1,176 @@
+/**
+ * Pre-Bundle Jobs - Extract and bundle Jobs.create() before tool bundling
+ *
+ * Flow:
+ * 1. Detect Jobs.create() in source
+ * 2. Extract execute function
+ * 3. Bundle execute with ALL dependencies
+ * 4. Replace execute with placeholder
+ * 5. Bundle tool/webhook/job
+ * 6. Replace placeholder with bundled job code
+ * 7. Compress
+ */
+import { Node } from 'ts-morph';
+import { build } from 'esbuild';
+import fs from 'fs';
+import path from 'path';
+import { sandboxGlobalsPlugin } from './bundling.js';
+const JOB_PLACEHOLDER = '__BUNDLED_JOB_EXECUTE__';
+/**
+ * Pre-processes source file to extract and bundle Jobs.create() execute functions
+ * Returns modified source code with placeholders
+ */
+export async function preBundleJobsInSource(sourceFilePath, project, distDir) {
+    const sourceFile = project.getSourceFile(sourceFilePath);
+    if (!sourceFile) {
+        return { modifiedSource: fs.readFileSync(sourceFilePath, 'utf8'), jobBundles: new Map() };
+    }
+    const jobBundles = new Map();
+    const bundlingPromises = [];
+    let jobIndex = 0;
+    let modifiedSource = sourceFile.getFullText();
+    // Find all Jobs.create() calls
+    sourceFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            // Check if this is Jobs.create()
+            if (Node.isPropertyAccessExpression(expression)) {
+                const object = expression.getExpression();
+                const property = expression.getName();
+                if (object.getText() === 'Jobs' && property === 'create') {
+                    jobIndex++;
+                    const placeholder = `${JOB_PLACEHOLDER}_${jobIndex}`;
+                    console.log(`[PreBundleJobs] Found Jobs.create() #${jobIndex}`);
+                    // Get the config object argument
+                    const args = node.getArguments();
+                    if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                        const configObj = args[0];
+                        // Find the execute property
+                        const executeProperty = configObj.getProperty('execute');
+                        if (executeProperty && Node.isPropertyAssignment(executeProperty)) {
+                            const executeInitializer = executeProperty.getInitializer();
+                            if (executeInitializer) {
+                                const executeCode = executeInitializer.getText();
+                                console.log(`[PreBundleJobs] Extracting execute function for bundling...`);
+                                // Bundle the execute function with dependencies (async)
+                                const bundlePromise = bundleJobExecuteFunction(executeCode, `job_${jobIndex}`, distDir, sourceFilePath).then(bundledCode => {
+                                    if (bundledCode) {
+                                        jobBundles.set(placeholder, bundledCode);
+                                        console.log(`[PreBundleJobs] ✅ Bundled job #${jobIndex} with dependencies`);
+                                    }
+                                });
+                                bundlingPromises.push(bundlePromise);
+                                // Replace execute function with a function that references the bundled code
+                                // Don't use string placeholder - use a reference
+                                const originalText = executeProperty.getText();
+                                const replacementText = `execute: ${placeholder}`;
+                                modifiedSource = modifiedSource.replace(originalText, replacementText);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+    // Wait for all bundling to complete
+    if (bundlingPromises.length > 0) {
+        console.log(`[PreBundleJobs] Waiting for ${bundlingPromises.length} job(s) to bundle...`);
+        await Promise.all(bundlingPromises);
+        console.log(`[PreBundleJobs] ✅ All job bundles complete`);
+    }
+    return { modifiedSource, jobBundles };
+}
+/**
+ * Bundles a job execute function with all its dependencies
+ */
+async function bundleJobExecuteFunction(executeCode, jobName, distDir, sourceFilePath) {
+    const tempDir = path.join(distDir, '.temp');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const tempOutput = path.join(tempDir, `${jobName}-bundled.js`);
+    try {
+        // Read the original source file to get its imports
+        const sourceContent = fs.readFileSync(sourceFilePath, 'utf8');
+        // Extract all import statements from the source
+        const importPattern = /^import\s+.+\s+from\s+['"][^'"]+['"];?$/gm;
+        const imports = sourceContent.match(importPattern) || [];
+        // Filter to only imports that might be used (exclude lua-cli internal classes and APIs)
+        const relevantImports = imports.filter(imp => !imp.includes('LuaTool') &&
+            !imp.includes('LuaWebhook') &&
+            !imp.includes('LuaJob') &&
+            !imp.includes('lua-cli') && // Exclude all lua-cli imports (they're available in sandbox)
+            !imp.includes('api-exports') && // Exclude api-exports
+            !imp.includes('../../../dist/api-exports') // Exclude direct api-exports imports
+        );
+        console.log(`[PreBundleJobs] Including ${relevantImports.length} import(s) in job bundle`);
+        // Create a TypeScript module with the execute function and all imports
+        const moduleCode = `
+// Auto-generated job execute bundle
+${relevantImports.join('\n')}
+
+// The execute function with all dependencies available
+const executeFunc = ${executeCode};
+
+export default executeFunc;
+`;
+        // Bundle with esbuild using stdin to preserve import resolution
+        await build({
+            stdin: {
+                contents: moduleCode,
+                resolveDir: path.dirname(sourceFilePath),
+                sourcefile: sourceFilePath,
+                loader: 'ts',
+            },
+            bundle: true,
+            platform: 'node',
+            target: 'node16',
+            format: 'cjs',
+            minify: true,
+            outfile: tempOutput,
+            external: [],
+            plugins: [sandboxGlobalsPlugin],
+        });
+        // Read bundled code
+        const bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        console.log(`[PreBundleJobs] Bundle size: ${(bundledCode.length / 1024).toFixed(2)}KB`);
+        // DON'T compress - just wrap for VM execution
+        // Compression happens later when the entire tool is bundled
+        const wrappedCode = `(async (job) => {
+  ${bundledCode}
+  const executeFunction = module.exports.default || module.exports;
+  return await executeFunction(job);
+})`;
+        // Cleanup temp files
+        try {
+            fs.unlinkSync(tempOutput);
+        }
+        catch { }
+        // Return uncompressed bundled code
+        return wrappedCode;
+    }
+    catch (error) {
+        console.warn(`[PreBundleJobs] Error bundling job ${jobName}:`, error);
+        try {
+            if (fs.existsSync(tempOutput))
+                fs.unlinkSync(tempOutput);
+        }
+        catch { }
+        return '';
+    }
+}
+/**
+ * Replaces placeholders in bundled code with actual job bundles
+ * The bundled job code is NOT compressed - it's JavaScript that will be part of the tool
+ */
+export function replaceJobPlaceholders(bundledCode, jobBundles) {
+    let result = bundledCode;
+    jobBundles.forEach((bundledJobCode, placeholder) => {
+        // The placeholder is used as an identifier (not a string), just replace it directly
+        // It appears as: execute: __BUNDLED_JOB_EXECUTE___1
+        const placeholderPattern = new RegExp(placeholder, 'g');
+        result = result.replace(placeholderPattern, bundledJobCode);
+        console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+    });
+    return result;
+}

package/dist/utils/sandbox-storage.d.ts

@@ -25,3 +25,51 @@ export declare function setSandboxSkillId(sandboxId: string, skillName?: string)
  * @returns Array of skill overrides with skillId and sandboxId pairs
  */
 export declare function getAllSandboxSkillIds(deployData: any): Promise<SkillOverride[]>;
+/**
+ * Retrieves sandbox preprocessor ID from secure storage.
+ *
+ * @param preprocessorName - Preprocessor name
+ * @returns The sandbox preprocessor ID or null if not found
+ */
+export declare function getSandboxPreProcessorId(preprocessorName: string): Promise<string | null>;
+/**
+ * Stores sandbox preprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox preprocessor ID to store
+ * @param preprocessorName - Preprocessor name
+ */
+export declare function setSandboxPreProcessorId(sandboxId: string, preprocessorName: string): Promise<void>;
+/**
+ * Retrieves sandbox postprocessor ID from secure storage.
+ *
+ * @param postprocessorName - Postprocessor name
+ * @returns The sandbox postprocessor ID or null if not found
+ */
+export declare function getSandboxPostProcessorId(postprocessorName: string): Promise<string | null>;
+/**
+ * Stores sandbox postprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox postprocessor ID to store
+ * @param postprocessorName - Postprocessor name
+ */
+export declare function setSandboxPostProcessorId(sandboxId: string, postprocessorName: string): Promise<void>;
+/**
+ * Gets all sandbox preprocessor overrides for the current config.
+ *
+ * @param config - Configuration with preprocessors
+ * @returns Array of preprocessor overrides
+ */
+export declare function getAllSandboxPreProcessorIds(config: any): Promise<Array<{
+    preprocessorId: string;
+    sandboxId: string;
+}>>;
+/**
+ * Gets all sandbox postprocessor overrides for the current config.
+ *
+ * @param config - Configuration with postprocessors
+ * @returns Array of postprocessor overrides
+ */
+export declare function getAllSandboxPostProcessorIds(config: any): Promise<Array<{
+    postprocessorId: string;
+    sandboxId: string;
+}>>;

package/dist/utils/sandbox-storage.js

@@ -69,3 +69,117 @@ export async function getAllSandboxSkillIds(deployData) {
     }
     return skillOverrides;
 }
+/**
+ * Retrieves sandbox preprocessor ID from secure storage.
+ *
+ * @param preprocessorName - Preprocessor name
+ * @returns The sandbox preprocessor ID or null if not found
+ */
+export async function getSandboxPreProcessorId(preprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_preprocessor_${preprocessorName}`;
+        return await keytar.getPassword(SANDBOX_STORAGE.SERVICE, account);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores sandbox preprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox preprocessor ID to store
+ * @param preprocessorName - Preprocessor name
+ */
+export async function setSandboxPreProcessorId(sandboxId, preprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_preprocessor_${preprocessorName}`;
+        await keytar.setPassword(SANDBOX_STORAGE.SERVICE, account, sandboxId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+/**
+ * Retrieves sandbox postprocessor ID from secure storage.
+ *
+ * @param postprocessorName - Postprocessor name
+ * @returns The sandbox postprocessor ID or null if not found
+ */
+export async function getSandboxPostProcessorId(postprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_postprocessor_${postprocessorName}`;
+        return await keytar.getPassword(SANDBOX_STORAGE.SERVICE, account);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores sandbox postprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox postprocessor ID to store
+ * @param postprocessorName - Postprocessor name
+ */
+export async function setSandboxPostProcessorId(sandboxId, postprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_postprocessor_${postprocessorName}`;
+        await keytar.setPassword(SANDBOX_STORAGE.SERVICE, account, sandboxId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+/**
+ * Gets all sandbox preprocessor overrides for the current config.
+ *
+ * @param config - Configuration with preprocessors
+ * @returns Array of preprocessor overrides
+ */
+export async function getAllSandboxPreProcessorIds(config) {
+    const overrides = [];
+    try {
+        const preprocessors = config.preprocessors || [];
+        for (const preprocessor of preprocessors) {
+            if (preprocessor.preprocessorId && preprocessor.name) {
+                const sandboxId = await getSandboxPreProcessorId(preprocessor.name);
+                if (sandboxId) {
+                    overrides.push({
+                        preprocessorId: preprocessor.preprocessorId,
+                        sandboxId: sandboxId
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error getting sandbox preprocessor IDs:', error);
+    }
+    return overrides;
+}
+/**
+ * Gets all sandbox postprocessor overrides for the current config.
+ *
+ * @param config - Configuration with postprocessors
+ * @returns Array of postprocessor overrides
+ */
+export async function getAllSandboxPostProcessorIds(config) {
+    const overrides = [];
+    try {
+        const postprocessors = config.postprocessors || [];
+        for (const postprocessor of postprocessors) {
+            if (postprocessor.postprocessorId && postprocessor.name) {
+                const sandboxId = await getSandboxPostProcessorId(postprocessor.name);
+                if (sandboxId) {
+                    overrides.push({
+                        postprocessorId: postprocessor.postprocessorId,
+                        sandboxId: sandboxId
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error getting sandbox postprocessor IDs:', error);
+    }
+    return overrides;
+}

package/dist/utils/sandbox.d.ts

@@ -20,7 +20,7 @@ export interface ExecuteJobOptions extends SandboxOptions {
 }
 export interface ExecutePreProcessorOptions extends SandboxOptions {
     processorCode: string;
-    message: string;
+    messages: any[];
     channel: string;
 }
 export interface ExecutePostProcessorOptions extends SandboxOptions {
@@ -75,7 +75,7 @@ export declare function executeJob(options: ExecuteJobOptions): Promise<any>;
  * @param options - PreProcessor execution options
  * @returns Processed message string
  */
-export declare function executePreProcessor(options: ExecutePreProcessorOptions): Promise<string>;
+export declare function executePreProcessor(options: ExecutePreProcessorOptions): Promise<any[]>;
 /**
  * Executes a postprocessor in a sandboxed environment.
  *

package/dist/utils/sandbox.js

@@ -13,6 +13,7 @@ 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";
+import { compressCode } from "./compile.js";
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
@@ -221,6 +222,7 @@ export function createSandbox(options) {
         Products: productService,
         Data: dataService,
         Baskets: basketsService,
+        compressCode: compressCode,
         Orders: orderService,
         // Jobs API
         Jobs: {
@@ -229,14 +231,27 @@ export function createSandbox(options) {
                 const executeString = typeof config.execute === 'function'
                     ? config.execute.toString()
                     : config.execute;
-                // Create job
+                // Create job with version and activation
                 return await jobService.createJobInstance({
-                    name: config.name,
+                    name: config.name + '_' + Date.now(),
                     description: config.description,
                     context: config.description || '',
                     schedule: config.schedule,
                     timeout: config.timeout,
-                    retry: config.retry
+                    retry: config.retry,
+                    metadata: config.metadata,
+                    dynamic: true,
+                    version: {
+                        version: '1.0.0',
+                        description: config.description,
+                        context: config.description || '',
+                        code: '',
+                        executeFunction: executeString,
+                        timeout: config.timeout,
+                        retry: config.retry,
+                        metadata: config.metadata
+                    },
+                    activate: config.activate ?? true
                 });
             },
             get: async (jobId) => jobService.getJob(jobId)
@@ -330,9 +345,9 @@ export async function executeWebhook(options) {
 const executeFunction = ${webhookCode};
 
 // Export the function for testing
-module.exports = async (input) => {
+module.exports = async (query, headers, body) => {
 try{
-  return await executeFunction(input);
+  return await executeFunction(query, headers, body);
 }catch(e){
   console.error(e);
   return { status: 'error', error: e.message };
@@ -438,7 +453,7 @@ try{
  * @returns Processed message string
  */
 export async function executePreProcessor(options) {
-    const { processorCode, message, channel, apiKey, agentId } = options;
+    const { processorCode, messages, channel, apiKey, agentId } = options;
     // Create sandbox
     const sandbox = createSandbox(options);
     // Get user instance first (outside VM)
@@ -453,7 +468,7 @@ const executeFunction = ${processorCode};
 module.exports = async (input) => {
 try{
   // userInstance is passed as parameter
-  return await executeFunction(input.user, input.message, input.channel);
+  return await executeFunction(input.user, input.messages, input.channel);
 }catch(e){
   console.error(e);
   return { status: 'error', error: e.message };
@@ -481,7 +496,7 @@ try{
     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 });
+    return await executeFunction({ user: userInstance, messages, channel });
 }
 /**
  * Executes a postprocessor in a sandboxed environment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.11",
   "description": "Command-line interface for Lua AI platform - develop, test, and deploy LuaSkills with custom tools",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",