lua-cli 3.15.3 → 3.16.0

package/dist/utils/sandbox.js

@@ -1,664 +0,0 @@
-import { createRequire } from 'module';
-import vm from 'vm';
-import path from 'path';
-import { parseEnvFile } from './env-loader.utils.js';
-import UserDataApiService from '../api/user.data.api.service.js';
-import { BASE_URLS } from '../config/constants.js';
-import ProductApiService from '../api/products.api.service.js';
-import BasketApiService from '../api/basket.api.service.js';
-import OrderApiService from '../api/order.api.service.js';
-import CustomDataApiService from '../api/custom.data.api.service.js';
-import WebhookApi from '../api/webhook.api.service.js';
-import JobApi from '../api/job.api.service.js';
-import WhatsAppTemplatesApiService from '../api/whatsapp-templates.api.service.js';
-import CdnApiService from '../api/cdn.api.service.js';
-import { BasketStatus } from '../interfaces/baskets.js';
-import { OrderStatus } from '../interfaces/orders.js';
-import { compressForPush } from './artifact-loader.js';
-import { PRIMITIVE_SHIMS } from '../config/compile.constants.js';
-// Alias for backward compatibility in sandbox context
-const compressCode = compressForPush;
-/**
- * Loads environment variables from multiple sources in priority order:
- * 1. process.env (lowest priority)
- * 2. .env file (overrides process.env)
- */
-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 (using shared parser)
-    const envFilePath = path.join(process.cwd(), '.env');
-    const fileEnvVars = parseEnvFile(envFilePath);
-    // Merge .env file vars (override process.env)
-    Object.assign(envVars, fileEnvVars);
-    return envVars;
-}
-/**
- * Creates a VM sandbox context with all necessary globals and utilities.
- *
- * Available globals in the sandbox:
- * - User: User data API
- * - Products: Product catalog API
- * - Data: Custom data collections API
- * - Baskets: Shopping basket API
- * - Orders: Order management API
- * - Templates: Template APIs (whatsapp)
- * - CDN: File upload/retrieval API
- * - Jobs: Job scheduling API
- * - AI: AI generation API
- * - env(): Environment variable access function
- * - console, fetch, and other standard globals
- */
-/**
- * Injects polyfills into a VM context's global scope.
- * This ensures libraries expecting browser APIs work correctly in the sandbox.
- */
-function injectPolyfillsIntoContext(context) {
-    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;
-      global.File = File;
-      global.Blob = Blob;
-    }
-  `, context);
-}
-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');
-    // Create console object (use custom console if provided, otherwise default)
-    const consoleObj = customConsole || console;
-    // Create API service instances
-    const userService = new UserDataApiService(BASE_URLS.API, apiKey, agentId);
-    const productService = new ProductApiService(BASE_URLS.API, apiKey, agentId);
-    const dataService = new CustomDataApiService(BASE_URLS.API, apiKey, agentId);
-    const basketsService = new BasketApiService(BASE_URLS.API, apiKey, agentId);
-    const orderService = new OrderApiService(BASE_URLS.API, apiKey, agentId);
-    const webhookService = new WebhookApi(BASE_URLS.API, apiKey, agentId);
-    const jobService = new JobApi(BASE_URLS.API, apiKey, agentId);
-    const whatsAppTemplatesService = new WhatsAppTemplatesApiService(BASE_URLS.API, apiKey, agentId);
-    const cdnService = new CdnApiService(BASE_URLS.CDN, apiKey);
-    // Override User service methods if needed
-    // Example: Override the update method
-    // const originalUpdate = userService.update.bind(userService);
-    // userService.update = async (data: any) => {
-    //   console.log('Custom update logic here');
-    //   return await originalUpdate(data);
-    // };
-    // 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,
-        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,
-        File: globalThis.File,
-        Blob: globalThis.Blob,
-        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,
-        // Primitive constructors & define functions (for bundled code with stripped imports)
-        ...PRIMITIVE_SHIMS,
-        Lua: {
-            request: {
-                channel: options.channel ?? 'unknown',
-                webhook: options.webhookPayload ? { payload: options.webhookPayload } : undefined,
-            },
-        },
-        User: userService,
-        Products: productService,
-        Data: dataService,
-        Baskets: basketsService,
-        compressCode: compressCode,
-        Orders: orderService,
-        // Templates API with namespaces for different template types
-        Templates: {
-            whatsapp: whatsAppTemplatesService,
-        },
-        // CDN API
-        CDN: cdnService,
-        // Jobs API
-        Jobs: {
-            create: async (config) => {
-                // Convert execute function to string
-                const executeString = typeof config.execute === 'function' ? config.execute.toString() : config.execute;
-                // Create job with version and activation
-                return await jobService.createJobInstance({
-                    name: config.name + '_' + Date.now(),
-                    description: config.description,
-                    schedule: config.schedule,
-                    timeout: config.timeout,
-                    retry: config.retry,
-                    metadata: config.metadata,
-                    dynamic: true,
-                    version: {
-                        version: '1.0.0',
-                        description: config.description,
-                        code: compressCode(executeString),
-                        timeout: config.timeout,
-                        retry: config.retry,
-                        metadata: config.metadata,
-                    },
-                    activate: config.activate ?? true,
-                });
-            },
-            getJob: async (jobId) => jobService.getJob(jobId),
-            getAll: async (options = {}) => jobService.getAll(options),
-        },
-        // Device API (for sandbox — commands route through lua-api developer endpoint)
-        Device: {
-            sendCommand: async (deviceName, command, payload, timeout) => {
-                const { getDeviceInstance } = await import('../api/lazy-instances.js');
-                const deviceApi = await getDeviceInstance();
-                const response = await deviceApi.sendCommand(deviceName, command, payload, timeout || 30000);
-                if (!response.success)
-                    throw new Error(response.error?.message || 'Device command failed');
-                return response.data;
-            },
-            listDevices: async () => {
-                const { getDeviceInstance } = await import('../api/lazy-instances.js');
-                const deviceApi = await getDeviceInstance();
-                const response = await deviceApi.getDevices();
-                return response.data?.devices || response.data || [];
-            },
-            getStatus: async (deviceName) => {
-                const { getDeviceInstance } = await import('../api/lazy-instances.js');
-                const deviceApi = await getDeviceInstance();
-                const response = await deviceApi.getDeviceStatus(deviceName);
-                return response.data;
-            },
-        },
-        // Environment variables function
-        env: (key) => envVars[key],
-        // Enums for status values
-        BasketStatus: BasketStatus,
-        OrderStatus: OrderStatus,
-        // AI Generation API (proxied to lua-api — isolated Gemini + Google Search; not agent chat)
-        AI: {
-            generate: async (promptOrOptions, content) => {
-                const { getAiInstance } = await import('../api/lazy-instances.js');
-                const ai = await getAiInstance();
-                return ai.generateForSandbox(promptOrOptions, content);
-            },
-        },
-        // Agent invocation API (proxied to lua-core's existing `/chat/generate/:agentId`).
-        // Matches the lua-core in-process `Agents.invoke` sandbox surface so the same
-        // skill/tool/job code runs in both environments.
-        Agents: {
-            invoke: async (targetAgentId, promptOrInput) => {
-                const { getAgentsInstance } = await import('../api/lazy-instances.js');
-                const agents = await getAgentsInstance();
-                return agents.invokeForSandbox(targetAgentId, promptOrInput);
-            },
-        },
-        process: {
-            env: envVars,
-        },
-    };
-    return sandbox;
-}
-/**
- * Executes a tool in a VM sandbox.
- * Supports both new bundled artifact format (dist-v2) and legacy execute function format.
- */
-export async function executeTool(options) {
-    const { toolCode, inputs } = options;
-    // Create sandbox
-    const sandbox = createSandbox(options);
-    // Execute the code in the sandbox
-    const context = vm.createContext(sandbox);
-    injectPolyfillsIntoContext(context);
-    // Check if this is a new bundled artifact (contains __lua_primitive__)
-    const isBundledArtifact = toolCode.includes('__lua_primitive__');
-    if (isBundledArtifact) {
-        // New format: bundled module with primitive export
-        vm.runInContext(toolCode, context);
-        // Get the primitive from the module exports
-        const moduleExports = context.module.exports;
-        const primitive = moduleExports.default?.primitive || moduleExports.primitive;
-        if (!primitive || !primitive.execute) {
-            throw new Error('Tool artifact does not have a valid execute function');
-        }
-        try {
-            return await primitive.execute(inputs);
-        }
-        catch (e) {
-            console.error(e);
-            return { status: 'error', error: e.message };
-        }
-    }
-    else {
-        // Legacy format: raw execute function
-        const commonJsWrapper = `
-const executeFunction = ${toolCode};
-
-module.exports = async (input) => {
-  try {
-    return await executeFunction(input);
-  } catch(e) {
-    console.error(e);
-    return { status: 'error', error: e.message };
-  }
-};
-`;
-        vm.runInContext(commonJsWrapper, context);
-        const executeFunction = context.module.exports;
-        return await executeFunction(inputs);
-    }
-}
-/**
- * Executes a webhook in a sandboxed environment.
- * Supports both new bundled artifact format (dist-v2) and legacy execute function format.
- */
-export async function executeWebhook(options) {
-    const { webhookCode, query, headers, body } = options;
-    // Create sandbox
-    const sandbox = createSandbox(options);
-    // Execute the code in the sandbox
-    const context = vm.createContext(sandbox);
-    injectPolyfillsIntoContext(context);
-    const event = {
-        query: query ?? {},
-        headers: headers ?? {},
-        body,
-        timestamp: new Date().toISOString(),
-    };
-    // Check if this is a new bundled artifact
-    const isBundledArtifact = webhookCode.includes('__lua_primitive__');
-    if (isBundledArtifact) {
-        // New format: bundled module with primitive export
-        vm.runInContext(webhookCode, context);
-        const moduleExports = context.module.exports;
-        const primitive = moduleExports.default?.primitive || moduleExports.primitive;
-        if (!primitive || !primitive.execute) {
-            throw new Error('Webhook artifact does not have a valid execute function');
-        }
-        try {
-            return await primitive.execute(event);
-        }
-        catch (e) {
-            console.error(e);
-            return { status: 'error', error: e.message };
-        }
-    }
-    else {
-        // Legacy format: raw execute function
-        const commonJsWrapper = `
-const executeFunction = ${webhookCode};
-
-module.exports = async (event) => {
-  try {
-    return await executeFunction(event);
-  } catch(e) {
-    console.error(e);
-    return { status: 'error', error: e.message };
-  }
-};
-`;
-        vm.runInContext(commonJsWrapper, context);
-        const executeFunction = context.module.exports;
-        return await executeFunction(event);
-    }
-}
-/**
- * Executes a job in a sandboxed environment.
- * Supports both new bundled artifact format (dist-v2) and legacy execute function format.
- */
-export async function executeJob(options) {
-    const { jobCode, jobData, apiKey, agentId } = options;
-    // Create sandbox
-    const sandbox = createSandbox(options);
-    // Execute the code in the sandbox
-    const context = vm.createContext(sandbox);
-    injectPolyfillsIntoContext(context);
-    // Create job instance
-    let jobInstance = undefined;
-    if (jobData) {
-        jobInstance = {
-            id: jobData.id || jobData.jobId,
-            jobId: jobData.jobId || jobData.id,
-            name: jobData.name,
-            schedule: jobData.schedule,
-            metadata: jobData.metadata || {},
-            data: jobData,
-            updateMetadata: async (newMetadata) => {
-                jobInstance.metadata = { ...jobInstance.metadata, ...newMetadata };
-                console.log('✅ Metadata updated:', jobInstance.metadata);
-            },
-            delete: async () => {
-                console.log('🗑️  Job.delete() called for:', jobInstance.jobId);
-            },
-            toJSON: () => jobData,
-        };
-    }
-    // Check if this is a new bundled artifact
-    const isBundledArtifact = jobCode.includes('__lua_primitive__');
-    if (isBundledArtifact) {
-        // New format: bundled module with primitive export
-        vm.runInContext(jobCode, context);
-        const moduleExports = context.module.exports;
-        const primitive = moduleExports.default?.primitive || moduleExports.primitive;
-        if (!primitive || !primitive.execute) {
-            throw new Error('Job artifact does not have a valid execute function');
-        }
-        try {
-            return await primitive.execute(jobInstance);
-        }
-        catch (e) {
-            console.error(e);
-            return { status: 'error', error: e.message };
-        }
-    }
-    else {
-        // Legacy format: raw execute function
-        const commonJsWrapper = `
-const executeFunction = ${jobCode};
-
-module.exports = async (job) => {
-  try {
-    return await executeFunction(job);
-  } catch(e) {
-    console.error(e);
-    return { status: 'error', error: e.message };
-  }
-};
-`;
-        vm.runInContext(commonJsWrapper, context);
-        const executeFunction = context.module.exports;
-        return await executeFunction(jobInstance);
-    }
-}
-/**
- * Executes a preprocessor in a sandboxed environment.
- * Supports both new bundled artifact format (dist-v2) and legacy execute function format.
- */
-export async function executePreProcessor(options) {
-    const { processorCode, messages, channel, apiKey, agentId } = options;
-    // Create sandbox
-    const sandbox = createSandbox(options);
-    // Get user instance first (outside VM)
-    const UserDataApi = (await import('../api/user.data.api.service.js')).default;
-    const userService = new UserDataApi(BASE_URLS.API, apiKey, agentId);
-    const userInstance = await userService.get();
-    // Execute the code in the sandbox
-    const context = vm.createContext(sandbox);
-    injectPolyfillsIntoContext(context);
-    // Check if this is a new bundled artifact
-    const isBundledArtifact = processorCode.includes('__lua_primitive__');
-    if (isBundledArtifact) {
-        // New format: bundled module with primitive export
-        vm.runInContext(processorCode, context);
-        const moduleExports = context.module.exports;
-        const primitive = moduleExports.default?.primitive || moduleExports.primitive;
-        if (!primitive || !primitive.execute) {
-            throw new Error('PreProcessor artifact does not have a valid execute function');
-        }
-        try {
-            return await primitive.execute(userInstance, messages, channel);
-        }
-        catch (e) {
-            console.error(e);
-            return { status: 'error', error: e.message };
-        }
-    }
-    else {
-        // Legacy format: raw execute function
-        const commonJsWrapper = `
-const executeFunction = ${processorCode};
-
-module.exports = async (input) => {
-  try {
-    return await executeFunction(input.user, input.messages, input.channel);
-  } catch(e) {
-    console.error(e);
-    return { status: 'error', error: e.message };
-  }
-};
-`;
-        vm.runInContext(commonJsWrapper, context);
-        const executeFunction = context.module.exports;
-        return await executeFunction({ user: userInstance, messages, channel });
-    }
-}
-/**
- * Executes a postprocessor in a sandboxed environment.
- * Supports both new bundled artifact format (dist-v2) and legacy execute function format.
- */
-export async function executePostProcessor(options) {
-    const { processorCode, message, response, channel, apiKey, agentId } = options;
-    // Create sandbox
-    const sandbox = createSandbox(options);
-    // Get user instance first (outside VM)
-    const UserDataApi = (await import('../api/user.data.api.service.js')).default;
-    const userService = new UserDataApi(BASE_URLS.API, apiKey, agentId);
-    const userInstance = await userService.get();
-    // Execute the code in the sandbox
-    const context = vm.createContext(sandbox);
-    injectPolyfillsIntoContext(context);
-    // Check if this is a new bundled artifact
-    const isBundledArtifact = processorCode.includes('__lua_primitive__');
-    if (isBundledArtifact) {
-        // New format: bundled module with primitive export
-        vm.runInContext(processorCode, context);
-        const moduleExports = context.module.exports;
-        const primitive = moduleExports.default?.primitive || moduleExports.primitive;
-        if (!primitive || !primitive.execute) {
-            throw new Error('PostProcessor artifact does not have a valid execute function');
-        }
-        try {
-            return await primitive.execute(userInstance, message, response, channel);
-        }
-        catch (e) {
-            console.error(e);
-            return response; // Return original response on error
-        }
-    }
-    else {
-        // Legacy format: raw execute function
-        const commonJsWrapper = `
-const executeFunction = ${processorCode};
-
-module.exports = async (input) => {
-  try {
-    return await executeFunction(input.user, input.message, input.response, input.channel);
-  } catch(e) {
-    console.error(e);
-    return { status: 'error', error: e.message };
-  }
-};
-`;
-        vm.runInContext(commonJsWrapper, context);
-        const executeFunction = context.module.exports;
-        return await executeFunction({ user: userInstance, message, response, channel });
-    }
-}
-/**
- * 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);
-        },
-    };
-}
-//# sourceMappingURL=sandbox.js.map