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

package/dist/cli/command-definitions.js

@@ -51,6 +51,7 @@ export function setupSkillCommands(program) {
     program
         .command("compile")
         .description("📦 Compile skill to deployable format")
+        .option("--debug", "Enable debug mode with verbose logging and temp file preservation")
         .action(compileCommand);
     program
         .command("test [type]")

package/dist/commands/compile.d.ts

@@ -27,6 +27,9 @@
  * - Skills deleted from code are removed from YAML
  * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
+ * @param options - Command options including debug flag
  * @returns Promise that resolves when compilation is complete
  */
-export declare function compileCommand(): Promise<void>;
+export declare function compileCommand(options?: {
+    debug?: boolean;
+}): Promise<void>;

package/dist/commands/compile.js

@@ -43,17 +43,43 @@ import { syncAgentPersonaWithYaml } from '../utils/agent-management.js';
  * - Skills deleted from code are removed from YAML
  * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
+ * @param options - Command options including debug flag
  * @returns Promise that resolves when compilation is complete
  */
-export async function compileCommand() {
+export async function compileCommand(options) {
     return withErrorHandling(async () => {
+        const debugMode = options?.debug || process.env.LUA_DEBUG === 'true';
+        if (debugMode) {
+            console.log('🐛 Debug mode enabled');
+            console.log('   - Verbose logging: ON');
+            console.log('   - Temp file preservation: ON');
+            console.log('   - Full error stacks: ON\n');
+        }
         writeProgress("🔨 Compiling Lua skill...");
+        // Track compilation issues
+        const compilationWarnings = [];
+        const failedBundles = [];
+        const startTime = Date.now();
         // Step 1: Prepare output directories
+        if (debugMode)
+            console.log('📁 Preparing output directories...');
         const { distDir, luaDir } = prepareOutputDirectories();
+        if (debugMode)
+            console.log(`   ✓ Created: ${distDir}`);
+        if (debugMode)
+            console.log(`   ✓ Created: ${luaDir}\n`);
         // Step 2: Analyze TypeScript project and detect tools
+        if (debugMode)
+            console.log('🔍 Finding index file...');
         const indexPath = findIndexFile();
+        if (debugMode)
+            console.log(`   ✓ Found: ${indexPath}\n`);
+        if (debugMode)
+            console.log('📚 Creating TypeScript project...');
         const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
+        if (debugMode)
+            console.log(`   ✓ Loaded source file\n`);
         // Step 2a: Check for LuaAgent (unified agent configuration)
         writeProgress("🔍 Checking for LuaAgent configuration...");
         const { extractLuaAgentMetadata, resolveLuaAgentReferences, getSkillFilePaths } = await import('../utils/compile.js');
@@ -69,7 +95,7 @@ export async function compileCommand() {
             resolvedAgentData = resolveLuaAgentReferences(agentMetadata, indexFile, project);
             // Get file paths where skills are defined so we can scan them for tools
             skillFilePaths = getSkillFilePaths(agentMetadata, indexFile);
-            writeProgress(`📦 Agent contains: ${resolvedAgentData.skills.length} skill(s), ${resolvedAgentData.webhooks.length} webhook(s), ${resolvedAgentData.jobs.length} job(s), ${resolvedAgentData.preProcessors.length} preprocessor(s), ${resolvedAgentData.postProcessors.length} postprocessor(s)`);
+            writeProgress(`📦 Agent contains: ${resolvedAgentData?.skills?.length || 0} skill(s), ${resolvedAgentData?.webhooks?.length || 0} webhook(s), ${resolvedAgentData?.jobs?.length || 0} job(s), ${resolvedAgentData?.preProcessors?.length || 0} preprocessor(s), ${resolvedAgentData?.postProcessors?.length || 0} postprocessor(s)`);
         }
         else {
             writeProgress(`ℹ️  No LuaAgent found, using legacy detection for individual components`);
@@ -80,21 +106,41 @@ export async function compileCommand() {
         // Step 3: Bundle each tool and extract metadata
         const { preBundleJobsInSource, replaceJobPlaceholders } = await import('../utils/pre-bundle-jobs.js');
         for (const tool of tools) {
+            if (debugMode)
+                console.log(`\n🔧 Processing tool: ${tool.className}`);
+            if (debugMode)
+                console.log(`   File: ${tool.filePath}`);
             // Step 3a: Pre-bundle any Jobs.create() in the tool source
+            const toolStartTime = Date.now();
             const { modifiedSource, jobBundles } = await preBundleJobsInSource(tool.filePath, project, distDir);
+            if (debugMode && jobBundles.size > 0) {
+                console.log(`   ✓ Found ${jobBundles.size} nested job(s) to pre-bundle`);
+            }
             // Step 3b: Bundle the tool (with placeholders for job execute functions)
-            await bundleTool(tool, distDir, modifiedSource);
+            await bundleTool(tool, distDir, modifiedSource, debugMode);
             // Step 3c: Replace placeholders in the bundled tool file
             if (jobBundles.size > 0) {
                 const toolBundlePath = path.join(distDir, 'tools', `${tool.className}.js`);
                 if (fs.existsSync(toolBundlePath)) {
                     let bundledToolCode = fs.readFileSync(toolBundlePath, 'utf8');
+                    const beforeSize = bundledToolCode.length;
                     bundledToolCode = replaceJobPlaceholders(bundledToolCode, jobBundles);
+                    const afterSize = bundledToolCode.length;
+                    if (debugMode)
+                        console.log(`   ✓ Replaced placeholders (+${afterSize - beforeSize} bytes)`);
                     fs.writeFileSync(toolBundlePath, bundledToolCode);
                 }
             }
             // Step 3d: Extract execute code
             await extractExecuteCode(tool, project, distDir);
+            if (debugMode) {
+                const toolTime = Date.now() - toolStartTime;
+                const bundledPath = path.join(distDir, 'tools', `${tool.className}.js`);
+                if (fs.existsSync(bundledPath)) {
+                    const size = fs.statSync(bundledPath).size;
+                    console.log(`   ✓ Bundled: ${(size / 1024).toFixed(2)}KB in ${toolTime}ms`);
+                }
+            }
         }
         // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);
@@ -119,8 +165,15 @@ export async function compileCommand() {
             writeProgress(`📦 Found ${webhooksMetadata.length} webhook(s)...`);
             // Bundle each webhook (extract execute function and schemas)
             for (const webhook of webhooksMetadata) {
-                const bundled = await bundleWebhook(webhook, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n🌐 Processing webhook: ${webhook.name}`);
+                const webhookStartTime = Date.now();
+                const bundled = await bundleWebhook(webhook, indexFile, distDir, project, debugMode);
                 bundledWebhooks.push(bundled);
+                if (debugMode) {
+                    const webhookTime = Date.now() - webhookStartTime;
+                    console.log(`   ✓ Completed in ${webhookTime}ms`);
+                }
             }
             // Ensure webhooks exist in YAML with valid IDs
             const configForWebhooks = readSkillConfig(); // Re-read for webhooks
@@ -141,8 +194,15 @@ export async function compileCommand() {
             writeProgress(`📦 Found ${jobsMetadata.length} job(s)...`);
             // Bundle each job (extract execute function)
             for (const job of jobsMetadata) {
-                const bundled = await bundleJob(job, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚙️  Processing job: ${job.name}`);
+                const jobStartTime = Date.now();
+                const bundled = await bundleJob(job, indexFile, distDir, project, debugMode);
                 bundledJobs.push(bundled);
+                if (debugMode) {
+                    const jobTime = Date.now() - jobStartTime;
+                    console.log(`   ✓ Completed in ${jobTime}ms`);
+                }
             }
             // Ensure jobs exist in YAML with valid IDs
             const configForJobs = readSkillConfig(); // Re-read for jobs
@@ -162,7 +222,9 @@ export async function compileCommand() {
         if (preprocessorsMetadata.length > 0) {
             writeProgress(`📦 Found ${preprocessorsMetadata.length} preprocessor(s)...`);
             for (const preprocessor of preprocessorsMetadata) {
-                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚡ Processing preprocessor: ${preprocessor.name}`);
+                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project, debugMode);
                 bundledPreProcessors.push(bundled);
             }
             // Ensure preprocessors exist in YAML with valid IDs
@@ -182,7 +244,9 @@ export async function compileCommand() {
         if (postprocessorsMetadata.length > 0) {
             writeProgress(`📦 Found ${postprocessorsMetadata.length} postprocessor(s)...`);
             for (const postprocessor of postprocessorsMetadata) {
-                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚡ Processing postprocessor: ${postprocessor.name}`);
+                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project, debugMode);
                 bundledPostProcessors.push(bundled);
             }
             // Ensure postprocessors exist in YAML with valid IDs
@@ -194,6 +258,7 @@ export async function compileCommand() {
             await syncServerPostProcessorsWithYaml(postprocessorConfig);
             fs.writeFileSync(path.join(distDir, 'postprocessors.json'), JSON.stringify(bundledPostProcessors, null, 2));
         }
+        // Build compilation summary
         const summaryParts = [`${tools.length} tools bundled`];
         if (webhooksMetadata.length > 0)
             summaryParts.push(`${webhooksMetadata.length} webhook(s) registered`);
@@ -203,6 +268,36 @@ export async function compileCommand() {
             summaryParts.push(`${preprocessorsMetadata.length} preprocessor(s) registered`);
         if (postprocessorsMetadata.length > 0)
             summaryParts.push(`${postprocessorsMetadata.length} postprocessor(s) registered`);
+        // Check for empty bundles (potential failures)
+        const emptyBundles = [];
+        for (const tool of tools) {
+            const bundledPath = path.join(distDir, 'tools', `${tool.className}.js`);
+            if (fs.existsSync(bundledPath)) {
+                const size = fs.statSync(bundledPath).size;
+                if (size < 100) { // Less than 100 bytes is suspiciously small
+                    emptyBundles.push(`${tool.className} (${size} bytes)`);
+                }
+            }
+            else {
+                emptyBundles.push(`${tool.className} (file missing)`);
+            }
+        }
+        if (emptyBundles.length > 0) {
+            console.warn(`\n⚠️  Warning: ${emptyBundles.length} tool(s) may have bundling issues:`);
+            emptyBundles.forEach(name => console.warn(`   - ${name}`));
+            console.warn(`   Run with NODE_ENV=development for detailed error logs.\n`);
+        }
+        const totalTime = Date.now() - startTime;
+        if (debugMode) {
+            console.log(`\n⏱️  Total compilation time: ${(totalTime / 1000).toFixed(2)}s`);
+            console.log(`📊 Output directories:`);
+            console.log(`   - ${distDir}`);
+            console.log(`   - ${luaDir}`);
+            const tempDir = path.join(distDir, '.temp');
+            if (fs.existsSync(tempDir)) {
+                console.log(`   - ${tempDir} (preserved for debugging)`);
+            }
+        }
         writeSuccess(`✅ Skill compiled successfully - ${summaryParts.join(', ')}`);
     }, "compilation");
 }
@@ -230,11 +325,22 @@ function prepareOutputDirectories() {
 }
 /**
  * Creates and configures a TypeScript project for AST analysis.
+ * Validates that tsconfig.json exists before creating project.
  *
  * @returns Configured ts-morph Project instance
+ * @throws Error if tsconfig.json is missing or invalid
  */
 function createTypeScriptProject() {
-    return new Project({
-        tsConfigFilePath: path.join(process.cwd(), COMPILE_FILES.TSCONFIG_JSON),
-    });
+    const tsconfigPath = path.join(process.cwd(), COMPILE_FILES.TSCONFIG_JSON);
+    if (!fs.existsSync(tsconfigPath)) {
+        throw new Error(`tsconfig.json not found at ${tsconfigPath}\n` +
+            `Please ensure you're in a Lua CLI project directory.`);
+    }
+    try {
+        return new Project({ tsConfigFilePath: tsconfigPath });
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tsconfig.json: ${error.message}\n` +
+            `Please check that your tsconfig.json is valid.`);
+    }
 }

package/dist/utils/bundling.d.ts

@@ -22,8 +22,10 @@ export declare const sandboxGlobalsPlugin: Plugin;
  *
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
+ * @param modifiedSource - Optional modified source (for pre-bundled jobs)
+ * @param debugMode - Enable verbose logging and preserve temp files
  */
-export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string): Promise<void>;
+export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string, debugMode?: boolean): Promise<void>;
 /**
  * Bundles the main index.ts file into a standalone JavaScript file.
  * This creates the entry point for the skill.
@@ -39,9 +41,10 @@ export declare function bundleMainIndex(indexPath: string, distDir: string): Pro
  * @param indexFile - The TypeScript source file containing the webhook
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Webhook with bundled code and schemas
  */
-export declare function bundleWebhook(webhook: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundleWebhook(webhook: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Extracts and bundles job execute function.
  *
@@ -49,17 +52,18 @@ export declare function bundleWebhook(webhook: any, indexFile: any, distDir: str
  * @param indexFile - The TypeScript source file containing the job
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Job with bundled code
  */
-export declare function bundleJob(job: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundleJob(job: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Bundles and compresses preprocessor execute function code.
  */
-export declare function bundlePreProcessor(preprocessor: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundlePreProcessor(preprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Bundles and compresses postprocessor execute function code.
  */
-export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Extracts execute code and input schema from a tool.
  * This function:

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,156 @@ 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
+ * @param debugMode - Enable verbose logging and preserve temp files
+ * @returns Compressed base64-encoded bundled code
+ */
+async function bundleAndCompressExecuteFunction(executeFunction, componentName, componentType, vmWrapperGenerator, distDir, sourceFilePath, debugMode) {
+    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);
+        if (debugMode) {
+            console.log(`   → Found ${relevantImports.length} import(s) to bundle`);
+            if (relevantImports.length > 0 && debugMode) {
+                relevantImports.forEach(imp => console.log(`     - ${imp}`));
+            }
+        }
+        // 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);
+        if (debugMode) {
+            console.log(`   → Created temp file: ${path.basename(tempFile)}`);
+        }
+        // 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 and validate it exists and has content
+        if (!fs.existsSync(tempOutput)) {
+            throw new Error(`esbuild failed to create output file for ${componentName}`);
+        }
+        const bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        if (bundledCode.length === 0) {
+            throw new Error(`esbuild created empty bundle for ${componentName}`);
+        }
+        // Wrap for VM execution using provided generator
+        const wrappedCode = vmWrapperGenerator(bundledCode);
+        // Compress the wrapped code
+        const compressed = compressCode(wrappedCode);
+        if (debugMode) {
+            console.log(`   → Bundle size: ${(bundledCode.length / 1024).toFixed(2)}KB (uncompressed)`);
+            console.log(`   → Compressed: ${(compressed.length / 1024).toFixed(2)}KB (base64 gzip)`);
+        }
+        // Clean up temp files (unless in debug mode)
+        if (!debugMode) {
+            try {
+                fs.unlinkSync(tempFile);
+                fs.unlinkSync(tempOutput);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
+        else {
+            console.log(`   ℹ️  Preserved temp files for debugging:`);
+            console.log(`      - ${tempFile}`);
+            console.log(`      - ${tempOutput}`);
+        }
+        return compressed;
+    }
+    catch (error) {
+        // Provide helpful error messages based on error type
+        let errorMessage = `Warning: Could not bundle ${componentType} ${componentName}`;
+        if (error.message && error.message.includes('Could not resolve')) {
+            errorMessage += `\n  Dependency resolution failed: ${error.message}`;
+            errorMessage += `\n  Hint: Ensure all imported packages are in package.json and run 'npm install'`;
+        }
+        else if (error.message && error.message.includes('Transform failed')) {
+            errorMessage += `\n  TypeScript compilation failed: ${error.message}`;
+            errorMessage += `\n  Hint: Check syntax in ${path.basename(sourceFilePath)}`;
+        }
+        else {
+            errorMessage += `: ${error.message || error}`;
+        }
+        console.warn(errorMessage);
+        if (debugMode && error.stack) {
+            console.error('   Full stack trace:', error.stack);
+        }
+        // Clean up on error (unless in debug mode)
+        if (!debugMode) {
+            try {
+                if (fs.existsSync(tempFile))
+                    fs.unlinkSync(tempFile);
+                if (fs.existsSync(tempOutput))
+                    fs.unlinkSync(tempOutput);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
+        else {
+            console.log(`   ℹ️  Temp files preserved for debugging (check dist/.temp/)`);
+        }
+        return '';
+    }
+}
 /**
  * esbuild plugin to inject sandbox globals instead of requiring lua-cli
  * This removes require("lua-cli") statements and injects the global API objects
@@ -109,9 +259,14 @@ export const sandboxGlobalsPlugin = {
  *
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
+ * @param modifiedSource - Optional modified source (for pre-bundled jobs)
+ * @param debugMode - Enable verbose logging and preserve temp files
  */
-export async function bundleTool(tool, distDir, modifiedSource) {
-    writeProgress(`📦 Bundling ${tool.className}...`);
+export async function bundleTool(tool, distDir, modifiedSource, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling ${tool.className}...`);
+    if (debugMode)
+        console.log(`   → Bundling ${tool.className}...`);
     try {
         const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
         let entryPoint = tool.filePath;
@@ -175,8 +330,8 @@ export async function bundleTool(tool, distDir, modifiedSource) {
         }
         // Wrap the bundled code for VM execution environment
         await wrapToolForVM(outputPath, tool);
-        // Clean up temp file if created
-        if (tempFile && fs.existsSync(tempFile)) {
+        // Clean up temp file if created (unless in debug mode)
+        if (tempFile && fs.existsSync(tempFile) && !debugMode) {
             try {
                 fs.unlinkSync(tempFile);
             }
@@ -184,9 +339,16 @@ export async function bundleTool(tool, distDir, modifiedSource) {
                 // Ignore cleanup errors
             }
         }
+        else if (tempFile && debugMode) {
+            if (debugMode)
+                console.log(`   ℹ️  Preserved temp file: ${tempFile}`);
+        }
     }
     catch (error) {
         console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
+        if (debugMode && error instanceof Error) {
+            console.error('   Stack trace:', error.stack);
+        }
     }
 }
 /**
@@ -216,16 +378,19 @@ export async function bundleMainIndex(indexPath, distDir) {
  * @param indexFile - The TypeScript source file containing the webhook
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Webhook with bundled code and schemas
  */
-export async function bundleWebhook(webhook, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling webhook ${webhook.name}...`);
+export async function bundleWebhook(webhook, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling webhook ${webhook.name}...`);
     try {
         // Find the LuaWebhook constructor in the AST
         let executeFunction = '';
         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 +436,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 +482,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, debugMode);
         }
         return {
             ...webhook,
@@ -332,44 +499,17 @@ 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
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @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, debugMode) {
+    return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (query, headers, body) => {
   
   // Execute the bundled webhook code
   ${bundledCode}
@@ -379,33 +519,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, debugMode);
 }
 /**
  * Extracts and bundles job execute function.
@@ -414,13 +528,16 @@ export default ${executeFunction};
  * @param indexFile - The TypeScript source file containing the job
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Job with bundled code
  */
-export async function bundleJob(job, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling job ${job.name}...`);
+export async function bundleJob(job, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling job ${job.name}...`);
     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 +568,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 +603,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, debugMode);
         }
         return {
             ...job,
@@ -500,44 +619,17 @@ 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
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @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, debugMode) {
+    return bundleAndCompressExecuteFunction(executeFunction, jobName, 'job', (bundledCode) => `(async (job) => {
   // Execute the bundled job code
   ${bundledCode}
   
@@ -546,41 +638,17 @@ 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, debugMode);
 }
 /**
  * Bundles and compresses preprocessor execute function code.
  */
-export async function bundlePreProcessor(preprocessor, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
+export async function bundlePreProcessor(preprocessor, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
     try {
         let executeFunction = '';
+        let sourceFilePath = indexFile.getFilePath();
         const searchFileForPreProcessor = (file) => {
             file.forEachDescendant((node) => {
                 if (Node.isNewExpression(node)) {
@@ -608,6 +676,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 +709,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, debugMode);
         }
         return {
             name: preprocessor.name,
@@ -659,10 +729,12 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
 /**
  * Bundles and compresses postprocessor execute function code.
  */
-export async function bundlePostProcessor(postprocessor, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
+export async function bundlePostProcessor(postprocessor, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
     try {
         let executeFunction = '';
+        let sourceFilePath = indexFile.getFilePath();
         const searchFileForPostProcessor = (file) => {
             file.forEachDescendant((node) => {
                 if (Node.isNewExpression(node)) {
@@ -690,6 +762,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 +795,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, debugMode);
         }
         return {
             name: postprocessor.name,
@@ -740,65 +814,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, debugMode) {
+    // 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, debugMode);
 }
 /**
  * Extracts execute code and input schema from a tool.

package/dist/utils/compile.d.ts

@@ -12,7 +12,10 @@ export declare function compressCode(code: string): string;
  */
 export declare function findIndexFile(): string;
 /**
- * Resolves import path from module specifier
+ * Resolves import path from module specifier with support for multiple extensions and index files
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * @param currentFilePath - The file doing the importing
+ * @returns Resolved absolute file path
  */
 export declare function resolveImportPath(moduleSpecifier: string, currentFilePath: string): string;
 /**

package/dist/utils/compile.js

@@ -29,16 +29,37 @@ export function findIndexFile() {
     throw new Error("index.ts not found in current directory or src/ directory");
 }
 /**
- * Resolves import path from module specifier
+ * Resolves import path from module specifier with support for multiple extensions and index files
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * @param currentFilePath - The file doing the importing
+ * @returns Resolved absolute file path
  */
 export function resolveImportPath(moduleSpecifier, currentFilePath) {
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
     if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
         // Relative import - resolve relative to current file
         const currentDir = path.dirname(currentFilePath);
-        return path.resolve(currentDir, moduleSpecifier + '.ts');
+        const basePath = path.resolve(currentDir, moduleSpecifier);
+        // Try each extension in order
+        for (const ext of extensions) {
+            const fullPath = ext.startsWith('/') ? path.join(basePath, ext) : basePath + ext;
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        // Fallback: return .ts extension (original behavior)
+        return basePath + '.ts';
     }
     else {
-        // Absolute import - assume it's in the project
+        // Absolute import - check in src/ directory
+        const srcBase = path.resolve(process.cwd(), 'src', moduleSpecifier);
+        for (const ext of extensions) {
+            const fullPath = ext.startsWith('/') ? path.join(srcBase, ext) : srcBase + ext;
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        // Fallback: return .ts in src/ (original behavior)
         return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
     }
 }

package/dist/utils/deployment.js

@@ -56,6 +56,10 @@ function readPackageJson() {
  */
 export async function createLegacyDeploymentData(tools, luaDir, indexFile, agentData) {
     const config = readSkillConfig();
+    // Handle null config gracefully
+    if (!config) {
+        console.warn('⚠️  Warning: lua.skill.yaml not found. Creating deployment with default configuration.');
+    }
     let skillsMetadata;
     // Check if we have agent data (from LuaAgent approach)
     if (agentData && agentData.skills && agentData.skills.length > 0) {
@@ -75,9 +79,9 @@ export async function createLegacyDeploymentData(tools, luaDir, indexFile, agent
     // Build skills array with their associated tools
     const skillsArray = buildSkillsArray(skillsMetadata, skillToTools, tools);
     // Ensure all skills exist in YAML config and have valid IDs
-    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
+    const updatedSkillsArray = config ? await ensureSkillsExistInYaml(skillsArray, config) : skillsArray;
     // Override versions from YAML config if they exist
-    const finalSkillsArray = overrideVersionsFromConfig(updatedSkillsArray, config);
+    const finalSkillsArray = config ? overrideVersionsFromConfig(updatedSkillsArray, config) : updatedSkillsArray;
     // Write deployment data
     const deployData = {
         skills: finalSkillsArray
@@ -169,6 +173,10 @@ function buildSkillsArray(skillsMetadata, skillToTools, tools) {
  * @returns Skills array with versions overridden from config
  */
 function overrideVersionsFromConfig(skillsArray, config) {
+    // Handle null config
+    if (!config) {
+        return skillsArray;
+    }
     // Get version map from YAML config
     const configVersionMap = new Map();
     if (config.skills && Array.isArray(config.skills)) {

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

@@ -22,5 +22,6 @@ export declare function preBundleJobsInSource(sourceFilePath: string, project: P
 /**
  * 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
+ * Validates that all placeholders are found and replaced
  */
 export declare function replaceJobPlaceholders(bundledCode: string, jobBundles: Map<string, string>): string;

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

@@ -162,15 +162,27 @@ export default executeFunc;
 /**
  * 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
+ * Validates that all placeholders are found and replaced
  */
 export function replaceJobPlaceholders(bundledCode, jobBundles) {
     let result = bundledCode;
+    const replacementsMade = new Map();
     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');
+        // Use word boundary to prevent partial matches
+        const placeholderPattern = new RegExp(`\\b${placeholder}\\b`, 'g');
+        const beforeLength = result.length;
         result = result.replace(placeholderPattern, bundledJobCode);
-        // console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+        const wasReplaced = result.length !== beforeLength;
+        replacementsMade.set(placeholder, wasReplaced);
+        if (wasReplaced) {
+            // console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+        }
+        else {
+            console.warn(`⚠️  Warning: Placeholder ${placeholder} not found in bundled code. Nested job may not work correctly.`);
+            console.warn(`    This can happen if esbuild mangled the identifier during minification.`);
+        }
     });
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.2-alpha.1",
+  "version": "3.0.2-alpha.3",
   "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/lua.skill.yaml

@@ -0,0 +1 @@
+skills: []

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