lua-cli 2.5.8 → 3.0.0-alpha.1

package/dist/utils/bundling.js

@@ -5,13 +5,14 @@
 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, } from '../config/compile.constants.js';
 import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema, } from './compile.js';
 /**
  * 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 (Product, User, Data, Baskets, Order)
+ * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
  */
 const sandboxGlobalsPlugin = {
     name: 'sandbox-globals',
@@ -50,7 +51,9 @@ const sandboxGlobalsPlugin = {
                 'User': 'User',
                 'Data': 'Data',
                 'Baskets': 'Baskets',
-                'Orders': 'Orders'
+                'Orders': 'Orders',
+                'Webhooks': 'Webhooks',
+                'Jobs': 'Jobs'
             };
             // Replace usage of imported names with globals
             for (const [importName, globalName] of Object.entries(globalMappings)) {
@@ -75,6 +78,8 @@ const sandboxGlobalsPlugin = {
  * - 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
  */
@@ -82,14 +87,57 @@ export async function bundleTool(tool, distDir) {
     writeProgress(`📦 Bundling ${tool.className}...`);
     try {
         const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
+        let entryPoint = tool.filePath;
+        let tempFile = null;
+        // 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;
+            }
+        }
         await build({
             ...ESBUILD_TOOL_CONFIG,
-            entryPoints: [tool.filePath],
+            entryPoints: [entryPoint],
             outfile: outputPath,
             plugins: [sandboxGlobalsPlugin],
         });
         // Wrap the bundled code for VM execution environment
         await wrapToolForVM(outputPath, tool);
+        // Clean up temp file if created
+        if (tempFile && fs.existsSync(tempFile)) {
+            try {
+                fs.unlinkSync(tempFile);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
     }
     catch (error) {
         console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
@@ -115,6 +163,590 @@ export async function bundleMainIndex(indexPath, distDir) {
         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
+ * @returns Webhook with bundled code and schemas
+ */
+export async function bundleWebhook(webhook, indexFile, distDir, project) {
+    writeProgress(`📦 Bundling webhook ${webhook.name}...`);
+    try {
+        // Find the LuaWebhook constructor in the AST
+        let executeFunction = '';
+        let querySchema = undefined;
+        let headerSchema = undefined;
+        let bodySchema = undefined;
+        // 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;
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        // 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);
+        }
+        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.
+ *
+ * @param executeFunction - Raw execute function code
+ * @param webhookName - Name of the webhook
+ * @param distDir - Distribution directory
+ * @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 = `
+// 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 (input) => {
+  const { query, headers, body } = input;
+  
+  // Execute the bundled webhook code
+  ${bundledCode}
+  
+  // Get the execute function from exports
+  const executeFunction = module.exports.default || module.exports;
+  
+  // Execute with proper input structure
+  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 '';
+    }
+}
+/**
+ * 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
+ * @returns Job with bundled code
+ */
+export async function bundleJob(job, indexFile, distDir, project) {
+    writeProgress(`📦 Bundling job ${job.name}...`);
+    try {
+        // Find the LuaJob constructor in the AST
+        let executeFunction = '';
+        // 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;
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        // 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);
+        }
+        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.
+ *
+ * @param executeFunction - Raw execute function code
+ * @param jobName - Name of the job
+ * @param distDir - Distribution directory
+ * @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 = `
+// 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) => {
+  // 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);
+})`;
+        // 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 '';
+    }
+}
+/**
+ * Bundles and compresses preprocessor execute function code.
+ */
+export async function bundlePreProcessor(preprocessor, indexFile, distDir, project) {
+    writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
+    try {
+        let executeFunction = '';
+        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;
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        // 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);
+        }
+        return {
+            ...preprocessor,
+            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) {
+    writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
+    try {
+        let executeFunction = '';
+        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;
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        // 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);
+        }
+        return {
+            ...postprocessor,
+            executeFunction,
+            code: compressedCode
+        };
+    }
+    catch (error) {
+        console.warn(`Warning: Could not bundle postprocessor ${postprocessor.name}:`, error);
+        return postprocessor;
+    }
+}
+/**
+ * Bundles and compresses processor execute function code.
+ */
+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 = `
+// ${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}) => {
+  // 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 '';
+    }
+}
 /**
  * Extracts execute code and input schema from a tool.
  * This function:
@@ -137,16 +769,27 @@ export async function extractExecuteCode(tool, project) {
             console.warn(`Warning: Could not find class ${tool.className} in ${tool.filePath}`);
             return;
         }
-        // Verify execute method exists
+        // Verify execute method or property exists
         const executeMethod = classDecl.getMethod('execute');
-        if (!executeMethod) {
-            console.warn(`Warning: Could not find execute method in ${tool.className}`);
+        const executeProperty = classDecl.getProperty('execute');
+        if (!executeMethod && !executeProperty) {
+            console.warn(`Warning: Could not find execute method or property in ${tool.className}`);
             return;
         }
-        const executeBody = executeMethod.getBodyText();
-        if (!executeBody) {
-            console.warn(`Warning: Execute method has no body 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;
+            }
         }
         // Extract execute code from bundled file
         tool.executeCode = extractExecuteCodeFromBundledFile(tool);