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

package/dist/utils/dev-api.js

@@ -4,12 +4,14 @@
  */
 import ChatApi from '../api/chat.api.service.js';
 import SkillApi from '../api/skills.api.service.js';
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import PostProcessorApi from '../api/postprocessor.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { writeProgress, writeSuccess } from './cli.js';
 import { loadEnvironmentVariables } from './sandbox.js';
-import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './sandbox-storage.js';
+import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds, getSandboxPreProcessorId, setSandboxPreProcessorId, getSandboxPostProcessorId, setSandboxPostProcessorId } from './sandbox-storage.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -18,9 +20,10 @@ import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './s
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData) {
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData, config) {
     try {
         // Get all sandbox skill IDs for skill override
         const allSkillOverrides = await getAllSandboxSkillIds(deployData);
@@ -31,6 +34,10 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 sandboxId: sandboxId
             }
         ];
+        // Get sandbox processor overrides if config provided
+        const { getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } = await import('./sandbox-storage.js');
+        const preprocessorOverride = config ? await getAllSandboxPreProcessorIds(config) : [];
+        const postprocessorOverride = config ? await getAllSandboxPostProcessorIds(config) : [];
         const chatRequest = {
             messages: [
                 {
@@ -39,7 +46,9 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 }
             ],
             navigate: true,
-            skillOverride: skillOverride
+            skillOverride: skillOverride,
+            preprocessorOverride: preprocessorOverride,
+            postprocessorOverride: postprocessorOverride
         };
         // Add persona override if provided
         if (persona) {
@@ -260,3 +269,167 @@ export async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial
     }
     return sandboxIds;
 }
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessorId, preprocessorData, isInitial = false) {
+    const preprocessorName = preprocessorData.name || 'Unknown PreProcessor';
+    const sandboxPreProcessorId = await getSandboxPreProcessorId(preprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = preprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: preprocessorName,
+        version: sandboxVersion,
+        description: preprocessorData.description,
+        context: preprocessorData.context,
+        code: preprocessorData.code,
+        executeFunction: preprocessorData.executeFunction,
+        async: Boolean(preprocessorData.async ?? false)
+    };
+    if (sandboxPreProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing preprocessor sandbox version...`);
+        }
+        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPreProcessor(preprocessorId, sandboxPreProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update preprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new preprocessor sandbox version...`);
+    }
+    const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPreProcessor(preprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox preprocessor ID
+        await setSandboxPreProcessorId(result.data.versionId, preprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PreProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessorId, postprocessorData, isInitial = false) {
+    const postprocessorName = postprocessorData.name || 'Unknown PostProcessor';
+    const sandboxPostProcessorId = await getSandboxPostProcessorId(postprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = postprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: postprocessorName,
+        version: sandboxVersion,
+        description: postprocessorData.description,
+        context: postprocessorData.context,
+        code: postprocessorData.code,
+        executeFunction: postprocessorData.executeFunction,
+        async: Boolean(postprocessorData.async ?? false)
+    };
+    if (sandboxPostProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing postprocessor sandbox version...`);
+        }
+        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPostProcessor(postprocessorId, sandboxPostProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update postprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new postprocessor sandbox version...`);
+    }
+    const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPostProcessor(postprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox postprocessor ID
+        await setSandboxPostProcessorId(result.data.versionId, postprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PostProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export async function pushProcessorsToSandbox(apiKey, agentId, config, bundledPreProcessors, bundledPostProcessors, isInitial = false) {
+    let preprocessorCount = 0;
+    let postprocessorCount = 0;
+    // Push preprocessors
+    const configPreProcessors = config.preprocessors || [];
+    for (const preprocessor of configPreProcessors) {
+        const bundled = bundledPreProcessors.find(p => p.name === preprocessor.name);
+        if (bundled && bundled.code && preprocessor.preprocessorId) {
+            try {
+                const success = await pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessor.preprocessorId, bundled, isInitial);
+                if (success)
+                    preprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push preprocessor ${preprocessor.name}:`, error);
+            }
+        }
+    }
+    // Push postprocessors
+    const configPostProcessors = config.postprocessors || [];
+    for (const postprocessor of configPostProcessors) {
+        const bundled = bundledPostProcessors.find(p => p.name === postprocessor.name);
+        if (bundled && bundled.code && postprocessor.postprocessorId) {
+            try {
+                const success = await pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessor.postprocessorId, bundled, isInitial);
+                if (success)
+                    postprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push postprocessor ${postprocessor.name}:`, error);
+            }
+        }
+    }
+    return { preprocessors: preprocessorCount, postprocessors: postprocessorCount };
+}

package/dist/utils/dev-server.d.ts

@@ -21,4 +21,4 @@ export interface DevServer {
  * @param port - Port to run server on
  * @returns Server instance with WebSocket and broadcast function
  */
-export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number): DevServer;
+export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number, config?: any): DevServer;

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;
+}>>;