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

package/dist/utils/bundling.d.ts

@@ -2,8 +2,15 @@
  * Bundling Utilities
  * Handles esbuild bundling of tools and main index
  */
+import { Plugin } from "esbuild";
 import { Project } from "ts-morph";
 import { ToolInfo } from '../interfaces/compile.js';
+/**
+ * esbuild plugin to inject sandbox globals instead of requiring lua-cli
+ * This removes require("lua-cli") statements and injects the global API objects
+ * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
+ */
+export declare const sandboxGlobalsPlugin: Plugin;
 /**
  * Bundles a tool's TypeScript code into a standalone JavaScript file.
  * Uses esbuild to:
@@ -16,7 +23,7 @@ import { ToolInfo } from '../interfaces/compile.js';
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
  */
-export declare function bundleTool(tool: ToolInfo, distDir: string): Promise<void>;
+export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string): Promise<void>;
 /**
  * Bundles the main index.ts file into a standalone JavaScript file.
  * This creates the entry point for the skill.
@@ -57,10 +64,12 @@ export declare function bundlePostProcessor(postprocessor: any, indexFile: any,
  * Extracts execute code and input schema from a tool.
  * This function:
  * 1. Reads the bundled tool code
- * 2. Extracts the execute function
- * 3. Converts Zod schema to JSON Schema format
+ * 2. Detects and bundles any Jobs.create() calls within execute
+ * 3. Extracts the execute function
+ * 4. Converts Zod schema to JSON Schema format
  *
  * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
  * @param project - The ts-morph Project instance for AST analysis
+ * @param distDir - Distribution directory for bundling nested jobs
  */
-export declare function extractExecuteCode(tool: ToolInfo, project: Project): Promise<void>;
+export declare function extractExecuteCode(tool: ToolInfo, project: Project, distDir?: string): Promise<void>;

package/dist/utils/bundling.js

@@ -8,13 +8,34 @@ import { build } from "esbuild";
 import { Project, Node } from "ts-morph";
 import { writeProgress } from "./cli.js";
 import { COMPILE_DIRS, COMPILE_FILES, ESBUILD_TOOL_CONFIG, ESBUILD_INDEX_CONFIG, DEFAULT_INPUT_SCHEMA, } from '../config/compile.constants.js';
-import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema, } from './compile.js';
+import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema } from './compile.js';
+/**
+ * Helper function to remove lua-cli and api-exports imports from source code.
+ * Used when bundling via stdin or temp files where the plugin can't process them.
+ */
+function stripLuaCliImports(sourceCode) {
+    return sourceCode
+        // Remove api-exports imports
+        .replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, '// api-exports imports removed - using sandbox globals')
+        // Remove lua-cli imports
+        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, '// lua-cli imports removed - using sandbox globals')
+        // Remove lua-cli/skill imports (but keep LuaTool, etc. for type checking in temp files)
+        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli\/skill["'];?/g, (match, imports) => {
+        // Keep only LuaTool, LuaWebhook, LuaJob types for temp files
+        const typeImports = imports.split(',')
+            .map((imp) => imp.trim())
+            .filter((imp) => /^(LuaTool|LuaWebhook|LuaJob|LuaPreProcessor|LuaPostProcessor)$/.test(imp));
+        return typeImports.length > 0
+            ? `// lua-cli/skill imports removed - using sandbox globals (types kept for compilation)`
+            : '// lua-cli/skill imports removed - using sandbox globals';
+    });
+}
 /**
  * esbuild plugin to inject sandbox globals instead of requiring lua-cli
  * This removes require("lua-cli") statements and injects the global API objects
  * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
  */
