lua-cli 2.2.8-alpha.2 → 2.3.0-alpha.1

package/dist/utils/auth-flows.js

@@ -0,0 +1,141 @@
+/**
+ * Authentication Flow Utilities
+ * Handles different authentication methods (API key and email OTP)
+ */
+import inquirer from "inquirer";
+import { saveApiKey, checkApiKey, requestEmailOTP, verifyOTPAndGetToken, generateApiKey } from "../services/auth.js";
+import { clearPromptLines, writeProgress, writeSuccess } from "./cli.js";
+/**
+ * Configuration for OTP verification
+ */
+const OTP_CONFIG = {
+    MAX_ATTEMPTS: 3,
+    OTP_LENGTH: 6,
+};
+/**
+ * Handles API key authentication flow.
+ * Prompts for API key, validates it, and saves it securely.
+ *
+ * @returns Promise that resolves when authentication is complete
+ * @throws Error if API key is invalid
+ */
+export async function handleApiKeyAuth() {
+    const answers = await inquirer.prompt([
+        {
+            type: "password",
+            name: "apiKey",
+            message: "Enter your API key",
+            mask: "*",
+        },
+    ]);
+    const data = await checkApiKey(answers.apiKey);
+    if (!data) {
+        throw new Error("Invalid API key");
+    }
+    await saveApiKey(answers.apiKey);
+    writeSuccess("✅ API key saved securely.");
+}
+/**
+ * Handles email authentication flow with OTP verification.
+ * Sends OTP to email, verifies it, generates API key, and saves it.
+ *
+ * @returns Promise that resolves when authentication is complete
+ * @throws Error if OTP sending fails, verification fails, or API key generation fails
+ */
+export async function handleEmailAuth() {
+    // Step 1: Collect email
+    const { email } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "email",
+            message: "Enter your email address:",
+            validate: (input) => {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                return emailRegex.test(input) || "Please enter a valid email address";
+            }
+        }
+    ]);
+    clearPromptLines(2);
+    // Step 2: Send OTP
+    writeProgress("📧 Sending OTP to your email...");
+    const otpSent = await requestEmailOTP(email);
+    if (!otpSent) {
+        throw new Error("Failed to send OTP. Please try again.");
+    }
+    writeProgress("✅ OTP sent successfully!");
+    // Step 3: Verify OTP with retry logic
+    const signInToken = await verifyOTPWithRetry(email);
+    // Step 4: Generate API key
+    writeProgress("🔑 Generating API key...");
+    const apiKey = await generateApiKey(signInToken);
+    if (!apiKey) {
+        throw new Error("Failed to generate API key. Please try again.");
+    }
+    // Step 5: Save API key
+    await saveApiKey(apiKey);
+    writeSuccess("✅ API key generated and saved securely.");
+}
+/**
+ * Verifies OTP with retry logic.
+ * Allows multiple attempts to enter the correct OTP.
+ *
+ * @param email - Email address for OTP verification
+ * @returns Sign-in token from successful verification
+ * @throws Error if maximum attempts are exceeded
+ */
+async function verifyOTPWithRetry(email) {
+    let otpVerified = false;
+    let attempts = 0;
+    let signInToken = null;
+    while (!otpVerified && attempts < OTP_CONFIG.MAX_ATTEMPTS) {
+        const { pin } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "pin",
+                message: "Enter the OTP code:",
+                validate: (input) => {
+                    return input.length === OTP_CONFIG.OTP_LENGTH || `OTP must be ${OTP_CONFIG.OTP_LENGTH} digits`;
+                }
+            }
+        ]);
+        clearPromptLines(2);
+        writeProgress("🔐 Verifying OTP...");
+        signInToken = await verifyOTPAndGetToken(email, pin);
+        if (signInToken) {
+            otpVerified = true;
+            writeProgress("✅ OTP verified successfully!");
+        }
+        else {
+            attempts++;
+            if (attempts < OTP_CONFIG.MAX_ATTEMPTS) {
+                console.log(`❌ Invalid OTP. ${OTP_CONFIG.MAX_ATTEMPTS - attempts} attempts remaining.`);
+            }
+            else {
+                throw new Error("Invalid OTP. Maximum attempts reached. Please try again later.");
+            }
+        }
+    }
+    if (!signInToken) {
+        throw new Error("OTP verification failed");
+    }
+    return signInToken;
+}
+/**
+ * Prompts user to choose authentication method.
+ *
+ * @returns Selected authentication method ('api-key' or 'email')
+ */
+export async function promptAuthMethod() {
+    const { authMethod } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "authMethod",
+            message: "Choose authentication method:",
+            choices: [
+                { name: "API Key", value: "api-key" },
+                { name: "Email", value: "email" }
+            ]
+        }
+    ]);
+    return authMethod;
+}

