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

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.0'; // 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,15 @@ ${personaSection}${welcomeMessageSection}
 skill:
   name: "${skillName}"
   version: "0.0.1"
-${skillIdSection}`;
+${skillIdSection}  env:
+    # Example environment variables - customize these for your skill
+    API_URL: "https://api.example.com"
+    API_KEY: "your-api-key-here"
+    DEBUG_MODE: "false"
+    MAX_RETRIES: "3"
+    TIMEOUT_MS: "5000"
+    # 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,96 @@
+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): {
+    require: NodeJS.Require;
+    console: any;
+    Buffer: BufferConstructor;
+    setTimeout: typeof setTimeout;
+    setInterval: typeof setInterval;
+    clearTimeout: typeof clearTimeout;
+    clearInterval: typeof clearInterval;
+    process: NodeJS.Process;
+    global: typeof globalThis;
+    __dirname: string;
+    __filename: string;
+    module: {
+        exports: {};
+    };
+    exports: {};
+    fetch: typeof fetch;
+    URLSearchParams: {
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+        prototype: URLSearchParams;
+    };
+    URL: {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    Headers: {
+        new (init?: HeadersInit): Headers;
+        prototype: Headers;
+    };
+    Request: {
+        new (input: RequestInfo | URL, init?: RequestInit): Request;
+        prototype: Request;
+    };
+    Response: {
+        new (body?: BodyInit | null, init?: ResponseInit): Response;
+        prototype: Response;
+        error(): Response;
+        json(data: any, init?: ResponseInit): Response;
+        redirect(url: string | URL, status?: number): Response;
+    };
+    Object: ObjectConstructor;
+    Array: ArrayConstructor;
+    String: StringConstructor;
+    Number: NumberConstructor;
+    Boolean: BooleanConstructor;
+    Date: DateConstructor;
+    Math: Math;
+    JSON: JSON;
+    Error: ErrorConstructor;
+    TypeError: TypeErrorConstructor;
+    ReferenceError: ReferenceErrorConstructor;
+    SyntaxError: SyntaxErrorConstructor;
+    globalThis: typeof globalThis;
+    undefined: undefined;
+    null: null;
+    Infinity: number;
+    NaN: number;
+    user: {
+        data: {
+            update: (data: any) => Promise<import("../services/api.js").ApiResponse<any>>;
+            get: () => Promise<any>;
+            create: (data: any) => Promise<any>;
+        };
+    };
+    env: (key: string) => string;
+};
+/**
+ * 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,161 @@
+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
+    const config = readSkillConfig();
+    const envVars = {};
+    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 a sandbox context
+    const sandbox = {
+        require,
+        console: consoleObj,
+        Buffer,
+        setTimeout,
+        setInterval,
+        clearTimeout,
+        clearInterval,
+        process,
+        global: globalThis,
+        __dirname: process.cwd(),
+        __filename: path.join(process.cwd(), 'index.ts'),
+        module: { exports: {} },
+        exports: {},
+        // Web APIs
+        fetch: globalThis.fetch,
+        URLSearchParams: globalThis.URLSearchParams,
+        URL: globalThis.URL,
+        Headers: globalThis.Headers,
+        Request: globalThis.Request,
+        Response: globalThis.Response,
+        // 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);
+    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);
+        }
+    };
+}