lua-cli 2.5.8 → 3.0.0-alpha.4

package/dist/api-exports.js

@@ -26,17 +26,11 @@
  * const products = await Products.search('laptop');
  * ```
  */
-import { LuaSkill, env } from "./types/skill.js";
+import { LuaSkill, LuaWebhook, LuaJob, PreProcessor, PostProcessor, LuaAgent, env } from "./types/skill.js";
 import { BasketStatus } from "./interfaces/baskets.js";
 import { OrderStatus } from "./interfaces/orders.js";
-import { getUserInstance, getDataInstance, getProductsInstance, getBasketsInstance, getOrderInstance, } from "./api/lazy-instances.js";
-// ============================================================================
-// USER DATA API
-// ============================================================================
-/**
- * User Data API
- * Access user information and preferences
- */
+import { getUserInstance, getDataInstance, getProductsInstance, getBasketsInstance, getOrderInstance, getJobInstance, getChatInstance, } from "./api/lazy-instances.js";
+import { JobInstance } from "./common/job.instance.js";
 export const User = {
     /**
      * Retrieves current user data.
@@ -46,6 +40,24 @@ export const User = {
     async get() {
         const instance = await getUserInstance();
         return instance.get();
+    },
+    /**
+     * Gets the chat history for the current user.
+     *
+     * @returns Promise resolving to array of chat messages
+     *
+     * @example
+     * ```typescript
+     * const history = await User.getChatHistory();
+     * // Returns: [
+     * //   { role: 'user', content: [{type: 'text', text: 'hello'}], createdAt: '...', id: '...', threadId: '...' },
+     * //   { role: 'assistant', content: [{type: 'text', text: 'hi'}], createdAt: '...', id: '...', threadId: '...' }
+     * // ]
+     * ```
+     */
+    async getChatHistory() {
+        const instance = await getUserInstance();
+        return instance.getChatHistory();
     }
 };
 // ============================================================================
@@ -158,17 +170,6 @@ export const Products = {
         const instance = await getProductsInstance();
         return instance.create(product);
     },
-    /**
-     * Updates an existing product.
-     *
-     * @param data - Updated product data
-     * @param id - Product ID
-     * @returns Promise resolving to updated product
-     */
-    async update(data, id) {
-        const instance = await getProductsInstance();
-        return instance.update(data, id);
-    },
     /**
      * Deletes a product.
      *
@@ -366,7 +367,180 @@ export const Orders = {
     }
 };
 // ============================================================================
+// JOBS API
+// ============================================================================
+/**
+ * Jobs API
+ * Manage and trigger scheduled jobs from within your tools
+ */
+export const Jobs = {
+    /**
+     * Creates a new job dynamically from within a tool.
+     * This allows tools to schedule one-time or recurring jobs programmatically.
+     *
+     * **What this does:**
+     * The server handles everything in ONE API call:
+     * 1. Creates the job
+     * 2. Creates version 1.0.0 with your execute function
+     * 3. Optionally activates the job (if activate: true)
+     * 4. Returns a JobInstance for manipulation
+     *
+     * @param config - Job configuration
+     * @param config.name - Unique job name
+     * @param config.description - Job description
+     * @param config.schedule - Schedule configuration (cron, once, or interval)
+     * @param config.execute - Async function to execute
+     * @param config.timeout - Optional timeout in seconds
+     * @param config.retry - Optional retry configuration
+     * @param config.metadata - Optional metadata
+     * @returns Promise resolving to JobInstance (already created, versioned, and activated)
+     *
+     * @example
+     * ```typescript
+     * // Create a one-time job to check basket in 3 hours
+     * const job = await Jobs.create({
+     *   name: `check-basket-${basketId}`,
+     *   description: 'Check if basket was abandoned',
+     *   schedule: {
+     *     type: 'once',
+     *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
+     *   },
+     *   metadata: {
+     *     basketId: basketId,
+     *     checkType: 'abandoned-cart'
+     *   },
+     *   execute: async (job, user) => {
+     *     // Access user context and metadata
+     *     console.log('Checking basket for user:', user.name);
+     *     console.log('Basket ID from metadata:', metadata?.basketId);
+     *
+     *     const basket = await Baskets.getById(metadata.basketId);
+     *     if (basket.status === 'active') {
+     *       // Send reminder
+     *     }
+     *     return { checked: true };
+     *   }
+     * });
+     * // Job is now created, versioned as 1.0.0, and activated!
+     * console.log(`Job ${job.jobId} is active: ${job.active}`);
+     * ```
+     */
+    async create(config) {
+        const instance = await getJobInstance();
+        // Convert the execute function to a string
+        const executeString = config.execute.toString();
+        console.log('Creating Job');
+        // Create the job with initial version and activation in one call
+        const createResult = await instance.createJobInstance({
+            dynamic: true,
+            name: config.name,
+            description: config.description,
+            context: config.description || '',
+            schedule: config.schedule,
+            timeout: config.timeout,
+            retry: config.retry,
+            metadata: config.metadata,
+            // Include initial version data for automatic version creation
+            version: {
+                version: '1.0.0',
+                description: config.description,
+                context: config.description || '',
+                code: '', // Will be set by server
+                executeFunction: executeString,
+                timeout: config.timeout,
+                retry: config.retry,
+                metadata: config.metadata
+            },
+            // Activate immediately
+            activate: config.activate ?? true
+        });
+        const jobId = createResult.jobId;
+        // Server has created the job, version, and activated it
+        // Return a JobInstance for easy manipulation
+        return new JobInstance(instance, {
+            id: jobId,
+            jobId: jobId,
+            name: config.name,
+            schedule: config.schedule,
+            metadata: config.metadata || {},
+            active: config.activate ?? true
+        });
+    },
+    /**
+     * Retrieves a job by its unique identifier
+     * @param jobId - The unique identifier of the job to retrieve
+     * @returns Promise resolving to an JobInstance representing the job
+     * @throws Error if the job is not found or the request fails
+     */
+    async getJob(jobId) {
+        const instance = await getJobInstance();
+        return instance.getJob(jobId);
+    }
+};
+// ============================================================================
+// AI GENERATION API
+// ============================================================================
+/**
+ * AI API
+ * Generate AI responses with custom context
+ */
+export const AI = {
+    /**
+     * Generates an AI response with custom runtime context.
+     *
+     * @param context - Runtime context to provide to the AI
+     * @param messages - Array of messages (text, image, file, etc.)
+     * @param agentId - Optional agent ID to use (defaults to current agent)
+     * @returns Promise resolving to AI response text
+     *
+     * @example
+     * ```typescript
+     * // Simple text message with current agent
+     * const response = await AI.generate(
+     *   'You are a helpful sales assistant for our e-commerce store.',
+     *   [{ type: 'text', text: 'What products do you recommend for beginners?' }]
+     * );
+     * console.log(response); // AI-generated recommendation
+     *
+     * // Multiple messages with images
+     * const response2 = await AI.generate(
+     *   'You are an image analysis expert.',
+     *   [
+     *     { type: 'text', text: 'What do you see in this image?' },
+     *     { type: 'image', url: 'https://example.com/image.jpg' }
+     *   ]
+     * );
+     *
+     * // Use a different agent
+     * const response3 = await AI.generate(
+     *   'You are a specialized assistant.',
+     *   [{ type: 'text', text: 'Help me with this task' }],
+     *   'agent_different_123'
+     * );
+     * ```
+     */
+    async generate(context, messages, agentId) {
+        const chatInstance = await getChatInstance();
+        const { getCredentials } = await import('./api/credentials.js');
+        const credentials = await getCredentials();
+        // Use provided agentId or default to current agent
+        const targetAgentId = agentId || 'luaAgent';
+        const result = await chatInstance.sendMessage(targetAgentId, {
+            messages,
+            navigate: false,
+            skillOverride: [],
+            runtimeContext: context
+        });
+        if (!result.success) {
+            throw new Error(result.error?.message || 'AI generation failed');
+        }
+        return result.data?.text || '';
+    }
+};
+// ============================================================================
 // EXPORTS
 // ============================================================================
 // Export skill classes and utilities
-export { LuaSkill, BasketStatus, OrderStatus, env };
+export { LuaSkill, LuaWebhook, LuaJob, PreProcessor, PostProcessor, LuaAgent, BasketStatus, OrderStatus, env };
+// Export instance classes
+export { JobInstance };

package/dist/cli/command-definitions.js

@@ -2,7 +2,7 @@
  * Command Definitions
  * Centralized command structure for the CLI
  */
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, featuresCommand } from "../commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, webhooksCommand, jobsCommand, featuresCommand, preprocessorsCommand, postprocessorsCommand } from "../commands/index.js";
 /**
  * Sets up authentication-related commands.
  *
@@ -53,20 +53,32 @@ export function setupSkillCommands(program) {
         .description("📦 Compile skill to deployable format")
         .action(compileCommand);
     program
-        .command("test")
-        .description("🧪 Test skill tools interactively")
+        .command("test [type]")
+        .description("🧪 Test skills, webhooks, or jobs interactively")
+        .addHelpText('after', `
+Arguments:
+  type                   Optional: 'skill', 'webhook', or 'job' (prompts if not provided)
+
+Examples:
+  $ lua test             Interactive selection
+  $ lua test skill       Test a skill/tool directly
+  $ lua test webhook     Test a webhook with query/headers/body
+  $ lua test job         Test a job by executing it
+`)
         .action(testCommand);
     // Deployment Commands
     program
         .command("push [type]")
-        .description("☁️  Push skill or persona version to server")
+        .description("☁️  Push skill, webhook, job, or persona version to server")
         .addHelpText('after', `
 Arguments:
