lua-cli 3.0.0-alpha.1 → 3.0.0-alpha.4

package/dist/commands/dev.js

@@ -7,7 +7,7 @@ import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
-import { pushSkillsToSandbox } from '../utils/dev-api.js';
+import { pushSkillsToSandbox, pushProcessorsToSandbox } from '../utils/dev-api.js';
 import { createChatServer } from '../utils/dev-server.js';
 import { createFileWatcher } from '../utils/dev-watcher.js';
 import { readConfigVersion, readDeployJson, extractSkillId, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
@@ -75,6 +75,26 @@ export async function devCommand() {
             process.exit(1);
         }
         writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+        // Step 6b: Push preprocessors and postprocessors to sandbox
+        const fs = await import('fs');
+        const path = await import('path');
+        const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+        const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+        let bundledPreProcessors = [];
+        let bundledPostProcessors = [];
+        if (fs.existsSync(preprocessorsPath)) {
+            bundledPreProcessors = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
+        }
+        if (fs.existsSync(postprocessorsPath)) {
+            bundledPostProcessors = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
+        }
+        if (bundledPreProcessors.length > 0 || bundledPostProcessors.length > 0) {
+            writeProgress("🔄 Pushing processors to sandbox...");
+            const processorCounts = await pushProcessorsToSandbox(apiKey, agentId, updatedConfig, bundledPreProcessors, bundledPostProcessors, true);
+            if (processorCounts.preprocessors > 0 || processorCounts.postprocessors > 0) {
+                writeSuccess(`✅ Pushed ${processorCounts.preprocessors} preprocessor(s) and ${processorCounts.postprocessors} postprocessor(s) to sandbox`);
+            }
+        }
         // Use the first skill's sandbox ID for the web interface
         const firstSkillName = Object.keys(sandboxIds)[0];
         const sandboxSkillId = sandboxIds[firstSkillName];
@@ -83,7 +103,8 @@ export async function devCommand() {
             process.exit(1);
         }
         // Step 7: Start web server for chat interface
-        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, DEV_SERVER_PORT);
+        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, DEV_SERVER_PORT, updatedConfig // Pass config for processor overrides
+        );
         // Step 8: Open browser to chat interface
         try {
             await open(`http://localhost:${DEV_SERVER_PORT}`);

package/dist/commands/push.js

@@ -441,7 +441,7 @@ async function pushWebhookVersion() {
         }
         const result = await response.json();
         writeSuccess(`\n✅ Successfully pushed ${selectedWebhook.name} v${versionToPush}\n`);
-        writeInfo(`📦 Webhook URL: ${BASE_URLS.API}/webhooks/${config.agent.agentId}/${selectedWebhook.webhookId}`);
+        writeInfo(`📦 Webhook URL: ${BASE_URLS.WEBHOOK}/${config.agent.agentId}/${selectedWebhook.webhookId}`);
         // Step 8: Ask if user wants to deploy now
         const deployAnswer = await safePrompt([
             {
@@ -765,7 +765,8 @@ async function pushPreProcessorVersion() {
                 context: bundledData.context || selected.context,
                 preprocessorId: selected.preprocessorId,
                 code: bundledData.code,
-                executeFunction: bundledData.executeFunction
+                executeFunction: bundledData.executeFunction,
+                async: Boolean(bundledData.async ?? false) // Ensure boolean type
             };
             writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
             const api = new PreProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);
@@ -896,7 +897,8 @@ async function pushPostProcessorVersion() {
                 context: bundledData.context || selected.context,
                 postprocessorId: selected.postprocessorId,
                 code: bundledData.code,
-                executeFunction: bundledData.executeFunction
+                executeFunction: bundledData.executeFunction,
+                async: Boolean(bundledData.async ?? false) // Ensure boolean type
             };
             writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
             const api = new PostProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);

package/dist/commands/test.js

@@ -434,15 +434,31 @@ async function testPreProcessor() {
         process.env[key] = value;
     }
     try {
+        // Convert string message to ChatMessage array
+        const messages = [{ type: 'text', text: messageAnswer.message }];
         const result = await executePreProcessor({
             processorCode: preprocessorCode,
-            message: messageAnswer.message,
+            messages: messages, // Pass array instead of string
             channel: channelAnswer.channel,
             apiKey,
             agentId
         });
         writeSuccess("\n✅ PreProcessor execution successful!");
-        console.log(`Processed message: ${result}`);
+        console.log(`\nProcessed messages (${result.length}):`);
+        result.forEach((msg, idx) => {
+            if (msg.type === 'text') {
+                console.log(`  ${idx + 1}. [TEXT] ${msg.text}`);
+            }
+            else if (msg.type === 'image') {
+                console.log(`  ${idx + 1}. [IMAGE] ${msg.mimeType}`);
+            }
+            else if (msg.type === 'file') {
+                console.log(`  ${idx + 1}. [FILE] ${msg.mimeType}`);
+            }
+            else {
+                console.log(`  ${idx + 1}. [${msg.type}]`, msg);
+            }
+        });
     }
     catch (error) {
         console.error("\n❌ PreProcessor execution failed:");

package/dist/common/job.instance.d.ts

@@ -3,6 +3,7 @@
  * Provides a convenient interface for interacting with a job
  */
 import JobApi from '../api/job.api.service.js';
+import UserDataInstance from './user.instance.js';
 /**
  * Job Instance class.
  * Represents a single job with helper methods for common operations.
@@ -38,6 +39,7 @@ export declare class JobInstance {
     readonly jobId: string;
     readonly schedule: any;
     metadata: Record<string, any>;
+    private userApi;
     constructor(jobApi: JobApi, jobData: any);
     /**
      * Gets the full job data.
@@ -70,6 +72,7 @@ export declare class JobInstance {
      * ```
      */
     delete(): Promise<void>;
+    user(): Promise<UserDataInstance>;
     /**
      * Converts the job instance to JSON.
      */

package/dist/common/job.instance.js

@@ -2,6 +2,9 @@
  * Job Instance
  * Provides a convenient interface for interacting with a job
  */
+import UserDataInstance from './user.instance.js';
+import UserDataApi from '../api/user.data.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
 /**
  * Job Instance class.
  * Represents a single job with helper methods for common operations.
@@ -38,6 +41,7 @@ export class JobInstance {
         this.name = jobData.name;
         this.schedule = jobData.schedule;
         this.metadata = jobData.metadata || {};
+        this.userApi = new UserDataApi(BASE_URLS.API, jobApi.apiKey, jobApi.agentId);
     }
     /**
      * Gets the full job data.
@@ -92,6 +96,10 @@ export class JobInstance {
             console.warn(`Job "${this.name}" has versions and was deactivated instead of deleted.`);
         }
     }
+    async user() {
+        const result = await this.userApi.get();
+        return new UserDataInstance(this.userApi, result);
+    }
     /**
      * Converts the job instance to JSON.
      */

package/dist/config/constants.d.ts

@@ -1,11 +1,12 @@
 /**
  * Base URLs for the API, Auth, and Chat - Production
  */
-export declare const BASE_URLS: {
-    readonly API: "http://localhost:3022";
-    readonly AUTH: "https://auth.heylua.ai";
-    readonly CHAT: "http://localhost:3001";
-};
 /**
  * Base URLs for the API, Auth, and Chat - Development
  */
+export declare const BASE_URLS: {
+    readonly API: "https://api.heylua.ai";
+    readonly AUTH: "https://auth.heylua.ai";
+    readonly CHAT: "https://api.heylua.ai";
+    readonly WEBHOOK: "https://webhook.heylua.ai";
+};

package/dist/config/constants.js

@@ -1,16 +1,18 @@
 /**
  * Base URLs for the API, Auth, and Chat - Production
  */
-export const BASE_URLS = {
-    API: 'http://localhost:3022',
-    AUTH: 'https://auth.heylua.ai',
-    CHAT: 'http://localhost:3001',
-};
-/**
- * Base URLs for the API, Auth, and Chat - Development
- */
 // export const BASE_URLS = {
-//   API: 'https://api.heylua.ai',
+//   API: 'http://localhost:3022',
 //   AUTH: 'https://auth.heylua.ai',
-//   CHAT: 'https://api.heylua.ai',
+//   CHAT: 'http://localhost:3001',
+//   WEBHOOK: 'https://webhook.heylua.ai',
 // } as const;
+/**
+ * Base URLs for the API, Auth, and Chat - Development
+ */
+export const BASE_URLS = {
+    API: 'https://api.heylua.ai',
+    AUTH: 'https://auth.heylua.ai',
+    CHAT: 'https://api.heylua.ai',
+    WEBHOOK: 'https://webhook.heylua.ai',
+};

package/dist/interfaces/chat.d.ts

@@ -6,10 +6,21 @@
  * Chat message structure.
  * Currently only supports text messages.
  */
-export interface ChatMessage {
+export type ChatMessage = TextMessage | ImageMessage | FileMessage;
+export interface TextMessage {
     type: 'text';
     text: string;
 }
+export interface ImageMessage {
+    type: 'image';
+    image: string;
+    mimeType: string;
+}
+export interface FileMessage {
+    type: 'file';
+    data: string;
+    mimeType: string;
+}
 /**
  * Skill override for testing specific skill versions.
  * Used in dev mode to override production skills with sandbox versions.
@@ -18,6 +29,22 @@ export interface SkillOverride {
     skillId: string;
     sandboxId: string;
 }
+/**
+ * PreProcessor override for sandbox testing.
+ * Maps production preprocessor ID to sandbox version ID.
+ */
+export interface PreProcessorOverride {
+    preprocessorId: string;
+    sandboxId: string;
+}
+/**
+ * PostProcessor override for sandbox testing.
+ * Maps production postprocessor ID to sandbox version ID.
+ */
+export interface PostProcessorOverride {
+    postprocessorId: string;
+    sandboxId: string;
+}
 /**
  * Chat request payload.
  * Sent to the chat API to start or continue a conversation.
@@ -26,6 +53,8 @@ export interface ChatRequest {
     messages: ChatMessage[];
     navigate: boolean;
     skillOverride: SkillOverride[];
+    preprocessorOverride?: PreProcessorOverride[];
+    postprocessorOverride?: PostProcessorOverride[];
     personaOverride?: string;
     runtimeContext?: string;
 }

package/dist/interfaces/jobs.d.ts

@@ -13,6 +13,27 @@ export interface CreateJobDTO {
     timeout?: number;
     retry?: JobRetryConfig;
     metadata?: Record<string, any>;
+    dynamic?: boolean;
+    /**
+     * Optional initial version data.
+     * If provided, creates the first version automatically.
+     */
+    version?: {
+        version: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        timeout?: number;
+        retry?: JobRetryConfig;
+        metadata?: Record<string, any>;
+    };
+    /**
+     * Auto-publish and activate the job after creation.
+     * If true, the job will be immediately active and running.
+     * Default: false
+     */
+    activate?: boolean;
 }
 /**
  * DTO for pushing a job version

package/dist/types/skill.d.ts

@@ -4,6 +4,7 @@
  */
 import { ZodType } from "zod";
 import UserDataInstance from "../common/user.instance.js";
+import { JobInstance } from "../common/job.instance.js";
 /**
  * Safe environment variable access function.
  * Gets injected at runtime with skill-specific environment variables.
@@ -171,8 +172,11 @@ export interface LuaJobConfig {
     context: string;
     /** Schedule configuration - cron, once, or interval */
     schedule: JobSchedule;
-    /** Function that executes the job logic - receives job instance as parameter */
-    execute: (job?: any) => Promise<any>;
+    /**
+     * Function that executes the job logic.
+     * Receives metadata as parameter for accessing job configuration.
+     */
+    execute: (job: JobInstance) => Promise<any>;
     /** Optional timeout in seconds (default: 300) */
     timeout?: number;
     /** Optional retry configuration */
@@ -180,7 +184,11 @@ export interface LuaJobConfig {
         maxAttempts: number;
         backoffSeconds?: number;
     };
-    /** Optional metadata for the job */
+    /**
+     * Optional metadata for the job.
+     * Can store any custom data (tags, config, context, etc.)
+     * Sent to server and accessible during execution.
+     */
     metadata?: Record<string, any>;
 }
 /**
@@ -309,19 +317,6 @@ export declare class LuaJob {
      * Gets the job metadata.
      */
     getMetadata(): Record<string, any> | undefined;
-    /**
-     * Executes the job.
-     * This is called by the scheduler at the appropriate time.
-     *
-     * @returns Promise resolving to job execution result
-     *
-     * @example
-     * ```typescript
-     * const result = await job.execute();
-     * console.log('Job completed:', result);
-     * ```
-     */
-    execute(): Promise<any>;
 }
 /**
  * Lua Webhook configuration.
@@ -343,11 +338,7 @@ export interface LuaWebhookConfig {
     /** Optional Zod schema for body validation */
     bodySchema?: ZodType;
     /** Function that executes the webhook logic */
-    execute: (input: {
-        query?: any;
-        headers?: any;
-        body?: any;
-    }) => Promise<any>;
+    execute: (query?: any, headers?: any, body?: any) => Promise<any>;
 }
 /**
  * Lua Webhook class.
@@ -380,19 +371,19 @@ export interface LuaWebhookConfig {
  *     email: z.string().email(),
  *     name: z.string()
  *   }),
- *   execute: async ({ query, headers, body }) => {
+ *   execute: async (query, headers, body) => {
  *     // Process the webhook...
  *     console.log('New user:', body.email);
  *     return { success: true, userId: body.userId };
  *   }
  * });
  *
- * // Execute the webhook with validated input
- * const result = await webhook.execute({
- *   query: { source: 'mobile' },
- *   headers: { 'x-api-key': 'secret-key' },
- *   body: { userId: '123', email: 'user@example.com', name: 'John' }
- * });
+ * // Execute the webhook with validated inputs
+ * const result = await webhook.execute(
+ *   { source: 'mobile' },
+ *   { 'x-api-key': 'secret-key' },
+ *   { userId: '123', email: 'user@example.com', name: 'John' }
+ * );
  * ```
  */
 export declare class LuaWebhook {
@@ -439,27 +430,22 @@ export declare class LuaWebhook {
      * Validates query parameters, headers, and body against their respective schemas
      * before executing the webhook function.
      *
-     * @param input - Input object containing query, headers, and/or body
-     * @param input.query - Query parameters object
-     * @param input.headers - Headers object
-     * @param input.body - Request body
+     * @param query - Query parameters object
+     * @param headers - Headers object
+     * @param body - Request body
      * @returns Promise resolving to webhook execution result
      * @throws Error if validation fails for any input
      *
      * @example
      * ```typescript
-     * const result = await webhook.execute({
-     *   query: { limit: '10' },
-     *   headers: { 'x-api-key': 'secret' },
-     *   body: { data: 'value' }
-     * });
+     * const result = await webhook.execute(
+     *   { limit: '10' },
+     *   { 'x-api-key': 'secret' },
+     *   { data: 'value' }
+     * );
      * ```
      */
-    execute(input: {
-        query?: Record<string, any>;
-        headers?: Record<string, any>;
-        body?: any;
-    }): Promise<any>;
+    execute(query?: Record<string, any>, headers?: Record<string, any>, body?: any): Promise<any>;
 }
 /**
  * PreProcessor configuration.
@@ -473,26 +459,45 @@ export interface PreProcessorConfig {
     description: string;
     /** Detailed context for what this preprocessor does */
     context: string;
-    /** Function that processes the message before sending to agent */
-    execute: (user: UserDataInstance, message: string, channel: string) => Promise<string>;
+    /**
+     * Async flag - indicates if processor should run in background on server:
+     * - true: Run asynchronously (non-blocking, for slow operations like API calls)
+     * - false: Run synchronously (blocking, for fast operations like text filtering)
+     * Default: false (synchronous)
+     */
+    async?: boolean;
+    /**
+     * Function that processes messages before sending to agent.
+     * MUST return ChatMessage[] - array of text, image, or file messages.
+     */
+    execute: (user: UserDataInstance, messages: import("../interfaces/chat.js").ChatMessage[], channel: string) => Promise<import("../interfaces/chat.js").ChatMessage[]>;
 }
 /**
  * PreProcessor class.
  * Processes user messages before they reach the agent.
+ * Can handle rich content (text, images, files).
  *
  * @example
  * ```typescript
- * const languageDetector = new PreProcessor({
- *   name: 'language-detector',
+ * const contentFilter = new PreProcessor({
+ *   name: 'content-filter',
  *   version: '1.0.0',
- *   description: 'Detects and translates messages',
- *   context: 'Detects language and translates to English if needed',
- *   execute: async (user, message, channel) => {
- *     const language = await detectLanguage(message);
- *     if (language !== 'en') {
- *       return await translate(message, 'en');
- *     }
- *     return message;
+ *   description: 'Filters and processes message content',
+ *   context: 'Filters spam, validates images, and adds context',
+ *   execute: async (user, messages, channel) => {
+ *     // Process each message
+ *     return messages.map(msg => {
+ *       if (msg.type === 'text') {
+ *         // Filter spam from text
+ *         const filtered = msg.text.replace(/spam/gi, '[filtered]');
+ *         return { type: 'text', text: filtered };
+ *       }
+ *       if (msg.type === 'image') {
+ *         // Could validate image, add watermark, etc.
+ *         return msg;
+ *       }
+ *       return msg;
+ *     });
  *   }
  * });
  * ```
@@ -502,13 +507,15 @@ export declare class PreProcessor {
     private readonly version;
     private readonly description;
     private readonly context;
+    private readonly asyncMode;
     private readonly executeFunction;
     constructor(config: PreProcessorConfig);
     getName(): string;
     getVersion(): string;
     getDescription(): string;
     getContext(): string;
-    execute(user: UserDataInstance, message: string, channel: string): Promise<string>;
+    getAsync(): boolean;
+    execute(user: UserDataInstance, messages: import("../interfaces/chat.js").ChatMessage[], channel: string): Promise<import("../interfaces/chat.js").ChatMessage[]>;
 }
 /**
  * PostProcessor configuration.
@@ -522,7 +529,17 @@ export interface PostProcessorConfig {
     description: string;
     /** Detailed context for what this postprocessor does */
     context: string;
-    /** Function that processes the agent's response before sending to user */
+    /**
+     * Async flag - indicates if processor should run in background on server:
+     * - true: Run asynchronously (non-blocking, for slow operations like API calls, translations)
+     * - false: Run synchronously (blocking, for fast operations like text formatting)
+     * Default: false (synchronous)
+     */
+    async?: boolean;
+    /**
+     * Function that processes the agent's response before sending to user.
+     * MUST return string - the formatted response text.
+     */
     execute: (user: UserDataInstance, message: string, response: string, channel: string) => Promise<string>;
 }
 /**
@@ -547,12 +564,14 @@ export declare class PostProcessor {
     private readonly version;
     private readonly description;
     private readonly context;
+    private readonly asyncMode;
     private readonly executeFunction;
     constructor(config: PostProcessorConfig);
     getName(): string;
     getVersion(): string;
     getDescription(): string;
     getContext(): string;
+    getAsync(): boolean;
     execute(user: UserDataInstance, message: string, response: string, channel: string): Promise<string>;
 }
 /**