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

package/dist/commands/push.js

@@ -31,17 +31,34 @@ 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 cmdObj - Commander command object with options
  * @returns Promise that resolves when push completes
  */
-export async function pushCommand(type) {
+export async function pushCommand(type, cmdObj) {
     return withErrorHandling(async () => {
+        // Extract options from Commander command object
+        const options = {
+            force: cmdObj?.force || false,
+            autoDeploy: cmdObj?.autoDeploy || false
+        };
         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 +67,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 +459,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 +783,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 +915,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 +1049,513 @@ 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");
+    if (options.autoDeploy) {
+        writeInfo("🚀 Auto-deploy to production is ENABLED\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'));
+    // Step 3b: Read bundled webhooks and jobs from dist/
+    const webhooksJsonPath = path.join(process.cwd(), 'dist', 'webhooks.json');
+    const jobsJsonPath = path.join(process.cwd(), 'dist', 'jobs.json');
+    const preprocessorsJsonPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+    const postprocessorsJsonPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+    const bundledWebhooks = fs.existsSync(webhooksJsonPath)
+        ? JSON.parse(fs.readFileSync(webhooksJsonPath, 'utf8'))
+        : [];
+    const bundledJobs = fs.existsSync(jobsJsonPath)
+        ? JSON.parse(fs.readFileSync(jobsJsonPath, 'utf8'))
+        : [];
+    const bundledPreprocessors = fs.existsSync(preprocessorsJsonPath)
+        ? JSON.parse(fs.readFileSync(preprocessorsJsonPath, 'utf8'))
+        : [];
+    const bundledPostprocessors = fs.existsSync(postprocessorsJsonPath)
+        ? JSON.parse(fs.readFileSync(postprocessorsJsonPath, 'utf8'))
+        : [];
+    // Track results for both push and deploy
+    const results = {
+        skills: [],
+        webhooks: [],
+        jobs: [],
+        preprocessors: [],
+        postprocessors: []
+    };
+    // Track what needs to be deployed
+    const toDeploySkills = [];
+    const toDeployWebhooks = [];
+    const toDeployJobs = [];
+    const toDeployPreprocessors = [];
+    const toDeployPostprocessors = [];
+    // 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 - use the full skillData with tools
+                const pushResult = await pushVersion(apiKey, agentId, skillId, {
+                    ...skillData, // Include all fields from deploy.json (tools, name, etc.)
+                    version: newVersion, // Override with new version
+                });
+                if (!pushResult.success) {
+                    console.error(`  ❌ Failed to push ${skillConfig.name}:`, pushResult.error?.message);
+                    continue;
+                }
+                // Update YAML with new version
+                updateSkillVersionInYaml(skillConfig.name, newVersion);
+                results.skills.push({ name: skillConfig.name, version: newVersion, skillId });
+                writeSuccess(`  ✅ ${skillConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeploySkills.push({ skillId, version: newVersion, name: skillConfig.name });
+                }
+            }
+            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 = bundledWebhooks.find((w) => w.name === webhookConfig.name);
+                if (!webhookData) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" not found in compiled data, 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`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployWebhooks.push({ webhookId: webhookConfig.webhookId, version: newVersion, name: webhookConfig.name });
+                }
+            }
+            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 = bundledJobs.find((j) => j.name === jobConfig.name);
+                if (!jobData) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" not found in compiled data, 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`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployJobs.push({ jobId: jobConfig.jobId, version: newVersion, name: jobConfig.name });
+                }
+            }
+            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 = bundledPreprocessors.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" not found in compiled data, 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`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployPreprocessors.push({ preprocessorId, version: newVersion, name: processorConfig.name });
+                }
+            }
+            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 = bundledPostprocessors.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" not found in compiled data, 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`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployPostprocessors.push({ postprocessorId, version: newVersion, name: processorConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 9: Deploy all components if autoDeploy is enabled
+    if (options.autoDeploy && (toDeploySkills.length > 0 || toDeployWebhooks.length > 0 || toDeployJobs.length > 0 || toDeployPreprocessors.length > 0 || toDeployPostprocessors.length > 0)) {
+        writeProgress('\n🚀 Deploying all pushed versions to production...');
+        writeInfo('⏱️  Waiting for server to process versions (5 seconds)...\n');
+        // Wait for server to process all pushed versions
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        // Deploy all skills
+        if (toDeploySkills.length > 0) {
+            writeProgress(`📦 Deploying ${toDeploySkills.length} skill(s)...`);
+            for (const skill of toDeploySkills) {
+                const deployed = await retryDeploy(() => publishVersion(apiKey, agentId, skill.skillId, skill.version), skill.name, skill.version, 2 // Only 2 retries since we already waited
+                );
+                if (deployed) {
+                    writeSuccess(`  🚀 ${skill.name} v${skill.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${skill.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all webhooks
+        if (toDeployWebhooks.length > 0) {
+            writeProgress(`🪝 Deploying ${toDeployWebhooks.length} webhook(s)...`);
+            for (const webhook of toDeployWebhooks) {
+                const deployed = await retryDeploy(async () => {
+                    const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhook.webhookId}/${webhook.version}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                }, webhook.name, webhook.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${webhook.name} v${webhook.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${webhook.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all jobs
+        if (toDeployJobs.length > 0) {
+            writeProgress(`⏰ Deploying ${toDeployJobs.length} job(s)...`);
+            for (const job of toDeployJobs) {
+                const deployed = await retryDeploy(async () => {
+                    const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${job.jobId}/${job.version}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                }, job.name, job.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${job.name} v${job.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${job.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all preprocessors
+        if (toDeployPreprocessors.length > 0) {
+            writeProgress(`📥 Deploying ${toDeployPreprocessors.length} preprocessor(s)...`);
+            const preprocessorService = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+            for (const processor of toDeployPreprocessors) {
+                const deployed = await retryDeploy(() => preprocessorService.publishPreProcessorVersion(processor.preprocessorId, processor.version), processor.name, processor.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${processor.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all postprocessors
+        if (toDeployPostprocessors.length > 0) {
+            writeProgress(`📤 Deploying ${toDeployPostprocessors.length} postprocessor(s)...`);
+            const postprocessorService = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+            for (const processor of toDeployPostprocessors) {
+                const deployed = await retryDeploy(() => postprocessorService.publishPostProcessorVersion(processor.postprocessorId, processor.version), processor.name, processor.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${processor.name} deployment failed`);
+                }
+            }
+        }
+    }
+    // Step 10: 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}`;
+}
+/**
+ * Retry deployment with exponential backoff
+ * The server needs time to process pushed versions before they can be deployed
+ */
+async function retryDeploy(deployFn, componentName, version, maxRetries = 3) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const delay = attempt * 2000; // 2s, 4s, 6s (longer delays)
+            await new Promise(resolve => setTimeout(resolve, delay));
+            await deployFn();
+            return true;
+        }
+        catch (error) {
+            if (attempt === maxRetries) {
+                console.error(`    [Retry ${attempt}/${maxRetries}] Deploy failed: ${error.message}`);
+                return false;
+            }
+            // Continue to next retry silently
+        }
+    }
+    return false;
+}

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.
      */