lua-cli 3.5.0-alpha.1 → 3.5.0-alpha.3

package/dist/commands/push.js

@@ -17,6 +17,9 @@ import { BASE_URLS } from '../config/constants.js';
 import PreProcessorApi from '../api/preprocessor.api.service.js';
 import PostProcessorApi from '../api/postprocessor.api.service.js';
 import DeveloperApi from '../api/developer.api.service.js';
+import JobApi from '../api/job.api.service.js';
+import WebhookApi from '../api/webhook.api.service.js';
+import PersonaApi from '../api/persona.api.service.js';
 import { loadPersonaFromCode } from '../utils/agent-code-utils.js';
 // ============================================================================
 // Core Push Helpers (shared by all push functions)
@@ -85,6 +88,7 @@ async function selectEntityOrFail(items, options, config) {
  * Validates semantic versioning format
  */
 async function resolveVersionOrFail(currentVersion, options) {
+    // If version explicitly provided, use it
     if (options.version) {
         if (!/^\d+\.\d+\.\d+/.test(options.version)) {
             console.log(`❌ Invalid version format: "${options.version}". Use semantic versioning (e.g., 1.0.5)`);
@@ -93,6 +97,13 @@ async function resolveVersionOrFail(currentVersion, options) {
         writeInfo(`📝 Using version: ${options.version}`);
         return options.version;
     }
+    // If force flag provided, auto-bump without prompting
+    if (options.force) {
+        const newVersion = bumpPatchVersion(currentVersion);
+        writeInfo(`📝 Auto-bumping version: ${currentVersion} → ${newVersion}`);
+        return newVersion;
+    }
+    // Otherwise, prompt interactively
     return await promptVersionConfirmOrUpdate(currentVersion);
 }
 /**
@@ -303,7 +314,7 @@ async function pushSkillVersion(options = {}) {
         }
         // Step 8: Deploy if requested
         if (await shouldDeployAfterPush(options)) {
-            await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
+            await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion, options.autoDeploy || false);
         }
     }
     else if (result.error) {
@@ -369,24 +380,16 @@ async function pushPersonaVersion(options = {}) {
     // Step 5: Push persona version to server
     writeProgress("🔄 Creating persona version...");
     try {
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${config.agent.agentId}/persona/version`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ persona: currentPersona })
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`HTTP error! status: ${response.status}, ${errorText}`);
+        const personaApi = new PersonaApi(BASE_URLS.API, apiKey, config.agent.agentId);
+        const result = await personaApi.createVersion(currentPersona);
+        if (!result.success || !result.data) {
+            throw new Error(result.error?.message || 'Failed to create persona version');
         }
-        const data = await response.json();
-        const versionNum = data.version || data.data?.version || 'N/A';
+        const versionNum = result.data.version;
         writeSuccess(`✅ Persona version ${versionNum} created successfully`);
         // Step 6: Deploy if requested
         if (await shouldDeployAfterPush(options)) {
-            await deployPersonaVersionAfterPush(apiKey, config.agent.agentId, versionNum);
+            await deployPersonaVersionAfterPush(apiKey, config.agent.agentId, versionNum, options.autoDeploy || false);
         }
         else {
             writeInfo("💡 You can deploy this version later using: lua deploy");
@@ -400,36 +403,32 @@ async function pushPersonaVersion(options = {}) {
 /**
  * Deploy a persona version immediately after pushing
  */
-async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum) {
+async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipConfirmation = false) {
     try {
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy this persona version?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy this persona version?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Persona version created but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Persona version created but not deployed.\n");
-            return;
         }
         writeProgress("🔄 Deploying persona version...");
-        const deployResponse = await fetch(`${BASE_URLS.API}/developer/agents/${agentId}/persona/version/${versionNum}`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({})
-        });
-        if (!deployResponse.ok) {
-            const errorText = await deployResponse.text();
-            console.error(`\n❌ Deploy Error: ${deployResponse.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${deployResponse.status}`);
+        const personaApi = new PersonaApi(BASE_URLS.API, apiKey, agentId);
+        const deployResult = await personaApi.deployVersion(versionNum);
+        if (!deployResult.success) {
+            console.error(`\n❌ Deploy Error: ${deployResult.error?.message || 'Unknown error'}\n`);
+            throw new Error(deployResult.error?.message || 'Failed to deploy persona version');
         }
         writeSuccess(`\n✅ Persona version ${versionNum} deployed successfully to production\n`);
         writeInfo("💡 The new persona is now active for all users.");
@@ -497,26 +496,18 @@ async function pushWebhookVersion(options = {}) {
             executeFunction: bundledWebhookData.executeFunction
         };
         writeProgress(`\n🚀 Pushing ${selectedWebhook.name} v${confirmedVersion} to server...`);
-        const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${config.agent.agentId}/${selectedWebhook.webhookId}/version`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(webhookData)
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.log(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${response.status}`);
+        const webhookApi = new WebhookApi(BASE_URLS.API, apiKey, config.agent.agentId);
+        const result = await webhookApi.pushWebhook(selectedWebhook.webhookId, webhookData);
+        if (!result.success) {
+            console.log(`\n❌ Push Error: ${result.error?.message || 'Unknown error'}\n`);
+            throw new Error(result.error?.message || 'Failed to push webhook');
         }
-        await response.json();
         writeSuccess(`\n✅ Successfully pushed ${selectedWebhook.name} v${confirmedVersion}\n`);
         writeInfo(`📦 Webhook URL (id):   ${BASE_URLS.WEBHOOK}/${config.agent.agentId}/${selectedWebhook.webhookId}`);
         writeInfo(`🔗 Webhook URL (name): ${BASE_URLS.WEBHOOK}/${config.agent.agentId}/${selectedWebhook.name}`);
         // Step 8: Deploy if requested
         if (await shouldDeployAfterPush(options)) {
-            await deployWebhookVersionAfterPush(apiKey, config.agent.agentId, selectedWebhook, confirmedVersion);
+            await deployWebhookVersionAfterPush(apiKey, config.agent.agentId, selectedWebhook, confirmedVersion, options.autoDeploy || false);
         }
         else {
             writeInfo("💡 You can deploy this version later using: lua webhooks production");
@@ -530,36 +521,32 @@ async function pushWebhookVersion(options = {}) {
 /**
  * Deploy a webhook version immediately after pushing
  */
-async function deployWebhookVersionAfterPush(apiKey, agentId, selectedWebhook, pushedVersion) {
+async function deployWebhookVersionAfterPush(apiKey, agentId, selectedWebhook, pushedVersion, skipConfirmation = false) {
     try {
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-            return;
         }
         writeProgress("🔄 Publishing webhook version...");
-        const publishResponse = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${selectedWebhook.webhookId}/${pushedVersion}/publish`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({})
-        });
-        if (!publishResponse.ok) {
-            const errorText = await publishResponse.text();
-            console.error(`\n❌ Deploy Error: ${publishResponse.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${publishResponse.status}`);
+        const webhookApi = new WebhookApi(BASE_URLS.API, apiKey, agentId);
+        const publishResult = await webhookApi.publishWebhookVersion(selectedWebhook.webhookId, pushedVersion);
+        if (!publishResult.success) {
+            console.error(`\n❌ Deploy Error: ${publishResult.error?.message || 'Unknown error'}\n`);
+            throw new Error(publishResult.error?.message || 'Failed to publish webhook version');
         }
         writeSuccess(`\n✅ Webhook ${selectedWebhook.name} v${pushedVersion} deployed successfully to production\n`);
         writeInfo("💡 The new webhook version is now active for all users.");
@@ -659,23 +646,16 @@ async function pushJobVersion(options = {}) {
             metadata: bundledJobData.metadata || selectedJob.metadata
         };
         writeProgress(`\n🚀 Pushing ${selectedJob.name} v${confirmedVersion} to server...`);
-        const response = await fetch(`${BASE_URLS.API}/developer/jobs/${config.agent.agentId}/${selectedJob.jobId}/version`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(jobData)
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.log(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${response.status}`);
+        const jobApi = new JobApi(BASE_URLS.API, apiKey, config.agent.agentId);
+        const result = await jobApi.pushJob(selectedJob.jobId, jobData);
+        if (!result.success) {
+            console.log(`\n❌ Push Error: ${result.error?.message || 'Unknown error'}\n`);
+            throw new Error(result.error?.message || 'Failed to push job');
         }
         writeSuccess(`\n✅ Successfully pushed ${selectedJob.name} v${confirmedVersion}\n`);
         // Step 8: Deploy if requested
         if (await shouldDeployAfterPush(options)) {
-            await deployJobVersionAfterPush(apiKey, config.agent.agentId, selectedJob, confirmedVersion);
+            await deployJobVersionAfterPush(apiKey, config.agent.agentId, selectedJob, confirmedVersion, options.autoDeploy || false);
         }
         else {
             writeInfo("💡 You can deploy this version later using: lua jobs production");
@@ -689,36 +669,32 @@ async function pushJobVersion(options = {}) {
 /**
  * Deploy a job version immediately after pushing
  */
-async function deployJobVersionAfterPush(apiKey, agentId, selectedJob, pushedVersion) {
+async function deployJobVersionAfterPush(apiKey, agentId, selectedJob, pushedVersion, skipConfirmation = false) {
     try {
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-            return;
         }
         writeProgress("🔄 Publishing job version...");
-        const publishResponse = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${selectedJob.jobId}/${pushedVersion}/publish`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({})
-        });
-        if (!publishResponse.ok) {
-            const errorText = await publishResponse.text();
-            console.error(`\n❌ Deploy Error: ${publishResponse.status} - ${errorText}\n`);
-            throw new Error(`HTTP error! status: ${publishResponse.status}`);
+        const jobApi = new JobApi(BASE_URLS.API, apiKey, agentId);
+        const publishResult = await jobApi.publishJobVersion(selectedJob.jobId, pushedVersion);
+        if (!publishResult.success) {
+            console.error(`\n❌ Deploy Error: ${publishResult.error?.message || 'Unknown error'}\n`);
+            throw new Error(publishResult.error?.message || 'Failed to publish job version');
         }
         writeSuccess(`\n✅ Job ${selectedJob.name} v${pushedVersion} deployed successfully to production\n`);
         writeInfo("💡 The new job version is now active and will run on schedule.");
@@ -784,7 +760,7 @@ async function pushPreProcessorVersion(options = {}) {
             writeSuccess(`\n✅ PreProcessor "${selected.name}" v${confirmedVersion} pushed successfully\n`);
             // Step 8: Deploy if requested
             if (await shouldDeployAfterPush(options)) {
-                await deployPreProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion);
+                await deployPreProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion, options.autoDeploy || false);
             }
             else {
                 writeInfo("💡 You can deploy this version later using: lua preprocessors production");
@@ -802,22 +778,25 @@ async function pushPreProcessorVersion(options = {}) {
 /**
  * Deploy a preprocessor version immediately after pushing
  */
-async function deployPreProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion) {
+async function deployPreProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion, skipConfirmation = false) {
     try {
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-            return;
         }
         writeProgress("🔄 Publishing preprocessor version...");
         const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
@@ -889,7 +868,7 @@ async function pushPostProcessorVersion(options = {}) {
             writeSuccess(`\n✅ PostProcessor "${selected.name}" v${confirmedVersion} pushed successfully\n`);
             // Step 8: Deploy if requested
             if (await shouldDeployAfterPush(options)) {
-                await deployPostProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion);
+                await deployPostProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion, options.autoDeploy || false);
             }
             else {
                 writeInfo("💡 You can deploy this version later using: lua postprocessors production");
@@ -907,22 +886,25 @@ async function pushPostProcessorVersion(options = {}) {
 /**
  * Deploy a postprocessor version immediately after pushing
  */
-async function deployPostProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion) {
+async function deployPostProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion, skipConfirmation = false) {
     try {
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-            return;
         }
         writeProgress("🔄 Publishing postprocessor version...");
         const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
@@ -1083,7 +1065,7 @@ async function pushMCPServerVersion(options = {}) {
 /**
  * Deploy a version immediately after pushing
  */
-async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVersion) {
+async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVersion, skipConfirmation = false) {
     try {
         writeProgress("\n🔄 Fetching available versions...");
         // Fetch versions to verify the pushed version exists
@@ -1092,20 +1074,23 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
             console.error("❌ No versions available. The push may have failed.");
             return;
         }
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy?',
-                default: false
+        // Skip confirmation when called from auto-deploy with --force
+        if (!skipConfirmation) {
+            // Show warning
+            console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+            console.log("⚠️  This will affect ALL users immediately.\n");
+            const confirmAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to deploy?',
+                    default: false
+                }
+            ]);
+            if (!confirmAnswer || !confirmAnswer.confirm) {
+                console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+                return;
             }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
-            return;
         }
         // Find the pushed version in the list
         const versionToDeploy = versionsResponse.versions.find((v) => v.version === pushedVersion);
@@ -1276,17 +1261,11 @@ async function pushAllCommand(options) {
                     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()}`);
+                // Push version using WebhookApi
+                const webhookApi = new WebhookApi(BASE_URLS.API, apiKey, agentId);
+                const result = await webhookApi.pushWebhook(webhookConfig.webhookId, pushData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push webhook');
                 }
                 // Update YAML
                 updateWebhookVersionInYaml(webhookConfig.name, newVersion);
@@ -1337,17 +1316,11 @@ async function pushAllCommand(options) {
                     executeFunction: jobData.executeFunction,
                     metadata: jobData.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()}`);
+                // Push version using JobApi
+                const jobApi = new JobApi(BASE_URLS.API, apiKey, agentId);
+                const result = await jobApi.pushJob(jobConfig.jobId, pushData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push job');
                 }
                 // Update YAML
                 updateJobVersionInYaml(jobConfig.name, newVersion);
@@ -1532,19 +1505,15 @@ async function pushAllCommand(options) {
         // Deploy all webhooks
         if (toDeployWebhooks.length > 0) {
             writeProgress(`🪝 Deploying ${toDeployWebhooks.length} webhook(s)...`);
+            const webhookService = new WebhookApi(BASE_URLS.API, apiKey, agentId);
             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}`);
+                    const result = await webhookService.publishWebhookVersion(webhook.webhookId, webhook.version);
+                    if (!result.success) {
+                        throw new Error(result.error?.message || 'Failed to publish webhook');
                     }
-                }, webhook.name, webhook.version, 2);
+                    return result;
+                }, webhook.name, webhook.version, 3);
                 if (deployed) {
                     writeSuccess(`  🚀 ${webhook.name} v${webhook.version} deployed`);
                 }
@@ -1556,19 +1525,15 @@ async function pushAllCommand(options) {
         // Deploy all jobs
         if (toDeployJobs.length > 0) {
             writeProgress(`⏰ Deploying ${toDeployJobs.length} job(s)...`);
+            const jobService = new JobApi(BASE_URLS.API, apiKey, agentId);
             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}`);
+                    const result = await jobService.publishJobVersion(job.jobId, job.version);
+                    if (!result.success) {
+                        throw new Error(result.error?.message || 'Failed to publish job');
                     }
-                }, job.name, job.version, 2);
+                    return result;
+                }, job.name, job.version, 3);
                 if (deployed) {
                     writeSuccess(`  🚀 ${job.name} v${job.version} deployed`);
                 }
@@ -1582,7 +1547,13 @@ async function pushAllCommand(options) {
             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);
+                const deployed = await retryDeploy(async () => {
+                    const result = await preprocessorService.publishPreProcessorVersion(processor.preprocessorId, processor.version);
+                    if (!result.success) {
+                        throw new Error(result.error?.message || 'Failed to publish preprocessor');
+                    }
+                    return result;
+                }, processor.name, processor.version, 3);
                 if (deployed) {
                     writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
                 }
@@ -1596,7 +1567,13 @@ async function pushAllCommand(options) {
             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);
+                const deployed = await retryDeploy(async () => {
+                    const result = await postprocessorService.publishPostProcessorVersion(processor.postprocessorId, processor.version);
+                    if (!result.success) {
+                        throw new Error(result.error?.message || 'Failed to publish postprocessor');
+                    }
+                    return result;
+                }, processor.name, processor.version, 3);
                 if (deployed) {
                     writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
                 }
@@ -1651,20 +1628,32 @@ function bumpPatchVersion(version) {
  * 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) {
+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));
+            // Only delay on retry attempts (not first attempt)
+            if (attempt > 1) {
+                const delay = attempt * 2000; // 2s on 2nd attempt, 4s on 3rd, etc.
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
             await deployFn();
+            // Show success message if succeeded after retrying
+            if (attempt > 1) {
+                writeInfo(`    ✓ Succeeded on retry ${attempt}/${maxRetries}`);
+            }
             return true;
         }
         catch (error) {
-            if (attempt === maxRetries) {
-                console.error(`    [Retry ${attempt}/${maxRetries}] Deploy failed: ${error.message}`);
-                return false;
+            // Extract detailed error message from API response
+            const errorMessage = error?.error?.message || error?.message || 'Unknown error';
+            if (attempt < maxRetries) {
+                // Intermediate retry - show brief info
+                writeInfo(`    [Attempt ${attempt}/${maxRetries}] ${errorMessage} - retrying...`);
+            }
+            else {
+                // Final attempt failed - show error
+                console.error(`    ❌ [Attempt ${attempt}/${maxRetries}] Deploy failed: ${errorMessage}`);
             }
-            // Continue to next retry silently
         }
     }
     return false;