lua-cli 1.3.2-alpha.2 → 2.0.0

package/dist/utils/files.js

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import pkg from 'js-yaml';
-const { load } = pkg;
+const { load, dump } = pkg;
 export function copyTemplateFiles(templateDir, targetDir) {
     const files = fs.readdirSync(templateDir);
     for (const file of files) {
@@ -29,7 +29,7 @@ function updatePackageJson(srcPath, destPath) {
     const templatePackageJson = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
     // 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
+    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 = [
@@ -59,7 +59,6 @@ function updatePackageJson(srcPath, destPath) {
     fs.writeFileSync(destPath, JSON.stringify(templatePackageJson, null, 2) + '\n');
 }
 export function createSkillYaml(agentId, orgId, skillName, skillId, persona, welcomeMessage) {
-    const skillIdSection = skillId ? `  skillId: "${skillId}"\n` : '';
     // Handle multiline strings properly for YAML
     const personaSection = persona ? `  persona: |\n${persona.split('\n').map(line => `    ${line}`).join('\n')}\n` : '';
     const welcomeMessageSection = welcomeMessage ? `  welcomeMessage: "${welcomeMessage}"\n` : '';
@@ -67,18 +66,9 @@ export function createSkillYaml(agentId, orgId, skillName, skillId, persona, wel
   agentId: "${agentId}"
   orgId: "${orgId}"
 ${personaSection}${welcomeMessageSection}
-skill:
-  name: "${skillName}"
-  version: "0.0.1"
-${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"`;
+skills:
+  # Skills will be auto-generated during compilation
+`;
     fs.writeFileSync("lua.skill.yaml", yamlContent);
 }
 export function readSkillYaml() {
@@ -110,18 +100,13 @@ export function updateSkillYamlPersona(persona, welcomeMessage) {
     if (welcomeMessage) {
         data.agent.welcomeMessage = welcomeMessage;
     }
-    // Convert back to YAML with proper formatting
-    const updatedYamlContent = `agent:
-  agentId: "${data.agent.agentId}"
-  orgId: "${data.agent.orgId}"
-  persona: |
-${persona.split('\n').map(line => `    ${line}`).join('\n')}
-  welcomeMessage: "${data.agent.welcomeMessage || ''}"
-
-skill:
-  name: "${data.skill.name}"
-  version: "${data.skill.version}"
-  skillId: "${data.skill.skillId || ''}"
-`;
+    // Use yaml.dump to properly handle both old and new formats
+    const updatedYamlContent = dump(data, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        quotingType: '"',
+        forceQuotes: false
+    });
     fs.writeFileSync(yamlPath, updatedYamlContent);
 }

package/dist/utils/sandbox.d.ts

@@ -8,79 +8,17 @@ export interface ExecuteToolOptions extends SandboxOptions {
     toolCode: string;
     inputs: any;
 }
+/**
+ * Loads environment variables from multiple sources in priority order:
+ * 1. process.env (lowest priority)
+ * 2. .env file (medium priority)
+ * 3. lua.skill.yaml env section (highest priority)
+ */
+export declare function loadEnvironmentVariables(): Record<string, string>;
 /**
  * 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;
-};
+export declare function createSandbox(options: SandboxOptions): any;
 /**
  * Executes a tool in a VM sandbox
  */

package/dist/utils/sandbox.js

@@ -1,21 +1,60 @@
 import { createRequire } from "module";
 import vm from "vm";
 import path from "path";
+import fs from "fs";
 import { UserDataApi } from "../services/api.js";
 import { readSkillConfig } from "./files.js";
 /**
- * Creates a VM sandbox context with all necessary globals and utilities
+ * Loads environment variables from multiple sources in priority order:
+ * 1. process.env (lowest priority)
+ * 2. .env file (medium priority)
+ * 3. lua.skill.yaml env section (highest priority)
  */
-export function createSandbox(options) {
-    const { apiKey, agentId, customConsole, broadcastLog } = options;
-    // Extract environment variables from YAML config
-    const config = readSkillConfig();
+export function loadEnvironmentVariables() {
     const envVars = {};
+    // 1. Start with process.env
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            envVars[key] = value;
+        }
+    }
+    // 2. Load from .env file if it exists
+    const envFilePath = path.join(process.cwd(), '.env');
+    if (fs.existsSync(envFilePath)) {
+        try {
+            const envFileContent = fs.readFileSync(envFilePath, 'utf8');
+            const envLines = envFileContent.split('\n');
+            for (const line of envLines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine && !trimmedLine.startsWith('#')) {
+                    const [key, ...valueParts] = trimmedLine.split('=');
+                    if (key && valueParts.length > 0) {
+                        const value = valueParts.join('=').replace(/^["']|["']$/g, ''); // Remove quotes
+                        envVars[key.trim()] = value;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not read .env file:', error);
+        }
+    }
+    // 3. Override with YAML config values (highest priority)
+    const config = readSkillConfig();
     if (config?.skill?.env) {
         for (const [key, value] of Object.entries(config.skill.env)) {
             envVars[key] = value;
         }
     }
+    return envVars;
+}
+/**
+ * Creates a VM sandbox context with all necessary globals and utilities
+ */
+export function createSandbox(options) {
+    const { apiKey, agentId, customConsole, broadcastLog } = options;
+    // Load environment variables from multiple sources (same logic as test command)
+    const envVars = loadEnvironmentVariables();
     // Create a CommonJS context for execution
     const require = createRequire(process.cwd() + '/package.json');
     const updateUserData = async (data) => {
@@ -29,6 +68,85 @@ export function createSandbox(options) {
     };
     // 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,
@@ -38,19 +156,26 @@ export function createSandbox(options) {
         setInterval,
         clearTimeout,
         clearInterval,
-        process,
+        process: {
+            env: envVars
+        },
         global: globalThis,
         __dirname: process.cwd(),
         __filename: path.join(process.cwd(), 'index.ts'),
         module: { exports: {} },
         exports: {},
-        // Web APIs
+        // 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,
@@ -94,11 +219,32 @@ const executeFunction = ${toolCode};
 
 // Export the function for testing
 module.exports = async (input) => {
+try{
   return await executeFunction(input);
+}catch(e){
+  console.error(e);
+  return { status: 'error', error: e.message };
+}
 };
 `;
     // 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;