lua-cli 3.0.2-alpha.1 → 3.0.2-alpha.2

package/dist/utils/bundling.js

@@ -7,7 +7,7 @@ import path from "path";
 import { build } from "esbuild";
 import { Project, Node } from "ts-morph";
 import { writeProgress } from "./cli.js";
-import { COMPILE_DIRS, COMPILE_FILES, ESBUILD_TOOL_CONFIG, ESBUILD_INDEX_CONFIG, DEFAULT_INPUT_SCHEMA, } from '../config/compile.constants.js';
+import { COMPILE_DIRS, COMPILE_FILES, ESBUILD_TOOL_CONFIG, ESBUILD_INDEX_CONFIG, DEFAULT_INPUT_SCHEMA, EXTERNAL_PACKAGES, } from '../config/compile.constants.js';
 import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema } from './compile.js';
 /**
  * Helper function to remove lua-cli and api-exports imports from source code.
@@ -30,6 +30,108 @@ function stripLuaCliImports(sourceCode) {
             : '// lua-cli/skill imports removed - using sandbox globals';
     });
 }
+/**
+ * Extracts and filters relevant imports from source code.
+ * Removes lua-cli internal classes and API imports that are available in the sandbox.
+ *
+ * @param sourceFilePath - Path to the source file
+ * @returns Array of relevant import statements
+ */
+function extractRelevantImports(sourceFilePath) {
+    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)
+    return imports.filter(imp => !imp.includes('LuaTool') &&
+        !imp.includes('LuaWebhook') &&
+        !imp.includes('LuaJob') &&
+        !imp.includes('PreProcessor') &&
+        !imp.includes('PostProcessor') &&
+        !imp.includes('LuaAgent') &&
+        !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
+    );
+}
+/**
+ * Generic function to bundle and compress execute function code with dependencies.
+ *
+ * @param executeFunction - Raw execute function code
+ * @param componentName - Name of the component (webhook/job/processor)
+ * @param componentType - Type identifier for temp files
+ * @param vmWrapperGenerator - Function that generates the VM wrapper code
+ * @param distDir - Distribution directory
+ * @param sourceFilePath - Path to source file containing the component
+ * @returns Compressed base64-encoded bundled code
+ */
+async function bundleAndCompressExecuteFunction(executeFunction, componentName, componentType, vmWrapperGenerator, distDir, sourceFilePath) {
+    const { compressCode } = await import('./compile.js');
+    // Create temporary file with the execute function wrapped as a module
+    const tempDir = path.join(distDir, '.temp');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const tempFile = path.join(tempDir, `${componentName}-${componentType}.ts`);
+    const tempOutput = path.join(tempDir, `${componentName}-${componentType}.js`);
+    try {
+        // Extract relevant imports from source file
+        const relevantImports = extractRelevantImports(sourceFilePath);
+        // Write execute function as a module export with all relevant imports
+        const moduleCode = `
+// ${componentType} execute function for ${componentName}
+${relevantImports.join('\n')}
+
+// The execute function with all dependencies available
+const executeFunc = ${executeFunction};
+
+export default executeFunc;
+`;
+        fs.writeFileSync(tempFile, moduleCode);
+        // Bundle with esbuild using the source file's directory for import resolution
+        await build({
+            entryPoints: [tempFile],
+            bundle: true,
+            platform: 'node',
+            target: 'node16',
+            format: 'cjs',
+            minify: true,
+            outfile: tempOutput,
+            external: [...EXTERNAL_PACKAGES], // Use same external packages as tools
+            plugins: [sandboxGlobalsPlugin],
+            absWorkingDir: path.dirname(sourceFilePath), // Use source file's directory for resolution
+        });
+        // Read bundled code
+        const bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        // Wrap for VM execution using provided generator
+        const wrappedCode = vmWrapperGenerator(bundledCode);
+        // 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 ${componentType} ${componentName} code:`, 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 '';
+    }
+}
 /**
  * esbuild plugin to inject sandbox globals instead of requiring lua-cli
  * This removes require("lua-cli") statements and injects the global API objects
@@ -226,6 +328,7 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
         let querySchema = undefined;
         let headerSchema = undefined;
         let bodySchema = undefined;
+        let sourceFilePath = indexFile.getFilePath();
         // Helper function to search for webhook in a file
         const searchFileForWebhook = (file) => {
             file.forEachDescendant((node) => {
@@ -271,6 +374,8 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
                                 querySchema = foundQuerySchema;
                                 headerSchema = foundHeaderSchema;
                                 bodySchema = foundBodySchema;
+                                // Update source file path to the file where webhook was found
+                                sourceFilePath = file.getFilePath();
                             }
                         }
                     }
@@ -315,7 +420,7 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
         // Bundle and compress the execute function (like tools)
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressWebhookCode(executeFunction, webhook.name, distDir);
+            compressedCode = await bundleAndCompressWebhookCode(executeFunction, webhook.name, distDir, sourceFilePath);
         }
         return {
             ...webhook,
@@ -332,44 +437,16 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
 /**
  * Bundles and compresses webhook execute function code.
  * Creates a temporary file, bundles with esbuild, compresses with gzip.
+ * Includes all imports from the source file to ensure dependencies are bundled.
  *
  * @param executeFunction - Raw execute function code
  * @param webhookName - Name of the webhook
  * @param distDir - Distribution directory
+ * @param sourceFilePath - Path to the source file containing the webhook
  * @returns Compressed base64-encoded bundled code
  */
