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

package/dist/commands/compile.js

@@ -78,9 +78,23 @@ export async function compileCommand() {
         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);

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.d.ts

@@ -17,7 +17,11 @@
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
- * @param type - Optional type argument ('skill' or 'persona')
+ * @param type - Optional type argument ('skill', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', or 'all')
+ * @param options - Command options (force, autoDeploy)
  * @returns Promise that resolves when push completes
  */
-export declare function pushCommand(type?: string): Promise<void>;
+export declare function pushCommand(type?: string, options?: {
+    force?: boolean;
+    autoDeploy?: boolean;
+}): Promise<void>;

package/dist/commands/push.js

@@ -31,17 +31,29 @@ import PostProcessorApi from '../api/postprocessor.api.service.js';
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
- * @param type - Optional type argument ('skill' or 'persona')
+ * @param type - Optional type argument ('skill', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', or 'all')
+ * @param options - Command options (force, autoDeploy)
  * @returns Promise that resolves when push completes
  */
-export async function pushCommand(type) {
+export async function pushCommand(type, options) {
     return withErrorHandling(async () => {
         let selectedType;
+        // Handle 'all' type with force flag
+        if (type === 'all') {
+            if (!options?.force) {
+                console.error('❌ The "all" type requires the --force flag');
+                console.log('\nUsage:');
+                console.log('  lua push all --force                Push all components without prompts');
+                console.log('  lua push all --force --auto-deploy  Push and deploy all to production');
+                process.exit(1);
+            }
+            return await pushAllCommand(options);
+        }
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
             if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", or "postprocessor".`);
+                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", or "all".`);
                 console.log('\nUsage:');
                 console.log('  lua push                - Interactive selection');
                 console.log('  lua push skill          - Push a skill directly');
@@ -50,6 +62,7 @@ export async function pushCommand(type) {
                 console.log('  lua push job            - Push a job directly');
                 console.log('  lua push preprocessor   - Push a preprocessor directly');
                 console.log('  lua push postprocessor  - Push a postprocessor directly');
+                console.log('  lua push all --force    - Push all components without prompts');
                 process.exit(1);
             }
             selectedType = type;
@@ -441,7 +454,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 +778,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 +910,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);
@@ -1029,3 +1044,394 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
         console.log('💡 You can deploy later using: lua deploy\n');
     }
 }
+/**
+ * Push all command - Pushes all components (skills, webhooks, jobs, processors) without prompts
+ *
+ * This command:
+ * 1. Compiles the project
+ * 2. Reads lua.skill.yaml to get all components
+ * 3. Auto-bumps patch versions
+ * 4. Pushes all components
+ * 5. Optionally auto-deploys to production
+ *
+ * @param options - Command options (force is required, autoDeploy is optional)
+ */
+async function pushAllCommand(options) {
+    writeProgress("🚀 Push All - Pushing all components to server...\n");
+    // Step 1: Compile first
+    writeProgress("📦 Compiling project...");
+    await compileCommand();
+    // Step 2: Load configuration and API key
+    const config = readSkillConfig();
+    if (!config?.agent?.agentId) {
+        console.error('❌ No agent ID found in lua.skill.yaml. Run "lua init" first.');
+        process.exit(1);
+    }
+    const apiKey = await loadApiKey();
+    if (!apiKey) {
+        console.error('❌ No API key found. Run "lua auth configure" first.');
+        process.exit(1);
+    }
+    const agentId = config.agent.agentId; // Validated above, safe to assert
+    // Step 3: Read deploy.json for component data
+    const deployJsonPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployJsonPath)) {
+        console.error('❌ No deploy.json found. Compilation may have failed.');
+        process.exit(1);
+    }
+    const deployData = JSON.parse(fs.readFileSync(deployJsonPath, 'utf8'));
+    // Track results
+    const results = {
+        skills: [],
+        webhooks: [],
+        jobs: [],
+        preprocessors: [],
+        postprocessors: []
+    };
+    // Step 4: Push all skills
+    if (config.skills && config.skills.length > 0) {
+        writeProgress(`\n📦 Pushing ${config.skills.length} skill(s)...`);
+        for (const skillConfig of config.skills) {
+            try {
+                const skillData = deployData.skills.find((s) => s.name === skillConfig.name);
+                if (!skillData) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate skillId and version exist
+                const skillId = skillConfig.skillId;
+                const currentVersion = skillConfig.version;
+                if (!skillId) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no skillId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${skillConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Push version
+                const pushResult = await pushVersion(apiKey, agentId, skillId, {
+                    version: newVersion,
+                    description: skillConfig.description || '',
+                    context: skillConfig.context || '',
+                    code: skillData.code,
+                    executeFunction: skillData.executeFunction,
+                    inputSchema: skillData.inputSchema,
+                    outputSchema: skillData.outputSchema,
+                });
+                // Update YAML with new version
+                updateSkillVersionInYaml(skillConfig.name, newVersion);
+                results.skills.push({ name: skillConfig.name, version: newVersion, skillId });
+                writeSuccess(`  ✅ ${skillConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    await publishVersion(apiKey, agentId, skillId, newVersion);
+                    writeSuccess(`  🚀 ${skillConfig.name} v${newVersion} deployed to production`);
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${skillConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 5: Push all webhooks
+    if (config.webhooks && config.webhooks.length > 0) {
+        writeProgress(`\n🪝 Pushing ${config.webhooks.length} webhook(s)...`);
+        for (const webhookConfig of config.webhooks) {
+            try {
+                const webhookData = deployData.webhooks?.find((w) => w.name === webhookConfig.name);
+                if (!webhookData) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate webhookId and version exist
+                if (!webhookConfig.webhookId) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no webhookId, skipping`);
+                    continue;
+                }
+                if (!webhookConfig.version) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(webhookConfig.version);
+                writeInfo(`  📝 ${webhookConfig.name}: ${webhookConfig.version} → ${newVersion}`);
+                // Prepare webhook data for push
+                const pushData = {
+                    name: webhookConfig.name,
+                    version: newVersion,
+                    description: webhookData.description || webhookConfig.description || '',
+                    context: webhookData.context || webhookConfig.context || '',
+                    webhookId: webhookConfig.webhookId,
+                    querySchema: webhookData.querySchema,
+                    headerSchema: webhookData.headerSchema,
+                    bodySchema: webhookData.bodySchema,
+                    code: webhookData.code,
+                    executeFunction: webhookData.executeFunction
+                };
+                // Push version using fetch (like existing webhook push)
+                const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhookConfig.webhookId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateWebhookVersionInYaml(webhookConfig.name, newVersion);
+                results.webhooks.push({ name: webhookConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${webhookConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResponse = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhookConfig.webhookId}/${newVersion}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (deployResponse.ok) {
+                        writeSuccess(`  🚀 ${webhookConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${webhookConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 6: Push all jobs
+    if (config.jobs && config.jobs.length > 0) {
+        writeProgress(`\n⏰ Pushing ${config.jobs.length} job(s)...`);
+        for (const jobConfig of config.jobs) {
+            try {
+                const jobData = deployData.jobs?.find((j) => j.name === jobConfig.name);
+                if (!jobData) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate jobId and version exist
+                if (!jobConfig.jobId) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no jobId, skipping`);
+                    continue;
+                }
+                if (!jobConfig.version) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(jobConfig.version);
+                writeInfo(`  📝 ${jobConfig.name}: ${jobConfig.version} → ${newVersion}`);
+                // Prepare job data for push
+                const pushData = {
+                    name: jobConfig.name,
+                    version: newVersion,
+                    description: jobData.description || jobConfig.description || '',
+                    context: jobData.context || jobConfig.context || '',
+                    jobId: jobConfig.jobId,
+                    schedule: jobData.schedule || jobConfig.schedule,
+                    timeout: jobData.timeout,
+                    retry: jobData.retry,
+                    code: jobData.code,
+                    executeFunction: jobData.executeFunction,
+                    metadata: jobData.metadata || jobConfig.metadata
+                };
+                // Push version using fetch
+                const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateJobVersionInYaml(jobConfig.name, newVersion);
+                results.jobs.push({ name: jobConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${jobConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResponse = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/${newVersion}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (deployResponse.ok) {
+                        writeSuccess(`  🚀 ${jobConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${jobConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 7: Push all preprocessors
+    if (config.preprocessors && config.preprocessors.length > 0) {
+        writeProgress(`\n📥 Pushing ${config.preprocessors.length} preprocessor(s)...`);
+        const preprocessorService = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.preprocessors) {
+            try {
+                const processorData = deployData.preprocessors?.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate preprocessorId and version exist
+                const preprocessorId = processorConfig.preprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!preprocessorId) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no preprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    preprocessorId: preprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await preprocessorService.pushPreProcessor(preprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push preprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('preprocessors', processorConfig.name, newVersion);
+                results.preprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResult = await preprocessorService.publishPreProcessorVersion(preprocessorId, newVersion);
+                    if (deployResult.success) {
+                        writeSuccess(`  🚀 ${processorConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 8: Push all postprocessors
+    if (config.postprocessors && config.postprocessors.length > 0) {
+        writeProgress(`\n📤 Pushing ${config.postprocessors.length} postprocessor(s)...`);
+        const postprocessorService = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.postprocessors) {
+            try {
+                const processorData = deployData.postprocessors?.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate postprocessorId and version exist
+                const postprocessorId = processorConfig.postprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!postprocessorId) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no postprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    postprocessorId: postprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await postprocessorService.pushPostProcessor(postprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push postprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('postprocessors', processorConfig.name, newVersion);
+                results.postprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResult = await postprocessorService.publishPostProcessorVersion(postprocessorId, newVersion);
+                    if (deployResult.success) {
+                        writeSuccess(`  🚀 ${processorConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 9: Print summary
+    writeSuccess('\n✅ Push All Complete!\n');
+    if (results.skills.length > 0) {
+        console.log(`🛠️  Skills (${results.skills.length}):`);
+        results.skills.forEach(s => console.log(`   • ${s.name} v${s.version}`));
+    }
+    if (results.webhooks.length > 0) {
+        console.log(`🪝 Webhooks (${results.webhooks.length}):`);
+        results.webhooks.forEach(w => console.log(`   • ${w.name} v${w.version}`));
+    }
+    if (results.jobs.length > 0) {
+        console.log(`⏰ Jobs (${results.jobs.length}):`);
+        results.jobs.forEach(j => console.log(`   • ${j.name} v${j.version}`));
+    }
+    if (results.preprocessors.length > 0) {
+        console.log(`📥 PreProcessors (${results.preprocessors.length}):`);
+        results.preprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (results.postprocessors.length > 0) {
+        console.log(`📤 PostProcessors (${results.postprocessors.length}):`);
+        results.postprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (options.autoDeploy) {
+        writeSuccess('\n🚀 All components deployed to production!');
+    }
+    console.log('');
+}
+/**
+ * Bumps the patch version of a semantic version string
+ * e.g., "1.2.3" -> "1.2.4"
+ */
+function bumpPatchVersion(version) {
+    const parts = version.split('.');
+    if (parts.length !== 3) {
+        // If not a valid semver, just return incremented version
+        return version + '.1';
+    }
+    const [major, minor, patch] = parts;
+    const newPatch = parseInt(patch, 10) + 1;
+    return `${major}.${minor}.${newPatch}`;
+}

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";
+};