lua-cli 3.5.0-alpha.3 → 3.5.0-beta.1

package/dist/utils/bundling.js

@@ -1,1068 +0,0 @@
-/**
- * Bundling Utilities
- * Handles esbuild bundling of tools and main index
- */
-import fs from "fs";
-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, EXTERNAL_PACKAGES, } from '../config/compile.constants.js';
-import { wrapExecuteForVM, wrapConditionForVM, evaluateZodSchemaToJsonSchema } from './compile.js';
-import { evaluate } from 'ts-evaluator';
-import ts from 'typescript';
-/**
- * Helper function to remove lua-cli and api-exports imports from source code.
- * Used when bundling via stdin or temp files where the plugin can't process them.
- */
-function stripLuaCliImports(sourceCode) {
-    return sourceCode
-        // Remove api-exports imports
-        .replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, '// api-exports imports removed - using sandbox globals')
-        // Remove lua-cli imports
-        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, '// lua-cli imports removed - using sandbox globals')
-        // Remove lua-cli/skill imports (but keep LuaTool, etc. for type checking in temp files)
-        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli\/skill["'];?/g, (match, imports) => {
-        // Keep only LuaTool, LuaWebhook, LuaJob types for temp files
-        const typeImports = imports.split(',')
-            .map((imp) => imp.trim())
-            .filter((imp) => /^(LuaTool|LuaWebhook|LuaJob|LuaPreProcessor|LuaPostProcessor)$/.test(imp));
-        return typeImports.length > 0
-            ? `// lua-cli/skill imports removed - using sandbox globals (types kept for compilation)`
-            : '// 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`);
-    let moduleCode = ''; // Declare outside try block for debug mode access
-    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
-        moduleCode = `
-// ${componentType} execute function for ${componentName}
-${relevantImports.join('\n')}
-
-// The execute function with all dependencies available
-const executeFunc = ${executeFunction};
-
-export default executeFunc;
-`;
-        if (debugMode) {
-            console.log(`   → Using stdin bundling to preserve import resolution`);
-        }
-        // Bundle with esbuild using stdin to preserve import resolution
-        // This ensures relative imports resolve correctly from the original source file location
-        await build({
-            stdin: {
-                contents: moduleCode,
-                resolveDir: path.dirname(sourceFilePath), // Resolve imports from source file's directory
-                sourcefile: sourceFilePath, // Pretend we're the source file for better error messages
-                loader: 'ts',
-            },
-            bundle: true,
-            platform: 'node',
-            target: 'node16',
-            format: 'cjs',
-            minify: true,
-            outfile: tempOutput,
-            external: [...EXTERNAL_PACKAGES], // Use same external packages as tools
-            plugins: [sandboxGlobalsPlugin],
-        });
-        // 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(tempOutput);
-            }
-            catch (cleanupError) {
-                // Ignore cleanup errors
-            }
-        }
-        else {
-            // In debug mode, write the moduleCode to tempFile for inspection
-            fs.writeFileSync(tempFile, moduleCode);
-            console.log(`   ℹ️  Preserved temp files for debugging:`);
-            console.log(`      - ${tempFile} (source with imports)`);
-            console.log(`      - ${tempOutput} (bundled output)`);
-        }
-        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}`;
-            // Check if it's a relative import issue
-            if (error.message.includes('"../') || error.message.includes('"./')) {
-                errorMessage += `\n  Hint: Relative imports detected. Consider using TypeScript path aliases (e.g., @/services/...)`;
-                errorMessage += `\n        Or ensure the import path is correct relative to: ${path.dirname(sourceFilePath)}`;
-            }
-            else {
-                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(tempOutput))
-                    fs.unlinkSync(tempOutput);
-            }
-            catch (cleanupError) {
-                // Ignore cleanup errors
-            }
-        }
-        else {
-            // In debug mode, write the moduleCode for inspection
-            try {
-                fs.writeFileSync(tempFile, moduleCode);
-                console.log(`   ℹ️  Temp files preserved for debugging (check dist/.temp/)`);
-            }
-            catch (writeError) {
-                // Ignore write 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
- * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
- */
-export const sandboxGlobalsPlugin = {
-    name: 'sandbox-globals',
-    setup(build) {
-        // Only process user files, not node_modules
-        build.onLoad({ filter: /\.([jt]sx?)$/, namespace: 'file' }, async (args) => {
-            // Skip node_modules
-            if (args.path.includes('node_modules')) {
-                return null;
-            }
-            const contents = await fs.promises.readFile(args.path, 'utf8');
-            // Only transform files that import from lua-cli or api-exports
-            if (!contents.includes('lua-cli') && !contents.includes('api-exports')) {
-                return null;
-            }
-            // Replace lua-cli imports with global references
-            let transformedContents = contents;
-            // Replace named imports from api-exports (e.g., ../../../dist/api-exports)
-            // Match: import { Jobs, Products, etc. } from "../../../dist/api-exports"
-            transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, (match, imports) => {
-                // Just remove the import, globals will be available in sandbox
-                return '// api-exports imports removed - using sandbox globals';
-            });
-            // Replace named imports from lua-cli
-            // Match: import { Products, User, Data, etc. } from "lua-cli"
-            transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, (match, imports) => {
-                // Just remove the import, globals will be available in sandbox
-                return '// lua-cli imports removed - using sandbox globals';
-            });
-            // Replace lua-cli/skill imports - keep env and LuaTool as they might be needed
-            transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli\/skill["'];?/g, (match, imports) => {
-                // Check if env is imported, if so we need to keep a reference
-                if (imports.includes('env')) {
-                    return '// lua-cli/skill imports removed - env available in sandbox';
-                }
-                return '// lua-cli/skill imports removed - using sandbox globals';
-            });
-            // Map import names to sandbox global names
-            // Products -> Product, Orders -> Order, etc.
-            const globalMappings = {
-                'Products': 'Products',
-                'User': 'User',
-                'Data': 'Data',
-                'Baskets': 'Baskets',
-                'Orders': 'Orders',
-                'Webhooks': 'Webhooks',
-                'Jobs': 'Jobs',
-                'Templates': 'Templates'
-            };
-            // Replace usage of imported names with globals
-            for (const [importName, globalName] of Object.entries(globalMappings)) {
-                // Replace standalone usage (e.g., Products.method() -> Product.method())
-                const regex = new RegExp(`\\b${importName}\\.`, 'g');
-                transformedContents = transformedContents.replace(regex, `${globalName}.`);
-            }
-            // Note: env function and LuaTool interface are already available in sandbox
-            // env is a function in the sandbox context (see sandbox.ts line 333)
-            return {
-                contents: transformedContents,
-                loader: args.path.endsWith('.ts') ? 'ts' :
-                    args.path.endsWith('.tsx') ? 'tsx' : 'js'
-            };
-        });
-    },
-};
-/**
- * Bundles a tool's TypeScript code into a standalone JavaScript file.
- * Uses esbuild to:
- * - Bundle all dependencies (except external packages)
- * - Minify code for production
- * - Wrap for VM execution
- *
- * For inline tools (defined in index.ts), creates a temporary export file first.
- *
- * @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, 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;
-        let tempFile = null;
-        // Note: modifiedSource is handled via stdin below, no temp file needed
-        // Check if tool is inline (in index.ts or src/index.ts)
-        const isInlineInIndex = tool.filePath.endsWith('index.ts') || tool.filePath.endsWith('index.tsx');
-        if (isInlineInIndex) {
-            // Create a temporary file that exports just this tool class
-            const tempDir = path.join(distDir, '.temp');
-            if (!fs.existsSync(tempDir)) {
-                fs.mkdirSync(tempDir, { recursive: true });
-            }
-            tempFile = path.join(tempDir, `${tool.className}.ts`);
-            // Read the source file and extract just the tool class
-            const sourceContent = fs.readFileSync(tool.filePath, 'utf8');
-            const project = new Project();
-            const sourceFile = project.addSourceFileAtPath(tool.filePath);
-            const classDecl = sourceFile.getClass(tool.className);
-            if (classDecl) {
-                // Get all imports from the original file that this class might need
-                const imports = sourceFile.getImportDeclarations();
-                let importsText = '';
-                // Include imports from lua-cli and zod (tools commonly need these)
-                imports.forEach(importDecl => {
-                    const moduleSpec = importDecl.getModuleSpecifierValue();
-                    if (moduleSpec === 'lua-cli' || moduleSpec === 'zod' || moduleSpec.startsWith('./')) {
-                        importsText += importDecl.getText() + '\n';
-                    }
-                });
-                // Create temporary file with imports and the tool class
-                const toolClassText = classDecl.getText();
-                const tempContent = `${importsText}\n${toolClassText}\n\nexport default ${tool.className};\n`;
-                fs.writeFileSync(tempFile, tempContent);
-                entryPoint = tempFile;
-            }
-        }
-        // Use stdin for modified source to preserve import resolution
-        if (modifiedSource && !isInlineInIndex) {
-            // Remove api-exports and lua-cli imports (they're available in sandbox)
-            const transformedSource = stripLuaCliImports(modifiedSource);
-            await build({
-                ...ESBUILD_TOOL_CONFIG,
-                stdin: {
-                    contents: transformedSource,
-                    resolveDir: path.dirname(tool.filePath),
-                    sourcefile: tool.filePath,
-                    loader: 'ts',
-                },
-                outfile: outputPath,
-                plugins: [sandboxGlobalsPlugin],
-            });
-        }
-        else {
-            await build({
-                ...ESBUILD_TOOL_CONFIG,
-                entryPoints: [entryPoint],
-                outfile: outputPath,
-                plugins: [sandboxGlobalsPlugin],
-            });
-        }
-        // Clean up temp file if created (unless in debug mode)
-        if (tempFile && fs.existsSync(tempFile) && !debugMode) {
-            try {
-                fs.unlinkSync(tempFile);
-            }
-            catch (cleanupError) {
-                // 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);
-        }
-    }
-}
-/**
- * Bundles the main index.ts file into a standalone JavaScript file.
- * This creates the entry point for the skill.
- *
- * @param indexPath - Path to the index.ts file
- * @param distDir - The distribution directory for output
- */
-export async function bundleMainIndex(indexPath, distDir) {
-    writeProgress("📦 Bundling main index...");
-    try {
-        await build({
-            ...ESBUILD_INDEX_CONFIG,
-            entryPoints: [indexPath],
-            outfile: path.join(distDir, COMPILE_FILES.INDEX_JS),
-        });
-    }
-    catch (error) {
-        console.warn("Warning: Failed to bundle main index:", error);
-    }
-}
-/**
- * Extracts and bundles webhook execute function and schemas.
- *
- * @param webhook - Webhook metadata with name and version
- * @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, 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) => {
-                if (Node.isNewExpression(node)) {
-                    const expression = node.getExpression();
-                    if (expression.getText() === 'LuaWebhook') {
-                        const args = node.getArguments();
-                        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                            const configObj = args[0];
-                            // First pass: check if this is the webhook we're looking for
-                            let isMatchingWebhook = false;
-                            let foundExecute = '';
-                            let foundQuerySchema = undefined;
-                            let foundHeaderSchema = undefined;
-                            let foundBodySchema = undefined;
-                            configObj.getProperties().forEach((prop) => {
-                                if (Node.isPropertyAssignment(prop)) {
-                                    const name = prop.getName();
-                                    const value = prop.getInitializer();
-                                    if (name === 'name' && value) {
-                                        const nameValue = value.getText().replace(/['"]/g, '');
-                                        if (nameValue === webhook.name) {
-                                            isMatchingWebhook = true;
-                                        }
-                                    }
-                                    if (name === 'execute' && value) {
-                                        foundExecute = value.getText();
-                                    }
-                                    else if (name === 'querySchema' && value) {
-                                        foundQuerySchema = value.getText();
-                                    }
-                                    else if (name === 'headerSchema' && value) {
-                                        foundHeaderSchema = value.getText();
-                                    }
-                                    else if (name === 'bodySchema' && value) {
-                                        foundBodySchema = value.getText();
-                                    }
-                                }
-                            });
-                            // Only set values if this is the matching webhook
-                            if (isMatchingWebhook) {
-                                executeFunction = foundExecute;
-                                querySchema = foundQuerySchema;
-                                headerSchema = foundHeaderSchema;
-                                bodySchema = foundBodySchema;
-                                // Update source file path to the file where webhook was found
-                                sourceFilePath = file.getFilePath();
-                            }
-                        }
-                    }
-                }
-            });
-        };
-        // Search in index file first
-        searchFileForWebhook(indexFile);
-        // If not found and project is available, search in imported files
-        if (!executeFunction && project) {
-            const imports = indexFile.getImportDeclarations();
-            for (const importDecl of imports) {
-                try {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const { resolveImportPath } = await import('./compile.js');
-                    const importPath = resolveImportPath(moduleSpecifier, indexFile.getFilePath());
-                    if (fs.existsSync(importPath)) {
-                        const importedFile = project.addSourceFileAtPath(importPath);
-                        searchFileForWebhook(importedFile);
-                        // If found, stop searching
-                        if (executeFunction) {
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    // Continue searching other imports
-                }
-            }
-        }
-        // Convert Zod schemas to JSON Schema
-        const convertedSchemas = {};
-        if (querySchema) {
-            convertedSchemas.querySchema = await evaluateZodSchemaToJsonSchema(querySchema);
-        }
-        if (headerSchema) {
-            convertedSchemas.headerSchema = await evaluateZodSchemaToJsonSchema(headerSchema);
-        }
-        if (bodySchema) {
-            convertedSchemas.bodySchema = await evaluateZodSchemaToJsonSchema(bodySchema);
-        }
-        // Bundle and compress the execute function (like tools)
-        let compressedCode = '';
-        if (executeFunction) {
-            compressedCode = await bundleAndCompressWebhookCode(executeFunction, webhook.name, distDir, sourceFilePath, debugMode);
-        }
-        return {
-            ...webhook,
-            executeFunction,
-            code: compressedCode, // Add compressed bundled code
-            ...convertedSchemas
-        };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle webhook ${webhook.name}:`, error);
-        return webhook;
-    }
-}
-/**
- * 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, sourceFilePath, debugMode) {
-    return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (event) => {
-  
-  // Execute the bundled webhook code
-  ${bundledCode}
-  
-  // Get the execute function from exports
-  const executeFunction = module.exports.default || module.exports;
-  
-  // Execute with the unified event object
-  return await executeFunction(event);
-})`, distDir, sourceFilePath, debugMode);
-}
-/**
- * Extracts and bundles job execute function.
- *
- * @param job - Job metadata with name and version
- * @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, 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) => {
-                if (Node.isNewExpression(node)) {
-                    const expression = node.getExpression();
-                    if (expression.getText() === 'LuaJob') {
-                        const args = node.getArguments();
-                        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                            const configObj = args[0];
-                            // First pass: check if this is the job we're looking for
-                            let isMatchingJob = false;
-                            let foundExecute = '';
-                            configObj.getProperties().forEach((prop) => {
-                                if (Node.isPropertyAssignment(prop)) {
-                                    const name = prop.getName();
-                                    const value = prop.getInitializer();
-                                    if (name === 'name' && value) {
-                                        const nameValue = value.getText().replace(/['"]/g, '');
-                                        if (nameValue === job.name) {
-                                            isMatchingJob = true;
-                                        }
-                                    }
-                                    if (name === 'execute' && value) {
-                                        foundExecute = value.getText();
-                                    }
-                                }
-                            });
-                            // 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();
-                            }
-                        }
-                    }
-                }
-            });
-        };
-        // Search in index file first
-        searchFileForJob(indexFile);
-        // If not found and project is available, search in imported files
-        if (!executeFunction && project) {
-            const imports = indexFile.getImportDeclarations();
-            for (const importDecl of imports) {
-                try {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const { resolveImportPath } = await import('./compile.js');
-                    const importPath = resolveImportPath(moduleSpecifier, indexFile.getFilePath());
-                    if (fs.existsSync(importPath)) {
-                        const importedFile = project.addSourceFileAtPath(importPath);
-                        searchFileForJob(importedFile);
-                        // If found, stop searching
-                        if (executeFunction) {
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    // Continue searching other imports
-                }
-            }
-        }
-        // Bundle and compress the execute function (like tools)
-        let compressedCode = '';
-        if (executeFunction) {
-            compressedCode = await bundleAndCompressJobCode(executeFunction, job.name, distDir, sourceFilePath, debugMode);
-        }
-        return {
-            ...job,
-            executeFunction,
-            code: compressedCode // Add compressed bundled code
-        };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle job ${job.name}:`, error);
-        return job;
-    }
-}
-/**
- * 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, sourceFilePath, debugMode) {
-    return bundleAndCompressExecuteFunction(executeFunction, jobName, 'job', (bundledCode) => `(async (job) => {
-  // Execute the bundled job code
-  ${bundledCode}
-  
-  // Get the execute function from exports
-  const executeFunction = module.exports.default || module.exports;
-  
-  // Execute job with job instance parameter
-  return await executeFunction(job);
-})`, distDir, sourceFilePath, debugMode);
-}
-/**
- * Bundles and compresses preprocessor execute function code.
- */
-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)) {
-                    const expression = node.getExpression();
-                    if (expression.getText() === 'PreProcessor') {
-                        const args = node.getArguments();
-                        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                            const configObj = args[0];
-                            let isMatching = false;
-                            let foundExecute = '';
-                            configObj.getProperties().forEach((prop) => {
-                                if (Node.isPropertyAssignment(prop)) {
-                                    const name = prop.getName();
-                                    const value = prop.getInitializer();
-                                    if (name === 'name' && value) {
-                                        const nameValue = value.getText().replace(/['"]/g, '');
-                                        if (nameValue === preprocessor.name) {
-                                            isMatching = true;
-                                        }
-                                    }
-                                    if (name === 'execute' && value) {
-                                        foundExecute = value.getText();
-                                    }
-                                }
-                            });
-                            if (isMatching && foundExecute) {
-                                executeFunction = foundExecute;
-                                // Update source file path to the file where preprocessor was found
-                                sourceFilePath = file.getFilePath();
-                            }
-                        }
-                    }
-                }
-            });
-        };
-        // Search in index file first
-        searchFileForPreProcessor(indexFile);
-        // If not found and project is available, search in imported files
-        if (!executeFunction && project) {
-            const imports = indexFile.getImportDeclarations();
-            for (const importDecl of imports) {
-                try {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const { resolveImportPath } = await import('./compile.js');
-                    const importPath = resolveImportPath(moduleSpecifier, indexFile.getFilePath());
-                    if (fs.existsSync(importPath)) {
-                        const importedFile = project.addSourceFileAtPath(importPath);
-                        searchFileForPreProcessor(importedFile);
-                        if (executeFunction) {
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    // Continue searching
-                }
-            }
-        }
-        let compressedCode = '';
-        if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir, sourceFilePath, debugMode);
-        }
-        return {
-            name: preprocessor.name,
-            version: preprocessor.version,
-            description: preprocessor.description,
-            async: preprocessor.async === true ? true : false, // Explicitly set boolean
-            executeFunction,
-            code: compressedCode
-        };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle preprocessor ${preprocessor.name}:`, error);
-        return preprocessor;
-    }
-}
-/**
- * Bundles and compresses postprocessor execute function code.
- */
-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)) {
-                    const expression = node.getExpression();
-                    if (expression.getText() === 'PostProcessor') {
-                        const args = node.getArguments();
-                        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                            const configObj = args[0];
-                            let isMatching = false;
-                            let foundExecute = '';
-                            configObj.getProperties().forEach((prop) => {
-                                if (Node.isPropertyAssignment(prop)) {
-                                    const name = prop.getName();
-                                    const value = prop.getInitializer();
-                                    if (name === 'name' && value) {
-                                        const nameValue = value.getText().replace(/['"]/g, '');
-                                        if (nameValue === postprocessor.name) {
-                                            isMatching = true;
-                                        }
-                                    }
-                                    if (name === 'execute' && value) {
-                                        foundExecute = value.getText();
-                                    }
-                                }
-                            });
-                            if (isMatching && foundExecute) {
-                                executeFunction = foundExecute;
-                                // Update source file path to the file where postprocessor was found
-                                sourceFilePath = file.getFilePath();
-                            }
-                        }
-                    }
-                }
-            });
-        };
-        // Search in index file first
-        searchFileForPostProcessor(indexFile);
-        // If not found and project is available, search in imported files
-        if (!executeFunction && project) {
-            const imports = indexFile.getImportDeclarations();
-            for (const importDecl of imports) {
-                try {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const { resolveImportPath } = await import('./compile.js');
-                    const importPath = resolveImportPath(moduleSpecifier, indexFile.getFilePath());
-                    if (fs.existsSync(importPath)) {
-                        const importedFile = project.addSourceFileAtPath(importPath);
-                        searchFileForPostProcessor(importedFile);
-                        if (executeFunction) {
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    // Continue searching
-                }
-            }
-        }
-        let compressedCode = '';
-        if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir, sourceFilePath, debugMode);
-        }
-        return {
-            name: postprocessor.name,
-            version: postprocessor.version,
-            description: postprocessor.description,
-            executeFunction,
-            code: compressedCode
-        };
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle postprocessor ${postprocessor.name}:`, error);
-        return postprocessor;
-    }
-}
-/**
- * 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, 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});
-})`, distDir, sourceFilePath, debugMode);
-}
-/**
- * Extracts tool code from a bundled tool.
- * Reads the bundled code, wraps it for VM execution (execute and condition),
- * and converts the Zod schema to JSON Schema format.
- */
-export async function extractToolCode(tool, project) {
-    try {
-        const toolSourceFile = project.getSourceFile(tool.filePath);
-        if (!toolSourceFile) {
-            console.warn(`Warning: Could not find source file for ${tool.className}`);
-            return;
-        }
-        const classDecl = toolSourceFile.getClass(tool.className);
-        if (!classDecl) {
-            console.warn(`Warning: Could not find class ${tool.className} in ${tool.filePath}`);
-            return;
-        }
-        // Verify execute method or property exists
-        const executeMethod = classDecl.getMethod('execute');
-        const executeProperty = classDecl.getProperty('execute');
-        if (!executeMethod && !executeProperty) {
-            console.warn(`Warning: Could not find execute method or property in ${tool.className}`);
-            return;
-        }
-        // Validate execute has a body (for methods) or initializer (for arrow function properties)
-        if (executeMethod) {
-            const executeBody = executeMethod.getBodyText();
-            if (!executeBody) {
-                console.warn(`Warning: Execute method has no body in ${tool.className}`);
-                return;
-            }
-        }
-        else if (executeProperty) {
-            const initializer = executeProperty.getInitializer();
-            if (!initializer) {
-                console.warn(`Warning: Execute property has no initializer in ${tool.className}`);
-                return;
-            }
-        }
-        // Read bundled code and wrap for VM execution
-        const rawBundledCode = readBundledToolCode(tool);
-        if (rawBundledCode) {
-            tool.executeCode = wrapExecuteForVM(rawBundledCode, tool.className);
-            // Check if tool has condition and wrap it
-            const hasCondition = classDecl.getMethod('condition') || classDecl.getProperty('condition');
-            if (hasCondition) {
-                tool.conditionCode = wrapConditionForVM(rawBundledCode, tool.className);
-            }
-        }
-        // Extract input schema using ts-evaluator (resolves all imports/expressions automatically)
-        tool.inputSchema = await extractInputSchema(classDecl, tool);
-    }
-    catch (error) {
-        console.warn(`Warning: Could not extract tool metadata for ${tool.className}:`, error);
-    }
-}
-/**
- * Reads the raw bundled tool code from the dist directory.
- */
-function readBundledToolCode(tool) {
-    const bundledPath = path.join(process.cwd(), COMPILE_DIRS.DIST, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
-    if (fs.existsSync(bundledPath)) {
-        return fs.readFileSync(bundledPath, 'utf8');
-    }
-    return undefined;
-}
-/**
- * Extracts and converts the input schema from a tool class using ts-evaluator.
- * This evaluates the actual TypeScript AST node, resolving all imports and expressions.
- *
- * @param classDecl - The tool class declaration from ts-morph
- * @param tool - The tool being analyzed
- * @returns The JSON Schema object or default schema
- */
-async function extractInputSchema(classDecl, tool) {
-    const inputSchemaProperty = classDecl.getProperty('inputSchema');
-    if (!inputSchemaProperty?.getInitializer()) {
-        return DEFAULT_INPUT_SCHEMA;
-    }
-    try {
-        const initializer = inputSchemaProperty.getInitializer();
-        const sourceFile = initializer.getSourceFile();
-        const project = sourceFile.getProject();
-        // Get the underlying TypeScript compiler objects for ts-evaluator
-        const tsNode = initializer.compilerNode;
-        const typeChecker = project.getTypeChecker().compilerObject;
-        const compilerOptions = project.getCompilerOptions();
-        // Get zod from node_modules to provide as extra global
-        const { z } = await import('zod');
-        // Evaluate the AST node using ts-evaluator
-        // This resolves all imports, variables, and expressions automatically
-        const result = evaluate({
-            node: tsNode,
-            typeChecker,
-            typescript: ts,
-            environment: {
-                preset: 'NODE',
-                extra: { z } // Provide zod as a global to avoid import resolution issues
-            },
-            policy: {
-                deterministic: false,
-                network: false,
-                console: false,
-                io: { read: true, write: false },
-                process: { exit: false, spawnChild: false }
-            }
-        });
-        if (!result.success) {
-            throw new Error(result.reason?.message || 'Failed to evaluate schema');
-        }
-        const zodSchema = result.value;
-        if (!zodSchema || typeof zodSchema !== 'object') {
-            return DEFAULT_INPUT_SCHEMA;
-        }
-        // Convert Zod schema to JSON Schema
-        const { zodToJsonSchema } = await import('zod-to-json-schema');
-        const jsonSchema = zodToJsonSchema(zodSchema, { target: 'jsonSchema7' });
-        // Clean up the JSON schema (remove $schema, title, etc.)
-        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
-        return cleanSchema;
-    }
-    catch (error) {
-        console.warn(`Warning: Could not evaluate schema for ${tool.className}:`, error?.message || error);
-        return DEFAULT_INPUT_SCHEMA;
-    }
-}
-/**
- * Bundles and compresses an MCP resolver function using esbuild.
- *
- * MCP resolver functions are simple arrow functions like:
- *   () => ({ KEY: env("KEY") })
- *
- * They don't have imports (env is runtime-provided), but may have TypeScript
- * type annotations that need transpilation. Uses esbuild for TypeScript support.
- *
- * @param functionCode - Raw function code (e.g., "() => ({ KEY: env('KEY') })")
- * @param resolverType - Type of resolver ('env', 'headers', 'url') for temp file naming
- * @param serverName - MCP server name for temp file naming
- * @param distDir - Distribution directory for temp files
- * @param debugMode - Enable verbose logging and preserve temp files
- * @returns Compressed base64-encoded bundled code, or null if bundling fails
- */
-export async function bundleMCPResolverFunction(functionCode, resolverType, serverName, distDir, debugMode) {
-    const { compressCode } = await import('./compile.js');
-    // Create temporary file with the function wrapped as a module
-    const tempDir = path.join(distDir, '.temp');
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-    }
-    const safeName = serverName.replace(/[^a-zA-Z0-9]/g, '_');
-    const tempFile = path.join(tempDir, `mcp-${safeName}-${resolverType}.ts`);
-    const tempOutput = path.join(tempDir, `mcp-${safeName}-${resolverType}.js`);
-    try {
-        // Write function as a module export
-        // The function references `env` which will be provided by the runtime sandbox
-        const moduleCode = `
-// MCP ${resolverType} resolver for ${serverName}
-// Note: env() is provided by the runtime sandbox, not imported
-const resolverFunc = ${functionCode};
-export default resolverFunc;
-`;
-        fs.writeFileSync(tempFile, moduleCode);
-        if (debugMode) {
-            console.log(`   → Bundling MCP ${resolverType} resolver for ${serverName}...`);
-        }
-        // Bundle with esbuild - minimal config since there are no imports to resolve
-        await build({
-            entryPoints: [tempFile],
-            bundle: true,
-            platform: 'node',
-            target: 'node16',
-            format: 'cjs',
-            minify: true,
-            outfile: tempOutput,
-            external: [...EXTERNAL_PACKAGES],
-            plugins: [sandboxGlobalsPlugin],
-        });
-        // Read bundled code
-        if (!fs.existsSync(tempOutput)) {
-            throw new Error(`esbuild failed to create output file for MCP ${resolverType} resolver`);
-        }
-        const bundledCode = fs.readFileSync(tempOutput, 'utf8');
-        if (bundledCode.length === 0) {
-            throw new Error(`esbuild created empty bundle for MCP ${resolverType} resolver`);
-        }
-        // Wrap for VM execution - the resolver function returns a value directly
-        const wrappedCode = `(async () => {
-  ${bundledCode}
-  
-  const resolverFunc = module.exports.default || module.exports;
-  return resolverFunc();
-})()`;
-        // Compress the wrapped code
-        const compressed = compressCode(wrappedCode);
-        if (debugMode) {
-            console.log(`   → MCP ${resolverType} resolver bundled: ${(compressed.length / 1024).toFixed(2)}KB`);
-        }
-        // Clean up temp files (unless in debug mode)
-        if (!debugMode) {
-            try {
-                fs.unlinkSync(tempFile);
-                fs.unlinkSync(tempOutput);
-            }
-            catch (cleanupError) {
-                // Ignore cleanup errors
-            }
-        }
-        return compressed;
-    }
-    catch (error) {
-        console.warn(`Warning: Could not bundle MCP ${resolverType} resolver for ${serverName}: ${error.message}`);
-        // Fallback: compress the raw function with simple wrapper (may fail at runtime if TS syntax)
-        try {
-            const fallbackCode = `(${functionCode})()`;
-            return compressCode(fallbackCode);
-        }
-        catch (fallbackError) {
-            console.warn(`Warning: Fallback compression also failed for MCP ${resolverType} resolver`);
-            return null;
-        }
-    }
-}
-//# sourceMappingURL=bundling.js.map