-  type                   Optional: 'skill' or 'persona' (prompts if not provided)
+  type                   Optional: 'skill', 'webhook', 'job', or 'persona' (prompts if not provided)
 
 Examples:
   $ lua push             Interactive selection
   $ lua push skill       Push a skill directly
+  $ lua push webhook     Push a webhook directly
+  $ lua push job         Push a job directly
   $ lua push persona     Push a persona directly
 `)
         .action(pushCommand);
@@ -160,6 +172,34 @@ Examples:
   $ lua skills production      Manage production skills directly
 `)
         .action(skillsCommand);
+    program
+        .command("webhooks [env]")
+        .description("🪝 Manage and view webhooks")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua webhooks                 Interactive selection
+  $ lua webhooks sandbox         View sandbox webhooks directly
+  $ lua webhooks staging         View staging webhooks (alias for sandbox)
+  $ lua webhooks production      Manage production webhooks directly
+`)
+        .action(webhooksCommand);
+    program
+        .command("jobs [env]")
+        .description("⏰ Manage and view scheduled jobs")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua jobs                     Interactive selection
+  $ lua jobs sandbox             View sandbox jobs directly
+  $ lua jobs staging             View staging jobs (alias for sandbox)
+  $ lua jobs production          Manage production jobs (pause/resume/trigger)
+`)
+        .action(jobsCommand);
     program
         .command("features")
         .description("🎯 Manage agent features (tickets, RAG, etc.)")
