lua-cli 2.5.8 → 3.0.0-alpha.4

package/dist/utils/preprocessor-management.js

@@ -0,0 +1,118 @@
+/**
+ * PreProcessor Management Utilities
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { SKILL_DEFAULTS, YAML_FORMAT } from '../config/compile.constants.js';
+/**
+ * Ensures all detected preprocessors exist in the YAML config with valid IDs.
+ */
+export async function ensurePreProcessorsExistInYaml(preprocessorsArray, config) {
+    const updatedPreProcessorsArray = [];
+    let yamlUpdated = false;
+    const existingPreProcessors = config?.preprocessors || [];
+    const existingMap = new Map(existingPreProcessors.map((p) => [p.name, p]));
+    for (const preprocessor of preprocessorsArray) {
+        const existing = existingMap.get(preprocessor.name);
+        if (existing && existing.preprocessorId) {
+            updatedPreProcessorsArray.push({
+                ...preprocessor,
+                preprocessorId: existing.preprocessorId
+            });
+        }
+        else {
+            const created = await createPreProcessorViaApi(preprocessor, config, existingPreProcessors, existing);
+            updatedPreProcessorsArray.push(created);
+            yamlUpdated = true;
+        }
+    }
+    if (yamlUpdated) {
+        await updateYamlWithPreProcessors(config);
+    }
+    return updatedPreProcessorsArray;
+}
+async function createPreProcessorViaApi(preprocessor, config, existingPreProcessors, existingPreProcessor) {
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey)
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        const agentId = config?.agent?.agentId;
+        if (!agentId)
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        const payload = {
+            name: preprocessor.name,
+            description: preprocessor.description || `A Lua preprocessor for ${preprocessor.name}`,
+            context: preprocessor.context || ''
+        };
+        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const result = await api.createPreProcessor(payload);
+        if (result.success && result.data && result.data.id) {
+            const newId = result.data.id;
+            if (!existingPreProcessor) {
+                existingPreProcessors.push({
+                    name: preprocessor.name || '',
+                    version: preprocessor.version || SKILL_DEFAULTS.VERSION,
+                    preprocessorId: newId
+                });
+            }
+            else {
+                existingPreProcessor.preprocessorId = newId;
+            }
+            if (!config.preprocessors) {
+                config.preprocessors = existingPreProcessors;
+            }
+            return {
+                ...preprocessor,
+                preprocessorId: newId
+            };
+        }
+        else {
+            throw new Error(result.error?.message || "Failed to create preprocessor");
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not create preprocessor ${preprocessor.name}:`, error);
+        return preprocessor;
+    }
+}
+async function updateYamlWithPreProcessors(config) {
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    const yamlContent = yaml.dump(config, { ...YAML_FORMAT, sortKeys: (a, b) => {
+            const order = ['agent', 'skills', 'webhooks', 'jobs', 'preprocessors', 'postprocessors', 'skill'];
+            const aIndex = order.indexOf(a);
+            const bIndex = order.indexOf(b);
+            if (aIndex !== -1 && bIndex !== -1)
+                return aIndex - bIndex;
+            if (aIndex !== -1)
+                return -1;
+            if (bIndex !== -1)
+                return 1;
+            return a.localeCompare(b);
+        } });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
+export async function syncServerPreProcessorsWithYaml(config) {
+    const messages = [];
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server preprocessor sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found. Skipping server preprocessor sync.");
+            return messages;
+        }
+        // Server sync will be implemented when backend is ready
+        return messages;
+    }
+    catch (error) {
+        console.warn("⚠️  Error syncing preprocessors:", error);
+        return messages;
+    }
+}

package/dist/utils/sandbox-storage.d.ts

@@ -25,3 +25,51 @@ export declare function setSandboxSkillId(sandboxId: string, skillName?: string)
  * @returns Array of skill overrides with skillId and sandboxId pairs
  */
 export declare function getAllSandboxSkillIds(deployData: any): Promise<SkillOverride[]>;
+/**
+ * Retrieves sandbox preprocessor ID from secure storage.
+ *
+ * @param preprocessorName - Preprocessor name
+ * @returns The sandbox preprocessor ID or null if not found
+ */
+export declare function getSandboxPreProcessorId(preprocessorName: string): Promise<string | null>;
+/**
+ * Stores sandbox preprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox preprocessor ID to store
+ * @param preprocessorName - Preprocessor name
+ */
+export declare function setSandboxPreProcessorId(sandboxId: string, preprocessorName: string): Promise<void>;
+/**
+ * Retrieves sandbox postprocessor ID from secure storage.
+ *
+ * @param postprocessorName - Postprocessor name
+ * @returns The sandbox postprocessor ID or null if not found
+ */
+export declare function getSandboxPostProcessorId(postprocessorName: string): Promise<string | null>;
+/**
+ * Stores sandbox postprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox postprocessor ID to store
+ * @param postprocessorName - Postprocessor name
+ */
+export declare function setSandboxPostProcessorId(sandboxId: string, postprocessorName: string): Promise<void>;
+/**
+ * Gets all sandbox preprocessor overrides for the current config.
+ *
+ * @param config - Configuration with preprocessors
+ * @returns Array of preprocessor overrides
+ */
+export declare function getAllSandboxPreProcessorIds(config: any): Promise<Array<{
+    preprocessorId: string;
+    sandboxId: string;
+}>>;
+/**
+ * Gets all sandbox postprocessor overrides for the current config.
+ *
+ * @param config - Configuration with postprocessors
+ * @returns Array of postprocessor overrides
+ */
+export declare function getAllSandboxPostProcessorIds(config: any): Promise<Array<{
+    postprocessorId: string;
+    sandboxId: string;
+}>>;

package/dist/utils/sandbox-storage.js

@@ -69,3 +69,117 @@ export async function getAllSandboxSkillIds(deployData) {
     }
     return skillOverrides;
 }
+/**
+ * Retrieves sandbox preprocessor ID from secure storage.
+ *
+ * @param preprocessorName - Preprocessor name
+ * @returns The sandbox preprocessor ID or null if not found
+ */
+export async function getSandboxPreProcessorId(preprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_preprocessor_${preprocessorName}`;
+        return await keytar.getPassword(SANDBOX_STORAGE.SERVICE, account);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores sandbox preprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox preprocessor ID to store
+ * @param preprocessorName - Preprocessor name
+ */
+export async function setSandboxPreProcessorId(sandboxId, preprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_preprocessor_${preprocessorName}`;
+        await keytar.setPassword(SANDBOX_STORAGE.SERVICE, account, sandboxId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+/**
+ * Retrieves sandbox postprocessor ID from secure storage.
+ *
+ * @param postprocessorName - Postprocessor name
+ * @returns The sandbox postprocessor ID or null if not found
+ */
+export async function getSandboxPostProcessorId(postprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_postprocessor_${postprocessorName}`;
+        return await keytar.getPassword(SANDBOX_STORAGE.SERVICE, account);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores sandbox postprocessor ID in secure storage.
+ *
+ * @param sandboxId - The sandbox postprocessor ID to store
+ * @param postprocessorName - Postprocessor name
+ */
+export async function setSandboxPostProcessorId(sandboxId, postprocessorName) {
+    try {
+        const account = `${SANDBOX_STORAGE.ACCOUNT}_postprocessor_${postprocessorName}`;
+        await keytar.setPassword(SANDBOX_STORAGE.SERVICE, account, sandboxId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+/**
+ * Gets all sandbox preprocessor overrides for the current config.
+ *
+ * @param config - Configuration with preprocessors
+ * @returns Array of preprocessor overrides
+ */
+export async function getAllSandboxPreProcessorIds(config) {
+    const overrides = [];
+    try {
+        const preprocessors = config.preprocessors || [];
+        for (const preprocessor of preprocessors) {
+            if (preprocessor.preprocessorId && preprocessor.name) {
+                const sandboxId = await getSandboxPreProcessorId(preprocessor.name);
+                if (sandboxId) {
+                    overrides.push({
+                        preprocessorId: preprocessor.preprocessorId,
+                        sandboxId: sandboxId
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error getting sandbox preprocessor IDs:', error);
+    }
+    return overrides;
+}
+/**
+ * Gets all sandbox postprocessor overrides for the current config.
+ *
+ * @param config - Configuration with postprocessors
+ * @returns Array of postprocessor overrides
+ */
+export async function getAllSandboxPostProcessorIds(config) {
+    const overrides = [];
+    try {
+        const postprocessors = config.postprocessors || [];
+        for (const postprocessor of postprocessors) {
+            if (postprocessor.postprocessorId && postprocessor.name) {
+                const sandboxId = await getSandboxPostProcessorId(postprocessor.name);
+                if (sandboxId) {
+                    overrides.push({
+                        postprocessorId: postprocessor.postprocessorId,
+                        sandboxId: sandboxId
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error getting sandbox postprocessor IDs:', error);
+    }
+    return overrides;
+}

package/dist/utils/sandbox.d.ts

@@ -8,6 +8,27 @@ export interface ExecuteToolOptions extends SandboxOptions {
     toolCode: string;
     inputs: any;
 }
+export interface ExecuteWebhookOptions extends SandboxOptions {
+    webhookCode: string;
+    query: any;
+    headers: any;
+    body: any;
+}
+export interface ExecuteJobOptions extends SandboxOptions {
+    jobCode: string;
+    jobData?: any;
+}
+export interface ExecutePreProcessorOptions extends SandboxOptions {
+    processorCode: string;
+    messages: any[];
+    channel: string;
+}
+export interface ExecutePostProcessorOptions extends SandboxOptions {
+    processorCode: string;
+    message: string;
+    response: string;
+    channel: string;
+}
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
@@ -16,13 +37,52 @@ export interface ExecuteToolOptions extends SandboxOptions {
  */
 export declare function loadEnvironmentVariables(): Record<string, string>;
 /**
- * Creates a VM sandbox context with all necessary globals and utilities
+ * 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
+ * - Webhooks: Webhook management API (new)
+ * - Jobs: Job scheduling API (new)
+ * - env(): Environment variable access function
+ * - console, fetch, and other standard globals
  */
 export declare function createSandbox(options: SandboxOptions): any;
 /**
  * Executes a tool in a VM sandbox
  */
 export declare function executeTool(options: ExecuteToolOptions): Promise<any>;
+/**
+ * Executes a webhook in a sandboxed environment.
+ *
+ * @param options - Webhook execution options including code and request data
+ * @returns Result from webhook execution
+ */
+export declare function executeWebhook(options: ExecuteWebhookOptions): Promise<any>;
+/**
+ * Executes a job in a sandboxed environment.
+ *
+ * @param options - Job execution options including code and job data
+ * @returns Result from job execution
+ */
+export declare function executeJob(options: ExecuteJobOptions): Promise<any>;
+/**
+ * Executes a preprocessor in a sandboxed environment.
+ *
+ * @param options - PreProcessor execution options
+ * @returns Processed message string
+ */
+export declare function executePreProcessor(options: ExecutePreProcessorOptions): Promise<any[]>;
+/**
+ * Executes a postprocessor in a sandboxed environment.
+ *
+ * @param options - PostProcessor execution options
+ * @returns Processed response string
+ */
+export declare function executePostProcessor(options: ExecutePostProcessorOptions): Promise<string>;
 /**
  * Creates a custom console that broadcasts logs via WebSocket
  */