lua-cli 1.3.2-alpha.0 → 1.3.2-alpha.3

package/dist/services/api.d.ts

@@ -184,10 +184,10 @@ export declare class ToolApi {
     static patchTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
 }
 export declare class UserDataApi {
-    static getUserData(apiKey: string, agentId: string): Promise<ApiResponse<UserData>>;
-    static createUserData(apiKey: string, agentId: string, data: any): Promise<ApiResponse<UserData>>;
-    static updateUserData(apiKey: string, agentId: string, data: any): Promise<ApiResponse<UserData>>;
-    static deleteUserData(apiKey: string, agentId: string): Promise<ApiResponse<UserData>>;
+    static getUserData(apiKey: string, agentId: string): Promise<any>;
+    static createUserData(apiKey: string, agentId: string, data: any): Promise<any>;
+    static updateUserData(apiKey: string, agentId: string, data: any): Promise<ApiResponse<any>>;
+    static deleteUserData(apiKey: string, agentId: string): Promise<ApiResponse<any>>;
 }
 /**
  * Main API service that exports all API classes

package/dist/services/api.js

@@ -200,24 +200,28 @@ export class ToolApi {
 // User Data API calls
 export class UserDataApi {
     static async getUserData(apiKey, agentId) {
-        return httpClient.get(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
+        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
             Authorization: `Bearer ${apiKey}`,
         });
+        return response;
     }
     static async createUserData(apiKey, agentId, data) {
-        return httpClient.post(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
+        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
             Authorization: `Bearer ${apiKey}`,
         });
+        return response.data.data;
     }
     static async updateUserData(apiKey, agentId, data) {
-        return httpClient.put(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
+        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
             Authorization: `Bearer ${apiKey}`,
         });
+        return response.data.data;
     }
     static async deleteUserData(apiKey, agentId) {
-        return httpClient.delete(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
+        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
             Authorization: `Bearer ${apiKey}`,
         });
+        return response;
     }
 }
 /**

package/dist/skill.d.ts

@@ -1,6 +1,20 @@
 import { ZodType } from "zod";
 import { LuaTool } from "./types/index.js";
 export { LuaTool };
+/**
+ * Safe environment variable access function
+ * Gets injected at runtime with skill-specific environment variables
+ *
+ * @param key - The environment variable key to retrieve
+ * @returns The environment variable value or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const baseUrl = env('BASE_URL');
+ * const apiKey = env('API_KEY');
+ * ```
+ */
+export declare const env: (key: string) => string | undefined;
 export interface LuaSkillConfig {
     description: string;
     context: string;
@@ -25,6 +39,7 @@ export declare class LuaSkill {
      * ```
      */
     constructor(config: LuaSkillConfig);
-    addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
+    addTool<TInput extends ZodType>(tool: LuaTool<TInput>): void;
+    addTools(tools: LuaTool<any>[]): void;
     run(input: Record<string, any>): Promise<any>;
 }

package/dist/skill.js

@@ -1,4 +1,46 @@
 import { assertValidToolName } from "./types/index.js";
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+/**
+ * Safe environment variable access function
+ * Gets injected at runtime with skill-specific environment variables
+ *
+ * @param key - The environment variable key to retrieve
+ * @returns The environment variable value or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const baseUrl = env('BASE_URL');
+ * const apiKey = env('API_KEY');
+ * ```
+ */
+export const env = (key) => {
+    // Try to load environment variables from lua.skill.yaml
+    try {
+        // Look for lua.skill.yaml in current directory and parent directories
+        let currentDir = process.cwd();
+        let yamlPath = null;
+        while (currentDir !== path.dirname(currentDir)) {
+            const potentialPath = path.join(currentDir, 'lua.skill.yaml');
+            if (fs.existsSync(potentialPath)) {
+                yamlPath = potentialPath;
+                break;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        if (yamlPath) {
+            const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+            const config = yaml.load(yamlContent);
+            return config?.skill?.env?.[key];
+        }
+    }
+    catch (error) {
+        // If we can't load the YAML, fall back to undefined
+        console.warn(`Warning: Could not load environment variables from lua.skill.yaml: ${error}`);
+    }
+    return undefined;
+};
 export class LuaSkill {
     /**
      * Creates a new LuaSkill instance
@@ -25,6 +67,13 @@ export class LuaSkill {
         assertValidToolName(tool.name);
         this.tools.push(tool);
     }
+    addTools(tools) {
+        // Validate all tool names before adding them
+        for (const tool of tools) {
+            assertValidToolName(tool.name);
+        }
+        this.tools.push(...tools);
+    }
     async run(input) {
         const tool = this.tools.find(tool => tool.name === input.tool);
         if (!tool) {

package/dist/types/index.d.ts

@@ -62,11 +62,10 @@ export declare function validateToolName(name: string): boolean;
  * Throws an error if the tool name is invalid
  */
 export declare function assertValidToolName(name: string): void;
-export interface LuaTool<TInput extends ZodType = ZodType, TOutput extends ZodType = ZodType> {
+export interface LuaTool<TInput extends ZodType = ZodType> {
     name: string;
     description: string;
     inputSchema: TInput;
-    outputSchema: TOutput;
     execute: (input: any) => Promise<any>;
 }
 export interface LuaSkillConfig {
@@ -78,6 +77,7 @@ export declare class LuaSkill {
     private readonly description;
     private readonly context;
     constructor(config: LuaSkillConfig);
-    addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
+    addTool<TInput extends ZodType>(tool: LuaTool<TInput>): void;
+    addTools(tools: LuaTool<any>[]): void;
     run(input: Record<string, any>): Promise<any>;
 }

package/dist/user-data-api.d.ts

@@ -3,6 +3,7 @@
  * Provides methods to interact with user data stored in the Lua system
  */
 export declare class UserDataAPI {
+    userData: any;
     constructor();
     /**
      * Get user data for the current agent

package/dist/user-data-api.js

@@ -3,13 +3,15 @@
  * Provides methods to interact with user data stored in the Lua system
  */
 export class UserDataAPI {
-    constructor() { }
+    constructor() {
+        this.userData = {};
+    }
     /**
      * Get user data for the current agent
      * @returns Promise<UserDataResponse>
      */
     async get() {
-        return { success: true };
+        return { success: true, data: this.userData };
     }
     /**
      * Create or update user data for the current agent
@@ -17,7 +19,8 @@ export class UserDataAPI {
      * @returns Promise<UserDataResponse>
      */
     async create(data) {
-        return { success: true };
+        this.userData = data;
+        return { success: true, data: this.userData };
     }
     /**
      * Update existing user data for the current agent
@@ -26,13 +29,15 @@ export class UserDataAPI {
      */
     async update(data) {
         // Update is the same as create for this API
-        return { success: true };
+        this.userData = { ...this.userData, ...data };
+        return { success: true, data: this.userData };
     }
     /**
      * Clear all user data for the current agent
      * @returns Promise<{success: boolean}>
      */
     async clear() {
+        this.userData = {};
         return { success: true };
     }
 }

package/dist/utils/files.js

@@ -27,10 +27,30 @@ export function copyTemplateFiles(templateDir, targetDir) {
 function updatePackageJson(srcPath, destPath) {
     // Read the template package.json
     const templatePackageJson = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
-    // Get the current CLI version from the main package.json
-    const mainPackageJsonPath = path.join(process.cwd(), 'package.json');
-    const mainPackageJson = JSON.parse(fs.readFileSync(mainPackageJsonPath, 'utf8'));
-    const currentCliVersion = mainPackageJson.version;
+    // Get the current CLI version from the CLI's own package.json
+    // We need to find the CLI's package.json, not the current working directory's
+    let currentCliVersion = '1.3.2-alpha.2'; // Default fallback version
+    try {
+        // Try to find the CLI's package.json by looking for it in common locations
+        const possiblePaths = [
+            path.join(__dirname, '..', '..', 'package.json'), // From dist/utils/
+            path.join(process.cwd(), 'package.json'), // Current directory (fallback)
+            path.join(process.env.HOME || '', '.npm-global', 'lib', 'node_modules', 'lua-cli', 'package.json'), // Global install
+        ];
+        for (const packagePath of possiblePaths) {
+            if (fs.existsSync(packagePath)) {
+                const mainPackageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+                if (mainPackageJson.name === 'lua-cli') {
+                    currentCliVersion = mainPackageJson.version;
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If we can't read any package.json, use the fallback version
+        console.log(`Using fallback CLI version: ${currentCliVersion}`);
+    }
     // Update the lua-cli dependency version
     if (templatePackageJson.dependencies && templatePackageJson.dependencies['lua-cli']) {
         templatePackageJson.dependencies['lua-cli'] = `^${currentCliVersion}`;
@@ -50,7 +70,13 @@ ${personaSection}${welcomeMessageSection}
 skill:
   name: "${skillName}"
   version: "0.0.1"
-${skillIdSection}`;
+${skillIdSection}  env:
+    # Example environment variables - customize these for your skill
+    PINECONE_API_KEY: "pcsk_5iFtQD_xxxxx"
+    OPENAI_API_KEY: "sk-proj--xxxx"
+    STRIPE_SECRET_KEY: "sk_test_xxxx"
+    # Add your own environment variables below
+    # CUSTOM_VAR: "custom-value"`;
     fs.writeFileSync("lua.skill.yaml", yamlContent);
 }
 export function readSkillYaml() {

package/dist/utils/sandbox.d.ts

@@ -0,0 +1,27 @@
+export interface SandboxOptions {
+    apiKey: string;
+    agentId: string;
+    customConsole?: any;
+    broadcastLog?: (logData: any) => void;
+}
+export interface ExecuteToolOptions extends SandboxOptions {
+    toolCode: string;
+    inputs: any;
+}
+/**
+ * Creates a VM sandbox context with all necessary globals and utilities
+ */
+export declare function createSandbox(options: SandboxOptions): any;
+/**
+ * Executes a tool in a VM sandbox
+ */
+export declare function executeTool(options: ExecuteToolOptions): Promise<any>;
+/**
+ * Creates a custom console that broadcasts logs via WebSocket
+ */
+export declare function createBroadcastConsole(broadcastLog: (logData: any) => void): {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};

package/dist/utils/sandbox.js

@@ -0,0 +1,271 @@
+import { createRequire } from "module";
+import vm from "vm";
+import path from "path";
+import { UserDataApi } from "../services/api.js";
+import { readSkillConfig } from "./files.js";
+/**
+ * Creates a VM sandbox context with all necessary globals and utilities
+ */
+export function createSandbox(options) {
+    const { apiKey, agentId, customConsole, broadcastLog } = options;
+    // Extract environment variables from YAML config and merge with process.env
+    const config = readSkillConfig();
+    const envVars = {};
+    // Copy process.env, filtering out undefined values
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            envVars[key] = value;
+        }
+    }
+    // Override with config values
+    if (config?.skill?.env) {
+        for (const [key, value] of Object.entries(config.skill.env)) {
+            envVars[key] = value;
+        }
+    }
+    // Create a CommonJS context for execution
+    const require = createRequire(process.cwd() + '/package.json');
+    const updateUserData = async (data) => {
+        return await UserDataApi.updateUserData(apiKey, agentId, data);
+    };
+    const getUserData = async () => {
+        return await UserDataApi.getUserData(apiKey, agentId);
+    };
+    const linkUserData = async (data) => {
+        return await UserDataApi.createUserData(apiKey, agentId, data);
+    };
+    // Create console object (use custom console if provided, otherwise default)
+    const consoleObj = customConsole || console;
+    // Create comprehensive polyfills for browser/Node.js APIs
+    const polyfills = {
+        // AbortController polyfill
+        AbortController: globalThis.AbortController || class AbortController {
+            constructor() {
+                this.signal = {
+                    aborted: false,
+                    addEventListener: () => { },
+                    removeEventListener: () => { },
+                    dispatchEvent: () => { }
+                };
+            }
+            abort() {
+                this.signal.aborted = true;
+            }
+        },
+        // FormData polyfill
+        FormData: globalThis.FormData || class FormData {
+            constructor() {
+                this._data = [];
+            }
+            append(name, value) {
+                this._data.push({ name, value });
+            }
+            get(name) {
+                const item = this._data.find(d => d.name === name);
+                return item ? item.value : null;
+            }
+            getAll(name) {
+                return this._data.filter(d => d.name === name).map(d => d.value);
+            }
+            has(name) {
+                return this._data.some(d => d.name === name);
+            }
+            delete(name) {
+                this._data = this._data.filter(d => d.name !== name);
+            }
+            set(name, value) {
+                this.delete(name);
+                this.append(name, value);
+            }
+            entries() {
+                return this._data.map(d => [d.name, d.value]);
+            }
+            keys() {
+                return this._data.map(d => d.name);
+            }
+            values() {
+                return this._data.map(d => d.value);
+            }
+        },
+        // TextEncoder/TextDecoder polyfills
+        TextEncoder: globalThis.TextEncoder || class TextEncoder {
+            encode(input) {
+                return Buffer.from(input, 'utf8');
+            }
+        },
+        TextDecoder: globalThis.TextDecoder || class TextDecoder {
+            decode(input) {
+                return Buffer.from(input).toString('utf8');
+            }
+        },
+        // Crypto polyfill (basic)
+        crypto: globalThis.crypto || {
+            randomUUID: () => {
+                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+                    const r = Math.random() * 16 | 0;
+                    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+                    return v.toString(16);
+                });
+            },
+            getRandomValues: (array) => {
+                for (let i = 0; i < array.length; i++) {
+                    array[i] = Math.floor(Math.random() * 256);
+                }
+                return array;
+            }
+        }
+    };
+    // Create a sandbox context
+    const sandbox = {
+        require,
+        console: consoleObj,
+        Buffer,
+        setTimeout,
+        setInterval,
+        clearTimeout,
+        clearInterval,
+        process: {
+            ...process,
+            env: envVars
+        },
+        global: globalThis,
+        __dirname: process.cwd(),
+        __filename: path.join(process.cwd(), 'index.ts'),
+        module: { exports: {} },
+        exports: {},
+        // Web APIs with polyfills
+        fetch: globalThis.fetch,
+        URLSearchParams: globalThis.URLSearchParams,
+        URL: globalThis.URL,
+        Headers: globalThis.Headers,
+        Request: globalThis.Request,
+        Response: globalThis.Response,
+        FormData: polyfills.FormData,
+        AbortController: polyfills.AbortController,
+        TextEncoder: polyfills.TextEncoder,
+        TextDecoder: polyfills.TextDecoder,
+        crypto: polyfills.crypto,
+        // Additional globals
+        Object,
+        Array,
+        String,
+        Number,
+        Boolean,
+        Date,
+        Math,
+        JSON,
+        Error,
+        TypeError,
+        ReferenceError,
+        SyntaxError,
+        globalThis,
+        undefined: undefined,
+        null: null,
+        Infinity: Infinity,
+        NaN: NaN,
+        user: {
+            data: {
+                update: updateUserData,
+                get: getUserData,
+                create: linkUserData
+            }
+        },
+        // Environment variables function
+        env: (key) => envVars[key]
+    };
+    return sandbox;
+}
+/**
+ * Executes a tool in a VM sandbox
+ */
+export async function executeTool(options) {
+    const { toolCode, inputs } = options;
+    // Create sandbox
+    const sandbox = createSandbox(options);
+    // Create the CommonJS wrapper code
+    const commonJsWrapper = `
+const executeFunction = ${toolCode};
+
+// Export the function for testing
+module.exports = async (input) => {
+  return await executeFunction(input);
+};
+`;
+    // Execute the code in the sandbox
+    const context = vm.createContext(sandbox);
+    // Add polyfills to global scope for libraries that expect them
+    vm.runInContext(`
+    if (typeof global !== 'undefined') {
+      global.AbortController = AbortController;
+      global.FormData = FormData;
+      global.TextEncoder = TextEncoder;
+      global.TextDecoder = TextDecoder;
+      global.crypto = crypto;
+      global.fetch = fetch;
+      global.Headers = Headers;
+      global.Request = Request;
+      global.Response = Response;
+      global.URL = URL;
+      global.URLSearchParams = URLSearchParams;
+    }
+  `, context);
+    vm.runInContext(commonJsWrapper, context);
+    // Get the exported function and execute it
+    const executeFunction = context.module.exports;
+    return await executeFunction(inputs);
+}
+/**
+ * Creates a custom console that broadcasts logs via WebSocket
+ */
+export function createBroadcastConsole(broadcastLog) {
+    return {
+        log: (...args) => {
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            broadcastLog({
+                type: 'log',
+                subType: 'info',
+                message: message,
+                timestamp: new Date().toISOString(),
+                id: Date.now().toString()
+            });
+            // Also log to server console
+            console.log(...args);
+        },
+        error: (...args) => {
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            broadcastLog({
+                type: 'log',
+                subType: 'error',
+                message: message,
+                timestamp: new Date().toISOString(),
+                id: Date.now().toString()
+            });
+            // Also log to server console
+            console.error(...args);
+        },
+        warn: (...args) => {
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            broadcastLog({
+                type: 'log',
+                subType: 'warn',
+                message: message,
+                timestamp: new Date().toISOString(),
+                id: Date.now().toString()
+            });
+            // Also log to server console
+            console.warn(...args);
+        },
+        info: (...args) => {
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            broadcastLog({
+                type: 'log',
+                subType: 'info',
+                message: message,
+                timestamp: new Date().toISOString(),
+                id: Date.now().toString()
+            });
+            // Also log to server console
+            console.info(...args);
+        }
+    };
+}