@@ -174,6 +214,36 @@ Examples:
   $ lua features               View and manage all agent features
 `)
         .action(featuresCommand);
+    program
+        .command("preprocessors")
+        .description("📥 Manage message preprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed preprocessors
+  • View preprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate preprocessors
+  • Delete preprocessors
+
+Examples:
+  $ lua preprocessors          Manage production preprocessors
+`)
+        .action(preprocessorsCommand);
+    program
+        .command("postprocessors")
+        .description("📤 Manage response postprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed postprocessors
+  • View postprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate postprocessors
+  • Delete postprocessors
+
+Examples:
+  $ lua postprocessors         Manage production postprocessors
+`)
+        .action(postprocessorsCommand);
     program
         .command("completion [shell]")
         .description("🎯 Generate shell completion script")

package/dist/commands/chat.js

@@ -8,8 +8,8 @@ import { loadApiKey, checkApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import { compileCommand } from './compile.js';
-import { pushSkillsToSandbox } from '../utils/dev-api.js';
-import { getAllSandboxSkillIds } from '../utils/sandbox-storage.js';
+import { pushSkillsToSandbox, pushProcessorsToSandbox } from '../utils/dev-api.js';
+import { getAllSandboxSkillIds, getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } from '../utils/sandbox-storage.js';
 import ChatApi from '../api/chat.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { readDeployJson, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
@@ -66,7 +66,7 @@ export async function chatCommand() {
     }, "chat");
 }
 /**
- * Sets up the sandbox environment by compiling and pushing skills
+ * Sets up the sandbox environment by compiling and pushing skills, preprocessors, and postprocessors
  */
 async function setupSandboxEnvironment(chatEnv, config) {
     writeProgress("🔄 Setting up sandbox environment...");
@@ -84,8 +84,31 @@ async function setupSandboxEnvironment(chatEnv, config) {
         process.exit(1);
     }
     writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+    // 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(chatEnv.apiKey, chatEnv.agentId, config, bundledPreProcessors, bundledPostProcessors, true);
+        if (processorCounts.preprocessors > 0 || processorCounts.postprocessors > 0) {
+            writeSuccess(`✅ Pushed ${processorCounts.preprocessors} preprocessor(s) and ${processorCounts.postprocessors} postprocessor(s) to sandbox`);
+        }
+    }
     // Store deploy data for skill overrides
     chatEnv.deployData = deployData;
+    // Get processor overrides for sandbox
+    chatEnv.preprocessorOverrides = await getAllSandboxPreProcessorIds(config);
+    chatEnv.postprocessorOverrides = await getAllSandboxPostProcessorIds(config);
     // Check for persona in config
     if (config.agent?.persona) {
         chatEnv.persona = config.agent.persona;
@@ -198,7 +221,9 @@ async function sendSandboxMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: allSkillOverrides
+        skillOverride: allSkillOverrides,
+        preprocessorOverride: chatEnv.preprocessorOverrides || [],
+        postprocessorOverride: chatEnv.postprocessorOverrides || []
     };
     // Add persona override if available
     if (chatEnv.persona) {
@@ -224,7 +249,9 @@ async function sendProductionMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: []
+        skillOverride: [],
+        preprocessorOverride: [],
+        postprocessorOverride: []
     };
     const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
     const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);

package/dist/commands/compile.js

@@ -6,13 +6,18 @@ import fs from "fs";
 import path from "path";
 import { Project } from "ts-morph";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
-import { findIndexFile } from '../utils/compile.js';
+import { findIndexFile, extractWebhooksMetadata, extractJobsMetadata, extractPreProcessorsMetadata, extractPostProcessorsMetadata } from '../utils/compile.js';
 import { detectTools } from '../utils/tool-detection.js';
-import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
+import { bundleTool, bundleMainIndex, extractExecuteCode, bundleWebhook, bundleJob, bundlePreProcessor, bundlePostProcessor } from '../utils/bundling.js';
 import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
 import { syncYamlWithDeployJson, syncServerSkillsWithYaml } from '../utils/skill-management.js';
+import { ensureWebhooksExistInYaml, syncServerWebhooksWithYaml } from '../utils/webhook-management.js';
+import { ensureJobsExistInYaml, syncServerJobsWithYaml } from '../utils/job-management.js';
+import { ensurePreProcessorsExistInYaml, syncServerPreProcessorsWithYaml } from '../utils/preprocessor-management.js';
+import { ensurePostProcessorsExistInYaml, syncServerPostProcessorsWithYaml } from '../utils/postprocessor-management.js';
 import { readSkillConfig } from '../utils/files.js';
 import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
+import { syncAgentPersonaWithYaml } from '../utils/agent-management.js';
 /**
  * Main compile command - orchestrates the entire skill compilation process.
  *
@@ -49,18 +54,53 @@ export async function compileCommand() {
         const indexPath = findIndexFile();
         const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
-        const tools = await detectTools(indexFile, project);
+        // Step 2a: Check for LuaAgent (unified agent configuration)
+        writeProgress("🔍 Checking for LuaAgent configuration...");
+        const { extractLuaAgentMetadata, resolveLuaAgentReferences, getSkillFilePaths } = await import('../utils/compile.js');
+        const agentMetadata = extractLuaAgentMetadata(indexFile);
+        let skillFilePaths = [];
+        let resolvedAgentData = null;
+        if (agentMetadata) {
+            writeProgress(`✨ Found LuaAgent: ${agentMetadata.name}`);
+            writeProgress(`   Using new unified agent configuration approach`);
+            // Sync persona and welcome message with YAML
+            await syncAgentPersonaWithYaml(agentMetadata);
+            // Resolve references to get actual metadata for all components
+            resolvedAgentData = resolveLuaAgentReferences(agentMetadata, indexFile, project);
+            // Get file paths where skills are defined so we can scan them for tools
+            skillFilePaths = getSkillFilePaths(agentMetadata, indexFile);
+            writeProgress(`📦 Agent contains: ${resolvedAgentData.skills.length} skill(s), ${resolvedAgentData.webhooks.length} webhook(s), ${resolvedAgentData.jobs.length} job(s), ${resolvedAgentData.preProcessors.length} preprocessor(s), ${resolvedAgentData.postProcessors.length} postprocessor(s)`);
+        }
+        else {
+            writeProgress(`ℹ️  No LuaAgent found, using legacy detection for individual components`);
+        }
+        // Step 2b: Detect tools from index file and skill files
+        const tools = await detectTools(indexFile, project, skillFilePaths);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
         // Step 3: Bundle each tool and extract metadata
+        const { preBundleJobsInSource, replaceJobPlaceholders } = await import('../utils/pre-bundle-jobs.js');
         for (const tool of tools) {
-            await bundleTool(tool, distDir);
-            await extractExecuteCode(tool, project);
+            // Step 3a: Pre-bundle any Jobs.create() in the tool source
+            const { modifiedSource, jobBundles } = await preBundleJobsInSource(tool.filePath, project, distDir);
+            // Step 3b: Bundle the tool (with placeholders for job execute functions)
+            await bundleTool(tool, distDir, modifiedSource);
+            // Step 3c: Replace placeholders in the bundled tool file
+            if (jobBundles.size > 0) {
+                const toolBundlePath = path.join(distDir, 'tools', `${tool.className}.js`);
+                if (fs.existsSync(toolBundlePath)) {
+                    let bundledToolCode = fs.readFileSync(toolBundlePath, 'utf8');
+                    bundledToolCode = replaceJobPlaceholders(bundledToolCode, jobBundles);
+                    fs.writeFileSync(toolBundlePath, bundledToolCode);
+                }
+            }
+            // Step 3d: Extract execute code
+            await extractExecuteCode(tool, project, distDir);
         }
         // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);
         // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
-        await createLegacyDeploymentData(tools, luaDir, indexFile);
+        await createLegacyDeploymentData(tools, luaDir, indexFile, resolvedAgentData);
         // Step 6: Sync YAML with deploy.json
         writeProgress("🔄 Syncing YAML with deploy.json...");
         const deployJsonPath = path.join(luaDir, COMPILE_FILES.DEPLOY_JSON);
@@ -70,7 +110,100 @@ export async function compileCommand() {
         writeProgress("🔄 Syncing server with YAML...");
         const updatedConfig = readSkillConfig(); // Re-read config after YAML sync
         await syncServerSkillsWithYaml(updatedConfig);
-        writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
+        // Step 8: Detect and process webhooks
+        writeProgress("🔍 Detecting webhooks...");
+        // Use resolved agent webhooks if available, otherwise scan index file
+        let webhooksMetadata = resolvedAgentData?.webhooks || extractWebhooksMetadata(indexFile);
+        let bundledWebhooks = [];
+        if (webhooksMetadata.length > 0) {
+            writeProgress(`📦 Found ${webhooksMetadata.length} webhook(s)...`);
+            // Bundle each webhook (extract execute function and schemas)
+            for (const webhook of webhooksMetadata) {
+                const bundled = await bundleWebhook(webhook, indexFile, distDir, project);
+                bundledWebhooks.push(bundled);
+            }
+            // Ensure webhooks exist in YAML with valid IDs
+            const configForWebhooks = readSkillConfig(); // Re-read for webhooks
+            await ensureWebhooksExistInYaml(webhooksMetadata, configForWebhooks);
+            // Sync server webhooks with YAML
+            writeProgress("🔄 Syncing server webhooks with YAML...");
+            const webhookConfig = readSkillConfig(); // Re-read after webhook updates
+            await syncServerWebhooksWithYaml(webhookConfig);
+            // Write bundled webhooks to file for reference
+            fs.writeFileSync(path.join(distDir, 'webhooks.json'), JSON.stringify(bundledWebhooks, null, 2));
+        }
+        // Step 9: Detect and process jobs
+        writeProgress("🔍 Detecting jobs...");
+        // Use resolved agent jobs if available, otherwise scan index file
+        let jobsMetadata = resolvedAgentData?.jobs || extractJobsMetadata(indexFile);
+        let bundledJobs = [];
+        if (jobsMetadata.length > 0) {
+            writeProgress(`📦 Found ${jobsMetadata.length} job(s)...`);
+            // Bundle each job (extract execute function)
+            for (const job of jobsMetadata) {
+                const bundled = await bundleJob(job, indexFile, distDir, project);
+                bundledJobs.push(bundled);
+            }
+            // Ensure jobs exist in YAML with valid IDs
+            const configForJobs = readSkillConfig(); // Re-read for jobs
+            await ensureJobsExistInYaml(jobsMetadata, configForJobs);
+            // Sync server jobs with YAML
+            writeProgress("🔄 Syncing server jobs with YAML...");
+            const jobConfig = readSkillConfig(); // Re-read after job updates
+            await syncServerJobsWithYaml(jobConfig);
+            // Write bundled jobs to file for reference
+            fs.writeFileSync(path.join(distDir, 'jobs.json'), JSON.stringify(bundledJobs, null, 2));
+        }
+        // Step 10: Detect and process preprocessors
+        writeProgress("🔍 Detecting preprocessors...");
+        // Use resolved agent preprocessors if available, otherwise scan index file
+        let preprocessorsMetadata = resolvedAgentData?.preProcessors || extractPreProcessorsMetadata(indexFile);
+        let bundledPreProcessors = [];
+        if (preprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${preprocessorsMetadata.length} preprocessor(s)...`);
+            for (const preprocessor of preprocessorsMetadata) {
+                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project);
+                bundledPreProcessors.push(bundled);
+            }
+            // Ensure preprocessors exist in YAML with valid IDs
+            const configForPreProcessors = readSkillConfig();
+            await ensurePreProcessorsExistInYaml(preprocessorsMetadata, configForPreProcessors);
+            // Sync server preprocessors with YAML
+            writeProgress("🔄 Syncing server preprocessors with YAML...");
+            const preprocessorConfig = readSkillConfig();
+            await syncServerPreProcessorsWithYaml(preprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'preprocessors.json'), JSON.stringify(bundledPreProcessors, null, 2));
+        }
+        // Step 11: Detect and process postprocessors
+        writeProgress("🔍 Detecting postprocessors...");
+        // Use resolved agent postprocessors if available, otherwise scan index file
+        let postprocessorsMetadata = resolvedAgentData?.postProcessors || extractPostProcessorsMetadata(indexFile);
+        let bundledPostProcessors = [];
+        if (postprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${postprocessorsMetadata.length} postprocessor(s)...`);
+            for (const postprocessor of postprocessorsMetadata) {
+                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project);
+                bundledPostProcessors.push(bundled);
+            }
+            // Ensure postprocessors exist in YAML with valid IDs
+            const configForPostProcessors = readSkillConfig();
+            await ensurePostProcessorsExistInYaml(postprocessorsMetadata, configForPostProcessors);
+            // Sync server postprocessors with YAML
+            writeProgress("🔄 Syncing server postprocessors with YAML...");
+            const postprocessorConfig = readSkillConfig();
+            await syncServerPostProcessorsWithYaml(postprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'postprocessors.json'), JSON.stringify(bundledPostProcessors, null, 2));
+        }
+        const summaryParts = [`${tools.length} tools bundled`];
+        if (webhooksMetadata.length > 0)
+            summaryParts.push(`${webhooksMetadata.length} webhook(s) registered`);
+        if (jobsMetadata.length > 0)
+            summaryParts.push(`${jobsMetadata.length} job(s) registered`);
+        if (preprocessorsMetadata.length > 0)
+            summaryParts.push(`${preprocessorsMetadata.length} preprocessor(s) registered`);
+        if (postprocessorsMetadata.length > 0)
+            summaryParts.push(`${postprocessorsMetadata.length} postprocessor(s) registered`);
+        writeSuccess(`✅ Skill compiled successfully - ${summaryParts.join(', ')}`);
     }, "compilation");
 }
 /**

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}`);