package/dist/utils/bundling.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Bundling Utilities
+ * Handles esbuild bundling of tools and main index
+ */
+import { ToolInfo } from '../interfaces/compile.js';
+import { Project } from "ts-morph";
+/**
+ * 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
+ *
+ * @param tool - The tool to bundle
+ * @param distDir - The distribution directory for output
+ */
+export declare function bundleTool(tool: ToolInfo, distDir: string): Promise<void>;
+/**
+ * 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 declare function bundleMainIndex(indexPath: string, distDir: string): Promise<void>;
+/**
+ * Extracts execute code and input schema from a tool.
+ * This function:
+ * 1. Reads the bundled tool code
+ * 2. Extracts the execute function
+ * 3. Converts Zod schema to JSON Schema format
+ *
+ * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
+ * @param project - The ts-morph Project instance for AST analysis
+ */
+export declare function extractExecuteCode(tool: ToolInfo, project: Project): Promise<void>;

package/dist/utils/bundling.js

@@ -0,0 +1,137 @@
+/**
+ * Bundling Utilities
+ * Handles esbuild bundling of tools and main index
+ */
+import fs from "fs";
+import path from "path";
+import { build } from "esbuild";
+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';
+/**
+ * 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
+ *
+ * @param tool - The tool to bundle
+ * @param distDir - The distribution directory for output
+ */
+export async function bundleTool(tool, distDir) {
+    writeProgress(`📦 Bundling ${tool.className}...`);
+    try {
+        const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
+        await build({
+            ...ESBUILD_TOOL_CONFIG,
+            entryPoints: [tool.filePath],
+            outfile: outputPath,
+        });
+        // Wrap the bundled code for VM execution environment
+        await wrapToolForVM(outputPath, tool);
+    }
+    catch (error) {
+        console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
+    }
+}
+/**
+ * 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 execute code and input schema from a tool.
+ * This function:
+ * 1. Reads the bundled tool code
+ * 2. Extracts the execute function
+ * 3. Converts Zod schema to JSON Schema format
+ *
+ * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
+ * @param project - The ts-morph Project instance for AST analysis
+ */
+export async function extractExecuteCode(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 exists
+        const executeMethod = classDecl.getMethod('execute');
+        if (!executeMethod) {
+            console.warn(`Warning: Could not find execute method in ${tool.className}`);
+            return;
+        }
+        const executeBody = executeMethod.getBodyText();
+        if (!executeBody) {
+            console.warn(`Warning: Execute method has no body in ${tool.className}`);
+            return;
+        }
+        // Extract execute code from bundled file
+        tool.executeCode = extractExecuteCodeFromBundledFile(tool);
+        // Extract and convert input schema
+        tool.inputSchema = await extractInputSchema(classDecl, tool);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not extract execute code for ${tool.className}:`, error);
+    }
+}
+/**
+ * Extracts execute code from the bundled tool file.
+ *
+ * @param tool - The tool whose bundled code to read
+ * @returns The execute function code or undefined if not found
+ */
+function extractExecuteCodeFromBundledFile(tool) {
+    const bundledPath = path.join(process.cwd(), COMPILE_DIRS.DIST, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
+    if (fs.existsSync(bundledPath)) {
+        const bundledCode = fs.readFileSync(bundledPath, 'utf8');
+        return createExecuteFunction(bundledCode, tool);
+    }
+    return undefined;
+}
+/**
+ * Extracts and converts the input schema from a tool class.
+ * Converts Zod schemas to JSON Schema format.
+ *
+ * @param classDecl - The tool class declaration from ts-morph
+ * @param tool - The tool being analyzed (for logging)
+ * @returns The JSON Schema object or default schema
+ */
+async function extractInputSchema(classDecl, tool) {
+    const inputSchemaProperty = classDecl.getProperty('inputSchema');
+    if (inputSchemaProperty && inputSchemaProperty.getInitializer()) {
+        const initializer = inputSchemaProperty.getInitializer();
+        if (initializer) {
+            try {
+                const zodSchemaCode = initializer.getText();
+                return await evaluateZodSchemaToJsonSchema(zodSchemaCode);
+            }
+            catch (error) {
+                console.warn(`Warning: Could not parse Zod schema for ${tool.className}:`, error);
+                return DEFAULT_INPUT_SCHEMA;
+            }
+        }
+    }
+    return DEFAULT_INPUT_SCHEMA;
+}

package/dist/utils/compile.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Utility functions for compile command
+ */
+import { Project } from "ts-morph";
+import { ToolInfo } from "../interfaces/compile.js";
+/**
+ * Compresses code using gzip and returns base64 encoded string
+ */
+export declare function compressCode(code: string): string;
+/**
+ * Finds the index.ts file in the project
+ */
+export declare function findIndexFile(): string;
+/**
+ * Resolves import path from module specifier
+ */
+export declare function resolveImportPath(moduleSpecifier: string, currentFilePath: string): string;
+/**
+ * Creates execute function wrapper from bundled code
+ */
+export declare function createExecuteFunction(bundledCode: string, tool: ToolInfo): string;
+/**
+ * Evaluates Zod schema code and converts it to JSON Schema
+ */
+export declare function evaluateZodSchemaToJsonSchema(zodSchemaCode: string): Promise<any>;
+/**
+ * Wraps bundled tool code for VM execution
+ */
+export declare function wrapToolForVM(outputPath: string, tool: ToolInfo): Promise<void>;
+/**
+ * Extracts tool information from a new expression in the AST
+ */
+export declare function extractToolFromNewExpressionSync(newExpr: any, project: Project): ToolInfo | null;
+/**
+ * Extracts skills metadata from index file
+ */
+export declare function extractSkillsMetadata(indexFile: any): any[];

package/dist/utils/compile.js

@@ -0,0 +1,242 @@
+/**
+ * Utility functions for compile command
+ */
+import fs from "fs";
+import path from "path";
+import { gzipSync } from "zlib";
+import { Node } from "ts-morph";
+/**
+ * Compresses code using gzip and returns base64 encoded string
+ */
+export function compressCode(code) {
+    const compressed = gzipSync(code);
+    return compressed.toString('base64');
+}
+/**
+ * Finds the index.ts file in the project
+ */
+export function findIndexFile() {
+    // Check for index.ts in current directory
+    let indexPath = path.join(process.cwd(), "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    // Check for index.ts in src directory
+    indexPath = path.join(process.cwd(), "src", "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    throw new Error("index.ts not found in current directory or src/ directory");
+}
+/**
+ * Resolves import path from module specifier
+ */
+export function resolveImportPath(moduleSpecifier, currentFilePath) {
+    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+        // Relative import - resolve relative to current file
+        const currentDir = path.dirname(currentFilePath);
+        return path.resolve(currentDir, moduleSpecifier + '.ts');
+    }
+    else {
+        // Absolute import - assume it's in the project
+        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
+    }
+}
+/**
+ * Creates execute function wrapper from bundled code
+ */
+export function createExecuteFunction(bundledCode, tool) {
+    // The bundled code is already wrapped for VM execution by wrapToolForVM
+    // Just return it directly since it's already an async function
+    return bundledCode;
+}
+/**
+ * Evaluates Zod schema code and converts it to JSON Schema
+ */
+export async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
+    try {
+        // Import zod and zod-to-json-schema dynamically
+        const { z } = await import('zod');
+        const { zodToJsonSchema } = await import('zod-to-json-schema');
+        // Create a safe evaluation context using Function constructor
+        const evalFunction = new Function('z', `return ${zodSchemaCode}`);
+        const zodSchema = evalFunction(z);
+        // Convert to JSON Schema using the library
+        const jsonSchema = zodToJsonSchema(zodSchema, 'schema');
+        // Extract just the core schema, removing JSON Schema references and definitions
+        if (jsonSchema.$ref && jsonSchema.definitions && jsonSchema.definitions.schema) {
+            // Return just the schema definition without the wrapper
+            return jsonSchema.definitions.schema;
+        }
+        // Remove the top-level $schema and title properties that we don't need
+        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
+        return cleanSchema;
+    }
+    catch (error) {
+        console.warn('Warning: Could not evaluate Zod schema, falling back to basic parsing:', error);
+        // Fallback to basic parsing for simple cases
+        if (zodSchemaCode.includes('z.object({')) {
+            return { type: 'object' };
+        }
+        if (zodSchemaCode.includes('z.string()'))
+            return { type: 'string' };
+        if (zodSchemaCode.includes('z.number()'))
+            return { type: 'number' };
+        if (zodSchemaCode.includes('z.boolean()'))
+            return { type: 'boolean' };
+        return { type: 'object' };
+    }
+}
+/**
+ * Wraps bundled tool code for VM execution
+ */
+export async function wrapToolForVM(outputPath, tool) {
+    const bundledCode = fs.readFileSync(outputPath, 'utf8');
+    // Create a wrapper that's compatible with the existing sandbox.ts VM system
+    // The sandbox expects: const executeFunction = ${toolCode}; module.exports = async (input) => { return await executeFunction(input); };
+    const wrappedCode = `async (input) => {
+  
+  // Execute the bundled tool code
+  ${bundledCode}
+  
+  // Get the tool class from exports
+  const ToolClass = module.exports.default || module.exports.${tool.className} || module.exports;
+  
+  // Create and execute the tool
+  const toolInstance = new ToolClass();
+  return await toolInstance.execute(input);
+}`;
+    fs.writeFileSync(outputPath, wrappedCode);
+}
+/**
+ * Extracts tool information from a new expression in the AST
+ */
+export function extractToolFromNewExpressionSync(newExpr, project) {
+    try {
+        const expression = newExpr.getExpression();
+        const className = expression.getText();
+        // Find the import declaration for this class
+        const sourceFile = newExpr.getSourceFile();
+        const imports = sourceFile.getImportDeclarations();
+        for (const importDecl of imports) {
+            const namedImports = importDecl.getNamedImports();
+            const defaultImport = importDecl.getDefaultImport();
+            let toolFilePath = null;
+            // Check named imports
+            for (const namedImport of namedImports) {
+                if (namedImport.getName() === className) {
+                    toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
+                    break;
+                }
+            }
+            // Check default import
+            if (!toolFilePath && defaultImport && defaultImport.getText() === className) {
+                toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
+            }
+            if (toolFilePath && fs.existsSync(toolFilePath)) {
+                // Extract tool metadata from the class file
+                try {
+                    const toolSourceFile = project.addSourceFileAtPath(toolFilePath);
+                    const classDecl = toolSourceFile.getClass(className);
+                    if (classDecl) {
+                        const nameProperty = classDecl.getProperty('name');
+                        const descProperty = classDecl.getProperty('description');
+                        let toolName = className.replace(/Tool$/, '').toLowerCase();
+                        let description = '';
+                        // Extract name from property if available
+                        if (nameProperty && nameProperty.getInitializer()) {
+                            const nameValue = nameProperty.getInitializer()?.getText();
+                            if (nameValue) {
+                                toolName = nameValue.replace(/['"]/g, '');
+                            }
+                        }
+                        // Extract description from property if available
+                        if (descProperty && descProperty.getInitializer()) {
+                            const descValue = descProperty.getInitializer()?.getText();
+                            if (descValue) {
+                                description = descValue.replace(/['"]/g, '');
+                            }
+                        }
+                        const toolInfo = {
+                            name: toolName,
+                            className,
+                            filePath: toolFilePath,
+                            description
+                        };
+                        return toolInfo;
+                    }
+                }
+                catch (fileError) {
+                    console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
+        return null;
+    }
+}
+/**
+ * Extracts skills metadata from index file
+ */
+export function extractSkillsMetadata(indexFile) {
+    const skills = [];
+    // Find all LuaSkill constructor calls
+    indexFile.forEachDescendant((node) => {
+        if (Node.isNewExpression(node)) {
+            const expression = node.getExpression();
+            if (expression.getText() === 'LuaSkill') {
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                    const configObj = args[0];
+                    let skillName = '';
+                    let skillVersion = '';
+                    let description = '';
+                    let context = '';
+                    let constructorTools = [];
+                    // Extract properties
+                    configObj.getProperties().forEach((prop) => {
+                        if (Node.isPropertyAssignment(prop)) {
+                            const name = prop.getName();
+                            const value = prop.getInitializer();
+                            if (name === 'name' && value) {
+                                skillName = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'version' && value) {
+                                skillVersion = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'context' && value) {
+                                context = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'tools' && value && Node.isArrayLiteralExpression(value)) {
+                                // Extract tools from constructor array
+                                const toolsArray = value;
+                                constructorTools = toolsArray.getElements().map((element) => {
+                                    if (Node.isNewExpression(element)) {
+                                        return element.getExpression().getText();
+                                    }
+                                    return '';
+                                }).filter(name => name);
+                            }
+                        }
+                    });
+                    if (skillName) {
+                        skills.push({
+                            name: skillName,
+                            version: skillVersion || '1.0.0',
+                            description,
+                            context,
+                            constructorTools
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return skills;
+}

package/dist/utils/deploy-api.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Deploy API Utilities
+ * Handles API calls for deployment operations
+ */
+import { VersionsResponse, PublishResponse } from '../interfaces/deploy.js';
+/**
+ * Fetches available versions for a skill.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @returns Versions response containing array of versions
+ * @throws Error if API call fails
+ */
+export declare function fetchVersions(apiKey: string, agentId: string, skillId: string): Promise<VersionsResponse>;
+/**
+ * Publishes a specific version to production.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param version - Version to publish
+ * @returns Publish response with deployment details
+ * @throws Error if API call fails
+ */
+export declare function publishVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<PublishResponse>;

package/dist/utils/deploy-api.js

@@ -0,0 +1,53 @@
+/**
+ * Deploy API Utilities
+ * Handles API calls for deployment operations
+ */
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Fetches available versions for a skill.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @returns Versions response containing array of versions
+ * @throws Error if API call fails
+ */
+export async function fetchVersions(apiKey, agentId, skillId) {
+    try {
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillApi.getSkillVersions(skillId);
+        if (!response.success) {
+            throw new Error(`Failed to fetch versions: ${response.error?.message || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error("❌ Error fetching versions:", error);
+        throw error;
+    }
+}
+/**
+ * Publishes a specific version to production.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param version - Version to publish
+ * @returns Publish response with deployment details
+ * @throws Error if API call fails
+ */
+export async function publishVersion(apiKey, agentId, skillId, version) {
+    try {
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillApi.publishSkillVersion(skillId, version);
+        if (!response.success) {
+            throw new Error(`Failed to publish version: ${response.error?.message || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error("❌ Error publishing version:", error);
+        throw error;
+    }
+}