-async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDir) {
-    const { compressCode } = await import('./compile.js');
-    // Create temporary file with the execute function wrapped as a module
-    const tempDir = path.join(distDir, '.temp');
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-    }
-    const tempFile = path.join(tempDir, `${webhookName}-webhook.ts`);
-    const tempOutput = path.join(tempDir, `${webhookName}-webhook.js`);
-    try {
-        // Write execute function as a module export
-        const moduleCode = stripLuaCliImports(`
-// Webhook execute function for ${webhookName}
-export default ${executeFunction};
-`);
-        fs.writeFileSync(tempFile, moduleCode);
-        // Bundle with esbuild
-        await build({
-            entryPoints: [tempFile],
-            bundle: true,
-            platform: 'node',
-            target: 'node16',
-            format: 'cjs',
-            minify: true,
-            outfile: tempOutput,
-            external: [], // Bundle everything
-            plugins: [sandboxGlobalsPlugin],
-        });
-        // Read bundled code
-        let bundledCode = fs.readFileSync(tempOutput, 'utf8');
-        // Wrap for webhook VM execution (similar to tools)
-        const wrappedCode = `(async (query, headers, body) => {
+async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDir, sourceFilePath) {
+    return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (query, headers, body) => {
   
   // Execute the bundled webhook code
   ${bundledCode}
@@ -379,33 +456,7 @@ export default ${executeFunction};
   
   // Execute with three separate parameters (not an object)
   return await executeFunction(query, headers, body);
-})`;
-        // 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 webhook ${webhookName} code:`, 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 '';
-    }
+})`, distDir, sourceFilePath);
 }
 /**
  * Extracts and bundles job execute function.
@@ -421,6 +472,7 @@ export async function bundleJob(job, indexFile, distDir, project) {
     try {
         // Find the LuaJob constructor in the AST
         let executeFunction = '';
+        let sourceFilePath = indexFile.getFilePath();
         // Helper function to search for job in a file
         const searchFileForJob = (file) => {
             file.forEachDescendant((node) => {
@@ -451,6 +503,8 @@ export async function bundleJob(job, indexFile, distDir, project) {
                             // Only set executeFunction if this is the matching job
                             if (isMatchingJob && foundExecute) {
                                 executeFunction = foundExecute;
+                                // Update source file path to the file where job was found
+                                sourceFilePath = file.getFilePath();
                             }
                         }
                     }
@@ -484,7 +538,7 @@ export async function bundleJob(job, indexFile, distDir, project) {
         // Bundle and compress the execute function (like tools)
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressJobCode(executeFunction, job.name, distDir);
+            compressedCode = await bundleAndCompressJobCode(executeFunction, job.name, distDir, sourceFilePath);
         }
         return {
             ...job,
@@ -500,44 +554,16 @@ export async function bundleJob(job, indexFile, distDir, project) {
 /**
  * Bundles and compresses job execute function code.
  * Creates a temporary file, bundles with esbuild, compresses with gzip.
+ * Includes all imports from the source file to ensure dependencies are bundled.
  *
  * @param executeFunction - Raw execute function code
  * @param jobName - Name of the job
  * @param distDir - Distribution directory
+ * @param sourceFilePath - Path to the source file containing the job
  * @returns Compressed base64-encoded bundled code
  */
-async function bundleAndCompressJobCode(executeFunction, jobName, distDir) {
-    const { compressCode } = await import('./compile.js');
-    // Create temporary file with the execute function wrapped as a module
-    const tempDir = path.join(distDir, '.temp');
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-    }
-    const tempFile = path.join(tempDir, `${jobName}-job.ts`);
-    const tempOutput = path.join(tempDir, `${jobName}-job.js`);
-    try {
-        // Write execute function as a module export
-        const moduleCode = stripLuaCliImports(`
-// Job execute function for ${jobName}
-export default ${executeFunction};
-`);
-        fs.writeFileSync(tempFile, moduleCode);
-        // Bundle with esbuild
-        await build({
-            entryPoints: [tempFile],
-            bundle: true,
-            platform: 'node',
-            target: 'node16',
-            format: 'cjs',
-            minify: true,
-            outfile: tempOutput,
-            external: [], // Bundle everything
-            plugins: [sandboxGlobalsPlugin],
-        });
-        // Read bundled code
-        let bundledCode = fs.readFileSync(tempOutput, 'utf8');
-        // Wrap for job VM execution (similar to tools, but accepts job parameter)
-        const wrappedCode = `(async (job) => {
+async function bundleAndCompressJobCode(executeFunction, jobName, distDir, sourceFilePath) {
+    return bundleAndCompressExecuteFunction(executeFunction, jobName, 'job', (bundledCode) => `(async (job) => {
   // Execute the bundled job code
   ${bundledCode}
   
@@ -546,33 +572,7 @@ export default ${executeFunction};
   
   // Execute job with job instance parameter
   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 ${jobName} code:`, 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 '';
-    }
+})`, distDir, sourceFilePath);
 }
 /**
  * Bundles and compresses preprocessor execute function code.
@@ -581,6 +581,7 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
     writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
     try {
         let executeFunction = '';
+        let sourceFilePath = indexFile.getFilePath();
         const searchFileForPreProcessor = (file) => {
             file.forEachDescendant((node) => {
                 if (Node.isNewExpression(node)) {
@@ -608,6 +609,8 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
                             });
                             if (isMatching && foundExecute) {
                                 executeFunction = foundExecute;
+                                // Update source file path to the file where preprocessor was found
+                                sourceFilePath = file.getFilePath();
                             }
                         }
                     }
@@ -639,7 +642,7 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
         }
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir);
+            compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir, sourceFilePath);
         }
         return {
             name: preprocessor.name,
@@ -663,6 +666,7 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
     writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
     try {
         let executeFunction = '';
+        let sourceFilePath = indexFile.getFilePath();
         const searchFileForPostProcessor = (file) => {
             file.forEachDescendant((node) => {
                 if (Node.isNewExpression(node)) {
@@ -690,6 +694,8 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
                             });
                             if (isMatching && foundExecute) {
                                 executeFunction = foundExecute;
+                                // Update source file path to the file where postprocessor was found
+                                sourceFilePath = file.getFilePath();
                             }
                         }
                     }
@@ -721,7 +727,7 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
         }
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir);
+            compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir, sourceFilePath);
         }
         return {
             name: postprocessor.name,
@@ -740,65 +746,18 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
 }
 /**
  * Bundles and compresses processor execute function code.
+ * Includes all imports from the source file to ensure dependencies are bundled.
  */
-async function bundleAndCompressProcessorCode(executeFunction, processorName, type, distDir) {
-    const { compressCode } = await import('./compile.js');
-    const tempDir = path.join(distDir, '.temp');
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-    }
-    const tempFile = path.join(tempDir, `${processorName}-${type}processor.ts`);
-    const tempOutput = path.join(tempDir, `${processorName}-${type}processor.js`);
-    try {
-        // Processor execute functions receive: (user, message, [response], channel)
-        const paramList = type === 'pre' ? 'user, message, channel' : 'user, message, response, channel';
-        const moduleCode = stripLuaCliImports(`
-// ${type === 'pre' ? 'Pre' : 'Post'}Processor execute function for ${processorName}
-export default ${executeFunction};
-`);
-        fs.writeFileSync(tempFile, moduleCode);
-        await build({
-            entryPoints: [tempFile],
-            bundle: true,
-            platform: 'node',
-            target: 'node16',
-            format: 'cjs',
-            minify: true,
-            outfile: tempOutput,
-            external: [],
-            plugins: [sandboxGlobalsPlugin],
-        });
-        let bundledCode = fs.readFileSync(tempOutput, 'utf8');
-        const wrappedCode = `(async (${paramList}) => {
+async function bundleAndCompressProcessorCode(executeFunction, processorName, type, distDir, sourceFilePath) {
+    // Processor execute functions receive: (user, message, [response], channel)
+    const paramList = type === 'pre' ? 'user, message, channel' : 'user, message, response, channel';
+    return bundleAndCompressExecuteFunction(executeFunction, processorName, `${type}processor`, (bundledCode) => `(async (${paramList}) => {
   // Execute the bundled processor code
   ${bundledCode}
   
   const executeFunction = module.exports.default || module.exports;
   return await executeFunction(${paramList});
-})`;
-        const compressed = compressCode(wrappedCode);
-        try {
-            fs.unlinkSync(tempFile);
-            fs.unlinkSync(tempOutput);
-        }
-        catch (cleanupError) {
-            // Ignore
-        }
-        return compressed;
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle ${type}processor ${processorName} code:`, error);
-        try {
-            if (fs.existsSync(tempFile))
-                fs.unlinkSync(tempFile);
-            if (fs.existsSync(tempOutput))
-                fs.unlinkSync(tempOutput);
-        }
-        catch (cleanupError) {
-            // Ignore
-        }
-        return '';
-    }
+})`, distDir, sourceFilePath);
 }
 /**
  * Extracts execute code and input schema from a tool.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.2-alpha.1",
+  "version": "3.0.2-alpha.2",
   "description": "Build, test, and deploy AI agents with custom tools, webhooks, and scheduled jobs. Features LuaAgent unified configuration, streaming chat, and batch deployment.",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",
@@ -89,6 +89,7 @@
     "@types/inquirer": "^9.0.9",
     "@types/jest": "^29.5.8",
     "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.20",
     "@types/node": "^24.5.1",
     "@types/node-fetch": "^2.6.13",
     "@types/react": "^18.2.0",
@@ -96,7 +97,10 @@
     "@types/ws": "^8.18.1",
     "@typescript-eslint/parser": "^8.44.1",
     "@typescript-eslint/typescript-estree": "^8.44.1",
+    "date-fns": "^4.1.0",
     "jest": "^29.7.0",
+    "lodash": "^4.17.21",
+    "stripe": "^19.2.0",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.2"

package/template/package.json

@@ -20,7 +20,7 @@
     "inquirer": "^12.9.6",
     "stripe": "^17.5.0",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^3.0.2-alpha.1",
+    "lua-cli": "file:..",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"

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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,143 +0,0 @@
-/**
- * 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
-        }
-    }
-}