lua-cli 1.2.1 → 1.3.0

package/dist/commands/deploy.js

@@ -1,779 +1,97 @@
-import fs from "fs";
-import path from "path";
-import { gzipSync, gunzipSync } from "zlib";
-import { Buffer } from "buffer";
-// Compression utilities
-function compressCode(code) {
-    const compressed = gzipSync(code);
-    return compressed.toString('base64');
-}
-function decompressCode(compressedCode) {
-    const buffer = Buffer.from(compressedCode, 'base64');
-    return gunzipSync(buffer).toString('utf8');
-}
-export async function deployCommand() {
+import inquirer from 'inquirer';
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { ApiService } from '../services/api.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from '../utils/cli.js';
+export async function fetchVersions(apiKey, agentId, skillId) {
     try {
-        console.log("🔨 Compiling Lua skill...");
-        // Read package.json to get version and name
-        const packageJsonPath = path.join(process.cwd(), "package.json");
-        if (!fs.existsSync(packageJsonPath)) {
-            throw new Error("package.json not found in current directory");
-        }
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        const version = packageJson.version || "1.0.0";
-        const skillsName = packageJson.name || "lua-skill";
-        // Read index.ts file
-        const indexPath = path.join(process.cwd(), "index.ts");
-        if (!fs.existsSync(indexPath)) {
-            throw new Error("index.ts not found in current directory");
-        }
-        const indexContent = fs.readFileSync(indexPath, "utf8");
-        // Extract skill information
-        const skillInfo = await extractSkillInfo(indexContent);
-        // Create deployment data with compressed execute code
-        const deployData = {
-            version,
-            skillsName,
-            tools: skillInfo.map(tool => ({
-                ...tool,
-                execute: compressCode(tool.execute)
-            }))
-        };
-        // Create .lua directory
-        const luaDir = path.join(process.cwd(), ".lua");
-        if (!fs.existsSync(luaDir)) {
-            fs.mkdirSync(luaDir, { recursive: true });
+        const response = await ApiService.Skill.getSkillVersions(apiKey, agentId, skillId);
+        if (!response.success) {
+            throw new Error(`Failed to fetch versions: ${response.error?.message || 'Unknown error'}`);
         }
-        // Write JSON output to .lua directory
-        const jsonOutputPath = path.join(luaDir, "deploy.json");
-        fs.writeFileSync(jsonOutputPath, JSON.stringify(deployData, null, 2));
-        // Write individual tool files to .lua directory
-        for (const tool of skillInfo) {
-            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
-            fs.writeFileSync(toolFilePath, tool.execute);
-        }
-        console.log(`📁 Compiled files written to: ${luaDir}`);
-        console.log(`📄 JSON output: ${jsonOutputPath}`);
-        console.log(`🔧 Tool files: ${skillInfo.map(t => `${t.name}.js`).join(', ')}`);
-        console.log("✅ Skill compilation completed successfully!");
+        return response.data;
     }
     catch (error) {
-        console.error("❌ Compilation failed:", error.message);
-        process.exit(1);
-    }
-}
-async function extractSkillInfo(indexContent) {
-    const tools = [];
-    // Find inline addTool calls: skill.addTool({...})
-    const inlineAddToolRegex = /skill\.addTool\(\s*\{([\s\S]*?)\}\s*\)/g;
-    let match;
-    while ((match = inlineAddToolRegex.exec(indexContent)) !== null) {
-        const toolContent = match[1];
-        // Extract tool properties
-        const nameMatch = toolContent.match(/name:\s*["']([^"']+)["']/);
-        const descriptionMatch = toolContent.match(/description:\s*["']([^"']+)["']/);
-        const inputSchemaMatch = toolContent.match(/inputSchema:\s*(\w+)/);
-        const outputSchemaMatch = toolContent.match(/outputSchema:\s*(\w+)/);
-        const executeMatch = toolContent.match(/execute:\s*async\s*\([^)]*\)\s*=>\s*\{([\s\S]*?)\}/);
-        if (nameMatch && descriptionMatch && inputSchemaMatch && outputSchemaMatch && executeMatch) {
-            const toolName = nameMatch[1];
-            const toolDescription = descriptionMatch[1];
-            const inputSchemaVar = inputSchemaMatch[1];
-            const outputSchemaVar = outputSchemaMatch[1];
-            const executeBody = executeMatch[1];
-            // Convert schemas to JSON Schema format
-            const inputSchema = convertSchemaToJSON(inputSchemaVar, indexContent);
-            const outputSchema = convertSchemaToJSON(outputSchemaVar, indexContent);
-            // Create self-contained execute function
-            const selfContainedExecute = await createSelfContainedExecute(executeBody, indexContent);
-            tools.push({
-                name: toolName,
-                description: toolDescription,
-                inputSchema,
-                outputSchema,
-                execute: selfContainedExecute
-            });
-        }
-    }
-    // Find class-based addTool calls: skill.addTool(new SomeTool())
-    const classAddToolRegex = /skill\.addTool\(\s*new\s+(\w+)\(\)\s*\)/g;
-    let classMatch;
-    while ((classMatch = classAddToolRegex.exec(indexContent)) !== null) {
-        const className = classMatch[1];
-        // Find the tool class definition
-        const toolInfo = await extractToolFromClass(className, indexContent);
-        if (toolInfo) {
-            tools.push(toolInfo);
-        }
-    }
-    return tools;
-}
-function convertSchemaToJSON(schemaVar, indexContent) {
-    // Find the schema definition
-    const schemaRegex = new RegExp(`const\\s+${schemaVar}\\s*=\\s*z\\.object\\(\\{([\\s\\S]*?)\\}\\\);`, 'g');
-    const match = schemaRegex.exec(indexContent);
-    if (match) {
-        const schemaContent = match[1];
-        // Convert Zod schema to JSON Schema format
-        return {
-            type: "object",
-            properties: parseZodProperties(schemaContent),
-            required: extractRequiredFields(schemaContent)
-        };
-    }
-    // If no match found, return empty schema
-    return { type: "object", properties: {} };
-}
-function parseZodProperties(schemaContent) {
-    const properties = {};
-    // Simple regex to find z.string(), z.number(), etc.
-    const fieldRegex = /(\w+):\s*z\.(\w+)\(\)/g;
-    let match;
-    while ((match = fieldRegex.exec(schemaContent)) !== null) {
-        const fieldName = match[1];
-        const fieldType = match[2];
-        switch (fieldType) {
-            case 'string':
-                properties[fieldName] = { type: 'string' };
-                break;
-            case 'number':
-                properties[fieldName] = { type: 'number' };
-                break;
-            case 'boolean':
-                properties[fieldName] = { type: 'boolean' };
-                break;
-            default:
-                properties[fieldName] = { type: 'string' };
-        }
-    }
-    return properties;
-}
-function extractRequiredFields(schemaContent) {
-    const required = [];
-    const fieldRegex = /(\w+):\s*z\.(\w+)\(\)/g;
-    let match;
-    while ((match = fieldRegex.exec(schemaContent)) !== null) {
-        required.push(match[1]);
+        console.error("❌ Error fetching versions:", error);
+        throw error;
     }
-    return required;
 }
-async function createSelfContainedExecute(executeBody, indexContent) {
-    const dependencies = [];
-    const bundledPackages = new Set();
-    // 1. Parse external package imports and bundle their code
-    const allImportRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let importMatch;
-    while ((importMatch = allImportRegex.exec(indexContent)) !== null) {
-        const namedImports = importMatch[1]; // Named imports like { z }
-        const defaultImport = importMatch[2]; // Default import like axios
-        const packagePath = importMatch[3];
-        // Skip local imports (relative paths)
-        if (packagePath.startsWith('./') || packagePath.startsWith('../')) {
-            continue;
-        }
-        // Skip lua-cli imports (these are handled separately)
-        if (packagePath.startsWith('lua-cli')) {
-            continue;
-        }
-        // Skip zod - assume it's always available on target machine
-        if (packagePath === 'zod') {
-            // Add require statement for zod instead of bundling
-            if (namedImports) {
-                const importsList = namedImports.split(',').map(imp => imp.trim());
-                const usedImports = importsList.filter(imp => executeBody.includes(imp) || indexContent.includes(`${imp}.`));
-                if (usedImports.length > 0) {
-                    const requireStatement = usedImports.length === 1
-                        ? `const { ${usedImports[0]} } = require('zod');`
-                        : `const { ${usedImports.join(', ')} } = require('zod');`;
-                    bundledPackages.add(requireStatement);
-                }
-            }
-            else if (defaultImport) {
-                bundledPackages.add(`const ${defaultImport} = require('zod');`);
-            }
-            continue;
-        }
-        // Bundle other external packages
-        if (namedImports || defaultImport) {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
-            }
-        }
-    }
-    // 2. Extract class definitions with proper brace matching
-    const classRegex = /class\s+(\w+)(?:\s+extends\s+\w+)?\s*\{/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(indexContent)) !== null) {
-        const className = classMatch[1];
-        const classStart = classMatch.index;
-        // Find the matching closing brace
-        let braceCount = 0;
-        let classEnd = classStart;
-        let found = false;
-        for (let i = classStart; i < indexContent.length; i++) {
-            if (indexContent[i] === '{') {
-                braceCount++;
-            }
-            else if (indexContent[i] === '}') {
-                braceCount--;
-                if (braceCount === 0) {
-                    classEnd = i;
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if (found) {
-            const fullClass = indexContent.substring(classStart, classEnd + 1);
-            // Check if this class is used in the execute function
-            let isUsed = false;
-            // Direct usage in execute body
-            if (executeBody.includes(`new ${className}`) ||
-                executeBody.includes(`${className}.`) ||
-                executeBody.includes(`${className}(`)) {
-                isUsed = true;
-            }
-            // Check if any variable that uses this class is referenced in execute body
-            const variableRegex = new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*new\\s+${className}\\s*\\([^)]*\\);`, 'g');
-            let varMatch;
-            while ((varMatch = variableRegex.exec(indexContent)) !== null) {
-                const varName = varMatch[1];
-                if (executeBody.includes(varName)) {
-                    isUsed = true;
-                    break;
-                }
-            }
-            if (isUsed) {
-                dependencies.push(fullClass);
-            }
-        }
-    }
-    // 3. Extract function definitions
-    const functionRegex = /(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*\{([\s\S]*?)\n\}/g;
-    let functionMatch;
-    while ((functionMatch = functionRegex.exec(indexContent)) !== null) {
-        const functionName = functionMatch[1];
-        const functionBody = functionMatch[2];
-        if (executeBody.includes(functionName)) {
-            dependencies.push(`function ${functionName}() {\n${functionBody}\n}`);
-        }
-    }
-    // 4. Extract const/let/var declarations (avoid duplicates)
-    const varRegex = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);/g;
-    const declaredVars = new Set();
-    let varMatch;
-    while ((varMatch = varRegex.exec(indexContent)) !== null) {
-        const varName = varMatch[1];
-        const varValue = varMatch[2];
-        // Skip if it's a class instantiation (we'll handle that separately)
-        if (varValue.includes('new ') && varValue.includes('()')) {
-            continue;
-        }
-        // Skip if already declared
-        if (declaredVars.has(varName)) {
-            continue;
-        }
-        if (executeBody.includes(varName)) {
-            declaredVars.add(varName);
-            dependencies.push(`const ${varName} = ${varValue};`);
-        }
-    }
-    // 5. Extract class instantiations (avoid duplicates)
-    const instantiationRegex = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+(\w+)\([^)]*\);/g;
-    let instantiationMatch;
-    while ((instantiationMatch = instantiationRegex.exec(indexContent)) !== null) {
-        const instanceName = instantiationMatch[1];
-        const className = instantiationMatch[2];
-        // Skip if already declared
-        if (declaredVars.has(instanceName)) {
-            continue;
-        }
-        if (executeBody.includes(instanceName)) {
-            declaredVars.add(instanceName);
-            dependencies.push(`const ${instanceName} = new ${className}();`);
-        }
-    }
-    // 6. Create the self-contained execute function
-    const allDependencies = [...Array.from(bundledPackages), ...dependencies];
-    const dependencyCode = allDependencies.join('\n');
-    // Strip TypeScript type annotations for JavaScript compatibility (only for local code)
-    const cleanDependencyCode = allDependencies.map(dep => {
-        // Only strip TypeScript from local dependencies, not bundled packages
-        if (dep.includes('require(') || dep.includes('import ')) {
-            return dep; // Skip bundled packages
-        }
-        return dep
-            .replace(/:\s*string/g, '') // Remove : string
-            .replace(/:\s*number/g, '') // Remove : number
-            .replace(/:\s*boolean/g, '') // Remove : boolean
-            .replace(/:\s*any/g, '') // Remove : any
-            .replace(/:\s*void/g, '') // Remove : void
-            .replace(/:\s*object/g, '') // Remove : object
-            .replace(/:\s*Array<[^>]+>/g, '') // Remove : Array<Type>
-            .replace(/:\s*Promise<[^>]+>/g, '') // Remove : Promise<Type>
-            .replace(/:\s*Record<[^>]+>/g, ''); // Remove : Record<Type>
-    }).join('\n');
-    const cleanExecuteBody = executeBody
-        .replace(/:\s*string/g, '') // Remove : string
-        .replace(/:\s*number/g, '') // Remove : number
-        .replace(/:\s*boolean/g, '') // Remove : boolean
-        .replace(/:\s*any/g, '') // Remove : any
-        .replace(/:\s*void/g, '') // Remove : void
-        .replace(/:\s*object/g, '') // Remove : object
-        .replace(/:\s*Array<[^>]+>/g, '') // Remove : Array<Type>
-        .replace(/:\s*Promise<[^>]+>/g, '') // Remove : Promise<Type>
-        .replace(/:\s*Record<[^>]+>/g, ''); // Remove : Record<Type>
-    const selfContainedExecute = `async (input) => {
-${cleanDependencyCode ? `  ${cleanDependencyCode.split('\n').join('\n  ')}\n` : ''}  ${cleanExecuteBody.trim()}
-}`;
-    return selfContainedExecute;
-}
-async function bundlePackageCode(packagePath, namedImports, defaultImport) {
+export async function publishVersion(apiKey, agentId, skillId, version) {
     try {
-        const { build } = await import('esbuild');
-        // Create a temporary entry file for esbuild in .lua directory
-        const luaDir = path.join(process.cwd(), '.lua');
-        if (!fs.existsSync(luaDir)) {
-            fs.mkdirSync(luaDir, { recursive: true });
-        }
-        const entryFile = path.join(luaDir, `${packagePath}-entry.cjs`);
-        const outputFile = path.join(luaDir, `${packagePath}-bundle.cjs`);
-        // Create entry file based on import type
-        let entryContent = '';
-        if (defaultImport) {
-            // For default imports like `import axios from 'axios'`
-            entryContent = `import ${defaultImport} from '${packagePath}';\nmodule.exports = ${defaultImport};`;
-        }
-        else if (namedImports) {
-            // For named imports like `import { z } from 'zod'`
-            const importsList = namedImports.split(',').map(imp => imp.trim());
-            entryContent = `import { ${importsList.join(', ')} } from '${packagePath}';\nmodule.exports = { ${importsList.join(', ')} };`;
-        }
-        else {
-            // Fallback - import everything
-            entryContent = `import * as ${packagePath.replace(/[^a-zA-Z0-9]/g, '_')} from '${packagePath}';\nmodule.exports = ${packagePath.replace(/[^a-zA-Z0-9]/g, '_')};`;
-        }
-        // Write entry file
-        fs.writeFileSync(entryFile, entryContent);
-        // Bundle with esbuild
-        const result = await build({
-            entryPoints: [entryFile],
-            bundle: true,
-            format: 'cjs', // CommonJS format
-            platform: 'node',
-            target: 'node16',
-            outfile: outputFile,
-            external: [], // Bundle everything
-            minify: false, // Keep readable for debugging
-            sourcemap: false,
-            write: true,
-            resolveExtensions: ['.js', '.ts', '.json'],
-            mainFields: ['main', 'module', 'browser'],
-            conditions: ['node'],
-            nodePaths: [
-                path.join(process.cwd(), 'node_modules'),
-                path.join(process.cwd(), '..', 'node_modules'),
-                path.join(process.cwd(), '..', '..', 'node_modules')
-            ],
-            absWorkingDir: process.cwd(),
-        });
-        if (result.errors.length > 0) {
-            console.warn(`Warning: esbuild errors for package ${packagePath}:`, result.errors);
-            return null;
-        }
-        // Read the bundled output
-        if (!fs.existsSync(outputFile)) {
-            console.warn(`Warning: Bundle output not found for package ${packagePath}`);
-            return null;
+        const response = await ApiService.Skill.publishSkillVersion(apiKey, agentId, skillId, version);
+        if (!response.success) {
+            throw new Error(`Failed to publish version: ${response.error?.message || 'Unknown error'}`);
         }
-        const bundledContent = fs.readFileSync(outputFile, 'utf8');
-        // Clean up temporary files
-        try {
-            fs.unlinkSync(entryFile);
-            fs.unlinkSync(outputFile);
-        }
-        catch (cleanupError) {
-            // Ignore cleanup errors
-        }
-        // Create the final bundled code
-        let finalCode = '';
-        if (defaultImport) {
-            finalCode = `const ${defaultImport} = (function() {\n${bundledContent}\n  return module.exports;\n})();\n`;
-        }
-        else if (namedImports) {
-            const importsList = namedImports.split(',').map(imp => imp.trim());
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
-            finalCode += `const { ${importsList.join(', ')} } = module.exports;\n`;
-        }
-        else {
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
-        }
-        return finalCode;
+        return response.data;
     }
     catch (error) {
-        console.warn(`Warning: Could not bundle package ${packagePath} with esbuild:`, error);
-        // For test environments or when esbuild fails, provide a fallback
-        if (packagePath === 'axios') {
-            return createWorkingAxiosImplementation();
-        }
-        return null;
+        console.error("❌ Error publishing version:", error);
+        throw error;
     }
 }
-function createWorkingAxiosImplementation() {
-    return `
-// Working axios implementation using native fetch (for test environments)
-const axios = {
-  get: async (url, config = {}) => {
-    const searchParams = new URLSearchParams(config.params || {});
-    const fullUrl = searchParams.toString() ? \`\${url}?\${searchParams}\` : url;
-    
-    const response = await fetch(fullUrl, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      }
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const data = await response.json();
-    return { 
-      data, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  post: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  put: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  delete: async (url, config = {}) => {
-    const response = await fetch(url, {
-      method: 'DELETE',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      }
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  patch: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'PATCH',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  }
-};
-`;
-}
-async function extractToolFromClass(className, indexContent) {
-    // Find the import statement for this class
-    const importRegex = new RegExp(`import\\s+${className}\\s+from\\s+["']([^"']+)["']`, 'g');
-    const importMatch = importRegex.exec(indexContent);
-    if (!importMatch) {
-        console.warn(`Warning: Could not find import for class ${className}`);
-        return null;
-    }
-    const importPath = importMatch[1];
-    // Read the tool file
-    const toolFilePath = path.join(process.cwd(), importPath.replace('./', '') + '.ts');
-    if (!fs.existsSync(toolFilePath)) {
-        console.warn(`Warning: Tool file not found: ${toolFilePath}`);
-        return null;
-    }
-    const toolContent = fs.readFileSync(toolFilePath, 'utf8');
-    // Extract tool properties from the class
-    const nameMatch = toolContent.match(/this\.name\s*=\s*["']([^"']+)["']/);
-    const descriptionMatch = toolContent.match(/this\.description\s*=\s*["']([^"']+)["']/);
-    if (!nameMatch || !descriptionMatch) {
-        console.warn(`Warning: Could not extract name or description from ${className}`);
-        return null;
-    }
-    const toolName = nameMatch[1];
-    const toolDescription = descriptionMatch[1];
-    // Extract schemas
-    const inputSchemaMatch = toolContent.match(/const\s+(\w+)\s*=\s*z\.object\(/);
-    const outputSchemaMatch = toolContent.match(/const\s+(\w+)\s*=\s*z\.object\(/);
-    if (!inputSchemaMatch) {
-        console.warn(`Warning: Could not find input schema in ${className}`);
-        return null;
-    }
-    // Convert schemas to JSON Schema format
-    const inputSchema = convertSchemaToJSON(inputSchemaMatch[1], toolContent);
-    const outputSchema = outputSchemaMatch ? convertSchemaToJSON(outputSchemaMatch[1], toolContent) : { type: "object" };
-    // Extract execute method
-    const executeMatch = toolContent.match(/async\s+execute\s*\([^)]*\)\s*\{([\s\S]*?)\}/);
-    if (!executeMatch) {
-        console.warn(`Warning: Could not find execute method in ${className}`);
-        return null;
-    }
-    const executeBody = executeMatch[1];
-    // For class-based tools, we need to create a self-contained function that includes:
-    // 1. The service classes
-    // 2. Class instantiation
-    // 3. The execute logic
-    const selfContainedExecute = await createClassBasedExecute(executeBody, toolContent, className);
-    return {
-        name: toolName,
-        description: toolDescription,
-        inputSchema,
-        outputSchema,
-        execute: selfContainedExecute
-    };
+function formatVersionChoice(version) {
+    const currentIndicator = version.isCurrent ? ' (CURRENT)' : '';
+    const date = new Date(version.createdDate).toLocaleDateString();
+    return `${version.version}${currentIndicator} - Created: ${date} by ${version.createdByEmail}`;
 }
-async function createClassBasedExecute(executeBody, toolContent, className) {
-    const dependencies = [];
-    const bundledPackages = new Set();
-    // 1. Parse imports from the tool file
-    const importRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let importMatch;
-    while ((importMatch = importRegex.exec(toolContent)) !== null) {
-        const namedImports = importMatch[1];
-        const defaultImport = importMatch[2];
-        const packagePath = importMatch[3];
-        // Skip lua-cli imports
-        if (packagePath.startsWith('lua-cli')) {
-            continue;
-        }
-        // Handle zod
-        if (packagePath === 'zod') {
-            if (namedImports) {
-                const importsList = namedImports.split(',').map(imp => imp.trim());
-                const usedImports = importsList.filter(imp => executeBody.includes(imp) || toolContent.includes(`${imp}.`));
-                if (usedImports.length > 0) {
-                    const requireStatement = usedImports.length === 1
-                        ? `const { ${usedImports[0]} } = require('zod');`
-                        : `const { ${usedImports.join(', ')} } = require('zod');`;
-                    bundledPackages.add(requireStatement);
-                }
-            }
-            else if (defaultImport) {
-                bundledPackages.add(`const ${defaultImport} = require('zod');`);
-            }
-            continue;
-        }
-        // Handle axios - bundle it properly
-        if (packagePath === 'axios') {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
-            }
-            continue;
-        }
-        // Handle local service imports
-        if (packagePath.startsWith('./') || packagePath.startsWith('../')) {
-            // The tool files are in tools/ subdirectory, so we need to resolve from there
-            const toolDir = path.join(process.cwd(), 'tools');
-            // Resolve the service file path correctly
-            // If the import is ../services/ApiService, resolve it relative to the tools directory
-            const serviceFilePath = path.resolve(process.cwd(), 'tools', packagePath + '.ts');
-            if (fs.existsSync(serviceFilePath)) {
-                const serviceContent = fs.readFileSync(serviceFilePath, 'utf8');
-                // Process all imports in the service file
-                const serviceImportRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-                let serviceImportMatch;
-                while ((serviceImportMatch = serviceImportRegex.exec(serviceContent)) !== null) {
-                    const namedImports = serviceImportMatch[1];
-                    const defaultImport = serviceImportMatch[2];
-                    const packagePath = serviceImportMatch[3];
-                    // Skip lua-cli imports
-                    if (packagePath.startsWith('lua-cli')) {
-                        continue;
-                    }
-                    // Handle zod
-                    if (packagePath === 'zod') {
-                        if (namedImports) {
-                            const importsList = namedImports.split(',').map(imp => imp.trim());
-                            const usedImports = importsList.filter(imp => serviceContent.includes(`${imp}.`));
-                            if (usedImports.length > 0) {
-                                const requireStatement = usedImports.length === 1
-                                    ? `const { ${usedImports[0]} } = require('zod');`
-                                    : `const { ${usedImports.join(', ')} } = require('zod');`;
-                                bundledPackages.add(requireStatement);
-                            }
-                        }
-                        else if (defaultImport) {
-                            bundledPackages.add(`const ${defaultImport} = require('zod');`);
-                        }
-                        continue;
-                    }
-                    // Handle axios - bundle it properly
-                    if (packagePath === 'axios') {
-                        const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-                        if (packageCode) {
-                            bundledPackages.add(packageCode);
-                        }
-                        continue;
-                    }
-                    // Bundle other external packages
-                    if (namedImports || defaultImport) {
-                        const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-                        if (packageCode) {
-                            bundledPackages.add(packageCode);
-                        }
-                    }
-                }
-                // Extract the service class with proper brace matching
-                const classRegex = /class\s+(\w+)(?:\s+extends\s+\w+)?\s*\{/g;
-                let classMatch = classRegex.exec(serviceContent);
-                if (classMatch) {
-                    const serviceClassName = classMatch[1];
-                    const startIndex = classMatch.index + classMatch[0].length - 1; // Position of opening brace
-                    // Find matching closing brace
-                    let braceCount = 1;
-                    let endIndex = startIndex + 1;
-                    while (endIndex < serviceContent.length && braceCount > 0) {
-                        if (serviceContent[endIndex] === '{')
-                            braceCount++;
-                        else if (serviceContent[endIndex] === '}')
-                            braceCount--;
-                        endIndex++;
-                    }
-                    if (braceCount === 0) {
-                        const serviceClassBody = serviceContent.substring(startIndex + 1, endIndex - 1);
-                        // Clean up the class body (remove TypeScript types)
-                        const cleanClassBody = serviceClassBody
-                            .replace(/:\s*string/g, '')
-                            .replace(/:\s*number/g, '')
-                            .replace(/:\s*boolean/g, '')
-                            .replace(/:\s*any/g, '')
-                            .replace(/:\s*void/g, '')
-                            .replace(/:\s*Promise<[^>]+>/g, '')
-                            .replace(/:\s*Record<[^>]+>/g, '');
-                        // Create the service class
-                        const serviceClass = `class ${serviceClassName} {\n${cleanClassBody}\n}`;
-                        dependencies.push(serviceClass);
-                    }
-                }
+export async function deployCommand() {
+    return withErrorHandling(async () => {
+        // Check if we're in a skill directory
+        const config = readSkillConfig();
+        if (!config || !config.agent?.agentId || !config.skill?.skillId) {
+            console.error("❌ No lua.skill.yaml found or missing agentId/skillId. Please run this command from a skill directory.");
+            process.exit(1);
+        }
+        // Load API key
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua configure' to set up your API key.");
+            process.exit(1);
+        }
+        // Validate API key
+        const userData = await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        // Fetch available versions
+        writeProgress("🔄 Fetching available versions...");
+        const versionsResponse = await fetchVersions(apiKey, config.agent.agentId, config.skill.skillId);
+        if (!versionsResponse.versions || versionsResponse.versions.length === 0) {
+            console.log("❌ No versions found for this skill.");
+            process.exit(1);
+        }
+        // Sort versions by creation date (newest first)
+        const sortedVersions = versionsResponse.versions.sort((a, b) => new Date(b.createdDate).getTime() - new Date(a.createdDate).getTime());
+        // Let user select a version
+        const { selectedVersion } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedVersion",
+                message: "Select a version to deploy:",
+                choices: sortedVersions.map(version => ({
+                    name: formatVersionChoice(version),
+                    value: version.version
+                }))
             }
-            continue;
-        }
-        // Bundle other external packages
-        if (namedImports || defaultImport) {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
+        ]);
+        // Clear the selection prompt lines
+        clearPromptLines(2);
+        // Show warning and confirm deployment
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "⚠️  Warning: This version will be deployed to all users. Do you want to proceed?",
+                default: false
             }
-        }
-    }
-    // 2. Extract class instantiation from constructor
-    const constructorMatch = toolContent.match(/constructor\s*\([^)]*\)\s*\{([\s\S]*?)\}/);
-    if (constructorMatch) {
-        const constructorBody = constructorMatch[1];
-        // Extract service instantiation
-        const serviceInstantiationMatch = constructorBody.match(/this\.(\w+)\s*=\s*new\s+(\w+)\([^)]*\);/);
-        if (serviceInstantiationMatch) {
-            const serviceProperty = serviceInstantiationMatch[1];
-            const serviceClass = serviceInstantiationMatch[2];
-            dependencies.push(`const ${serviceProperty} = new ${serviceClass}();`);
-        }
-    }
-    // 3. Create the self-contained execute function
-    const allDependencies = [...Array.from(bundledPackages), ...dependencies];
-    const dependencyCode = allDependencies.join('\n');
-    // Clean the execute body (remove TypeScript types)
-    const cleanExecuteBody = executeBody
-        .replace(/:\s*string/g, '')
-        .replace(/:\s*number/g, '')
-        .replace(/:\s*boolean/g, '')
-        .replace(/:\s*any/g, '')
-        .replace(/:\s*void/g, '')
-        .replace(/:\s*Promise<[^>]+>/g, '')
-        .replace(/:\s*Record<[^>]+>/g, '');
-    // Replace this.serviceProperty with the instantiated service
-    const finalExecuteBody = cleanExecuteBody.replace(/this\.(\w+)/g, '$1');
-    return `async (input) => {
-${dependencyCode ? dependencyCode + '\n' : ''}${finalExecuteBody}
-}`;
+        ]);
+        // Clear the confirmation prompt lines
+        clearPromptLines(2);
+        if (!confirmed) {
+            console.log("❌ Deployment cancelled.");
+            process.exit(0);
+        }
+        // Publish the selected version
+        writeProgress("🔄 Publishing version...");
+        const publishResponse = await publishVersion(apiKey, config.agent.agentId, config.skill.skillId, selectedVersion);
+        writeSuccess(`✅ Version ${publishResponse.activeVersionId} deployed successfully`);
+    }, "deployment");
 }