-const sandboxGlobalsPlugin = {
+export const sandboxGlobalsPlugin = {
     name: 'sandbox-globals',
     setup(build) {
         // Only process user files, not node_modules
@@ -24,12 +45,18 @@ const sandboxGlobalsPlugin = {
                 return null;
             }
             const contents = await fs.promises.readFile(args.path, 'utf8');
-            // Only transform files that import from lua-cli
-            if (!contents.includes('lua-cli')) {
+            // Only transform files that import from lua-cli or api-exports
+            if (!contents.includes('lua-cli') && !contents.includes('api-exports')) {
                 return null;
             }
             // Replace lua-cli imports with global references
             let transformedContents = contents;
+            // Replace named imports from api-exports (e.g., ../../../dist/api-exports)
+            // Match: import { Jobs, Products, etc. } from "../../../dist/api-exports"
+            transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, (match, imports) => {
+                // Just remove the import, globals will be available in sandbox
+                return '// api-exports imports removed - using sandbox globals';
+            });
             // Replace named imports from lua-cli
             // Match: import { Products, User, Data, etc. } from "lua-cli"
             transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, (match, imports) => {
@@ -83,12 +110,13 @@ const sandboxGlobalsPlugin = {
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
  */
-export async function bundleTool(tool, distDir) {
+export async function bundleTool(tool, distDir, modifiedSource) {
     writeProgress(`📦 Bundling ${tool.className}...`);
     try {
         const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
         let entryPoint = tool.filePath;
         let tempFile = null;
+        // Note: modifiedSource is handled via stdin below, no temp file needed
         // Check if tool is inline (in index.ts or src/index.ts)
         const isInlineInIndex = tool.filePath.endsWith('index.ts') || tool.filePath.endsWith('index.tsx');
         if (isInlineInIndex) {
@@ -121,12 +149,30 @@ export async function bundleTool(tool, distDir) {
                 entryPoint = tempFile;
             }
         }
-        await build({
-            ...ESBUILD_TOOL_CONFIG,
-            entryPoints: [entryPoint],
-            outfile: outputPath,
-            plugins: [sandboxGlobalsPlugin],
-        });
+        // Use stdin for modified source to preserve import resolution
+        if (modifiedSource && !isInlineInIndex) {
+            // Remove api-exports and lua-cli imports (they're available in sandbox)
+            const transformedSource = stripLuaCliImports(modifiedSource);
+            await build({
+                ...ESBUILD_TOOL_CONFIG,
+                stdin: {
+                    contents: transformedSource,
+                    resolveDir: path.dirname(tool.filePath),
+                    sourcefile: tool.filePath,
+                    loader: 'ts',
+                },
+                outfile: outputPath,
+                plugins: [sandboxGlobalsPlugin],
+            });
+        }
+        else {
+            await build({
+                ...ESBUILD_TOOL_CONFIG,
+                entryPoints: [entryPoint],
+                outfile: outputPath,
+                plugins: [sandboxGlobalsPlugin],
+            });
+        }
         // Wrap the bundled code for VM execution environment
         await wrapToolForVM(outputPath, tool);
         // Clean up temp file if created
@@ -303,10 +349,10 @@ async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDi
     const tempOutput = path.join(tempDir, `${webhookName}-webhook.js`);
     try {
         // Write execute function as a module export
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // Webhook execute function for ${webhookName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         // Bundle with esbuild
         await build({
@@ -323,8 +369,7 @@ export default ${executeFunction};
         // Read bundled code
         let bundledCode = fs.readFileSync(tempOutput, 'utf8');
         // Wrap for webhook VM execution (similar to tools)
-        const wrappedCode = `(async (input) => {
-  const { query, headers, body } = input;
+        const wrappedCode = `(async (query, headers, body) => {
   
   // Execute the bundled webhook code
   ${bundledCode}
@@ -332,8 +377,8 @@ export default ${executeFunction};
   // Get the execute function from exports
   const executeFunction = module.exports.default || module.exports;
   
-  // Execute with proper input structure
-  return await executeFunction({ query, headers, body });
+  // Execute with three separate parameters (not an object)
+  return await executeFunction(query, headers, body);
 })`;
         // Compress the wrapped code
         const compressed = compressCode(wrappedCode);
@@ -472,10 +517,10 @@ async function bundleAndCompressJobCode(executeFunction, jobName, distDir) {
     const tempOutput = path.join(tempDir, `${jobName}-job.js`);
     try {
         // Write execute function as a module export
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // Job execute function for ${jobName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         // Bundle with esbuild
         await build({
@@ -597,7 +642,11 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
             compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir);
         }
         return {
-            ...preprocessor,
+            name: preprocessor.name,
+            version: preprocessor.version,
+            description: preprocessor.description,
+            context: preprocessor.context,
+            async: preprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -675,7 +724,11 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
             compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir);
         }
         return {
-            ...postprocessor,
+            name: postprocessor.name,
+            version: postprocessor.version,
+            description: postprocessor.description,
+            context: postprocessor.context,
+            async: postprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -699,10 +752,10 @@ async function bundleAndCompressProcessorCode(executeFunction, processorName, ty
     try {
         // Processor execute functions receive: (user, message, [response], channel)
         const paramList = type === 'pre' ? 'user, message, channel' : 'user, message, response, channel';
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // ${type === 'pre' ? 'Pre' : 'Post'}Processor execute function for ${processorName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         await build({
             entryPoints: [tempFile],
@@ -751,13 +804,15 @@ export default ${executeFunction};
  * Extracts execute code and input schema from a tool.
  * This function:
  * 1. Reads the bundled tool code
- * 2. Extracts the execute function
- * 3. Converts Zod schema to JSON Schema format
+ * 2. Detects and bundles any Jobs.create() calls within execute
+ * 3. Extracts the execute function
+ * 4. Converts Zod schema to JSON Schema format
  *
  * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
  * @param project - The ts-morph Project instance for AST analysis
+ * @param distDir - Distribution directory for bundling nested jobs
  */
-export async function extractExecuteCode(tool, project) {
+export async function extractExecuteCode(tool, project, distDir) {
     try {
         const toolSourceFile = project.getSourceFile(tool.filePath);
         if (!toolSourceFile) {
@@ -793,6 +848,8 @@ export async function extractExecuteCode(tool, project) {
         }
         // Extract execute code from bundled file
         tool.executeCode = extractExecuteCodeFromBundledFile(tool);
+        // NOTE: Dynamic job bundling moved to source-level processing
+        // Attempting to extract from minified bundled code is too fragile
         // Extract and convert input schema
         tool.inputSchema = await extractInputSchema(classDecl, tool);
     }

package/dist/utils/compile.js

@@ -423,6 +423,7 @@ export function extractPreProcessorsMetadata(indexFile) {
                     let version = '';
                     let description = '';
                     let context = '';
+                    let asyncMode = false;
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const propName = prop.getName();
@@ -439,6 +440,11 @@ export function extractPreProcessorsMetadata(indexFile) {
                             else if (propName === 'context' && value) {
                                 context = value.getText().replace(/['"]/g, '');
                             }
+                            else if (propName === 'async' && value) {
+                                // Properly extract boolean value by checking node kind
+                                const nodeKind = value.getKind();
+                                asyncMode = nodeKind === 110; // TrueKeyword = 110, FalseKeyword = 95
+                            }
                         }
                     });
                     if (name) {
@@ -446,7 +452,8 @@ export function extractPreProcessorsMetadata(indexFile) {
                             name,
                             version: version || '1.0.0',
                             description,
-                            context
+                            context,
+                            async: asyncMode
                         });
                     }
                 }
@@ -472,6 +479,7 @@ export function extractPostProcessorsMetadata(indexFile) {
                     let version = '';
                     let description = '';
                     let context = '';
+                    let asyncMode = false;
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const propName = prop.getName();
@@ -488,6 +496,11 @@ export function extractPostProcessorsMetadata(indexFile) {
                             else if (propName === 'context' && value) {
                                 context = value.getText().replace(/['"]/g, '');
                             }
+                            else if (propName === 'async' && value) {
+                                // Properly extract boolean value by checking node kind
+                                const nodeKind = value.getKind();
+                                asyncMode = nodeKind === 110; // TrueKeyword = 110, FalseKeyword = 95
+                            }
                         }
                     });
                     if (name) {
@@ -495,7 +508,8 @@ export function extractPostProcessorsMetadata(indexFile) {
                             name,
                             version: version || '1.0.0',
                             description,
-                            context
+                            context,
+                            async: asyncMode
                         });
                     }
                 }
@@ -674,10 +688,12 @@ function extractValueFromNode(node) {
     if (Node.isNumericLiteral(node)) {
         return node.getLiteralValue();
     }
-    // Boolean literal
-    if (node.getKind() === 110 || node.getKind() === 95) { // TrueKeyword or FalseKeyword
-        return node.getText() === 'true';
-    }
+    // Boolean literal (TrueKeyword = 110, FalseKeyword = 95)
+    const nodeKind = node.getKind();
+    if (nodeKind === 110)
+        return true; // TrueKeyword
+    if (nodeKind === 95)
+        return false; // FalseKeyword
     // New expression (for tools: [new ToolClass()])
     // Extract just the class name for compatibility with buildSkillsArray
     if (Node.isNewExpression(node)) {
@@ -699,6 +715,11 @@ function extractValueFromNode(node) {
     // Template literal or other complex expressions
     // For persona, context, etc. that might be multiline
     const text = node.getText();
+    // Handle boolean strings (fallback if node kind check didn't catch it)
+    if (text === 'true')
+        return true;
+    if (text === 'false')
+        return false;
     // If it starts with a quote, remove quotes
     if ((text.startsWith('"') && text.endsWith('"')) ||
         (text.startsWith("'") && text.endsWith("'")) ||

package/dist/utils/dev-api.d.ts

@@ -4,7 +4,7 @@
  */
 import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../interfaces/dev.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -13,9 +13,10 @@ import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any): Promise<string | null>;
+export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any, config?: any): Promise<string | null>;
 /**
  * Updates an existing sandbox version.
  *
@@ -59,3 +60,42 @@ export declare function pushSingleSkillToSandbox(apiKey: string, agentId: string
  * @returns Map of skill names to their sandbox IDs
  */
 export declare function pushSkillsToSandbox(apiKey: string, agentId: string, deployData: any, isInitial?: boolean): Promise<SandboxIdsMap>;
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePreProcessorToSandbox(apiKey: string, agentId: string, preprocessorId: string, preprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePostProcessorToSandbox(apiKey: string, agentId: string, postprocessorId: string, postprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export declare function pushProcessorsToSandbox(apiKey: string, agentId: string, config: any, bundledPreProcessors: any[], bundledPostProcessors: any[], isInitial?: boolean): Promise<{
+    preprocessors: number;
+    postprocessors: number;
+}>;

package/dist/utils/dev-api.js

@@ -4,12 +4,14 @@
  */
 import ChatApi from '../api/chat.api.service.js';
 import SkillApi from '../api/skills.api.service.js';
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import PostProcessorApi from '../api/postprocessor.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { writeProgress, writeSuccess } from './cli.js';
 import { loadEnvironmentVariables } from './sandbox.js';
-import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './sandbox-storage.js';
+import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds, getSandboxPreProcessorId, setSandboxPreProcessorId, getSandboxPostProcessorId, setSandboxPostProcessorId } from './sandbox-storage.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -18,9 +20,10 @@ import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './s
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData) {
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData, config) {
     try {
         // Get all sandbox skill IDs for skill override
         const allSkillOverrides = await getAllSandboxSkillIds(deployData);
@@ -31,6 +34,10 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 sandboxId: sandboxId
             }
         ];
+        // Get sandbox processor overrides if config provided
+        const { getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } = await import('./sandbox-storage.js');
+        const preprocessorOverride = config ? await getAllSandboxPreProcessorIds(config) : [];
+        const postprocessorOverride = config ? await getAllSandboxPostProcessorIds(config) : [];
         const chatRequest = {
             messages: [
                 {
@@ -39,7 +46,9 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 }
             ],
             navigate: true,
-            skillOverride: skillOverride
+            skillOverride: skillOverride,
+            preprocessorOverride: preprocessorOverride,
+            postprocessorOverride: postprocessorOverride
         };
         // Add persona override if provided
         if (persona) {
@@ -260,3 +269,167 @@ export async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial
     }
     return sandboxIds;
 }
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessorId, preprocessorData, isInitial = false) {
+    const preprocessorName = preprocessorData.name || 'Unknown PreProcessor';
+    const sandboxPreProcessorId = await getSandboxPreProcessorId(preprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = preprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: preprocessorName,
+        version: sandboxVersion,
+        description: preprocessorData.description,
+        context: preprocessorData.context,
+        code: preprocessorData.code,
+        executeFunction: preprocessorData.executeFunction,
+        async: Boolean(preprocessorData.async ?? false)
+    };
+    if (sandboxPreProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing preprocessor sandbox version...`);
+        }
+        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPreProcessor(preprocessorId, sandboxPreProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update preprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new preprocessor sandbox version...`);
+    }
+    const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPreProcessor(preprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox preprocessor ID
+        await setSandboxPreProcessorId(result.data.versionId, preprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PreProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessorId, postprocessorData, isInitial = false) {
+    const postprocessorName = postprocessorData.name || 'Unknown PostProcessor';
+    const sandboxPostProcessorId = await getSandboxPostProcessorId(postprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = postprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: postprocessorName,
+        version: sandboxVersion,
+        description: postprocessorData.description,
+        context: postprocessorData.context,
+        code: postprocessorData.code,
+        executeFunction: postprocessorData.executeFunction,
+        async: Boolean(postprocessorData.async ?? false)
+    };
+    if (sandboxPostProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing postprocessor sandbox version...`);
+        }
+        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPostProcessor(postprocessorId, sandboxPostProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update postprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new postprocessor sandbox version...`);
+    }
+    const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPostProcessor(postprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox postprocessor ID
+        await setSandboxPostProcessorId(result.data.versionId, postprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PostProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export async function pushProcessorsToSandbox(apiKey, agentId, config, bundledPreProcessors, bundledPostProcessors, isInitial = false) {
+    let preprocessorCount = 0;
+    let postprocessorCount = 0;
+    // Push preprocessors
+    const configPreProcessors = config.preprocessors || [];
+    for (const preprocessor of configPreProcessors) {
+        const bundled = bundledPreProcessors.find(p => p.name === preprocessor.name);
+        if (bundled && bundled.code && preprocessor.preprocessorId) {
+            try {
+                const success = await pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessor.preprocessorId, bundled, isInitial);
+                if (success)
+                    preprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push preprocessor ${preprocessor.name}:`, error);
+            }
+        }
+    }
+    // Push postprocessors
+    const configPostProcessors = config.postprocessors || [];
+    for (const postprocessor of configPostProcessors) {
+        const bundled = bundledPostProcessors.find(p => p.name === postprocessor.name);
+        if (bundled && bundled.code && postprocessor.postprocessorId) {
+            try {
+                const success = await pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessor.postprocessorId, bundled, isInitial);
+                if (success)
+                    postprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push postprocessor ${postprocessor.name}:`, error);
+            }
+        }
+    }
+    return { preprocessors: preprocessorCount, postprocessors: postprocessorCount };
+}

package/dist/utils/dev-server.d.ts

@@ -21,4 +21,4 @@ export interface DevServer {
  * @param port - Port to run server on
  * @returns Server instance with WebSocket and broadcast function
  */
-export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number): DevServer;
+export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number, config?: any): DevServer;