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

package/dist/commands/push.js

@@ -2,40 +2,60 @@
  * Push Command
  * Orchestrates pushing skill versions to the server
  */
-import fs from 'fs';
-import path from 'path';
-import yaml from 'js-yaml';
 import { compileCommand } from './compile.js';
-import { checkApiKey, loadApiKey } from '../services/auth.js';
-import { readSkillConfig } from '../utils/files.js';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
+import { readYamlConfig, } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo, clearPromptLines } from '../utils/cli.js';
+import { requireAuthOrExit } from '../utils/command-utils.js';
 import { safePrompt } from '../utils/prompt-handler.js';
-import { readDeployJson, validatePushConfig, validateDeployData, promptVersionConfirmOrUpdate, getAvailableSkills, updateSkillVersionInYaml, getSkillDeployData, } from '../utils/push-helpers.js';
-import { pushVersion } from '../utils/push-api.js';
-import { fetchVersions, publishVersion, } from '../utils/deploy-api.js';
+import { incrementPatchVersion, maxSemver } from '../utils/semver.js';
 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';
+import { loadManifest, getAgentPersona } from '../utils/artifact-loader.js';
+import { skillHandler as skillH, webhookHandler as webhookH, jobHandler as jobH, preprocessorHandler as preprocessorH, postprocessorHandler as postprocessorH, } from '../primitives/index.js';
+import { pushBackupCommand } from './pushBackup.js';
 // ============================================================================
 // Core Push Helpers (shared by all push functions)
 // ============================================================================
+/**
+ * Prompts user to confirm or update the version.
+ *
+ * @param currentVersion - Current version of the skill
+ * @returns Confirmed or updated version
+ */
+async function promptVersionConfirmOrUpdate(currentVersion) {
+    console.log(`\nCurrent version: ${currentVersion || '(none - first push)'}`);
+    const answer = await safePrompt([
+        {
+            type: "input",
+            name: "newVersion",
+            message: "Enter new version to push:",
+            default: incrementPatchVersion(currentVersion),
+            validate: (input) => {
+                if (!input || input.trim() === "") {
+                    return "Version cannot be empty";
+                }
+                // Basic semver validation
+                const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+                if (!semverRegex.test(input.trim())) {
+                    return "Version must follow semver format (e.g., 1.0.0, 1.0.0-alpha.1)";
+                }
+                return true;
+            }
+        }
+    ]);
+    if (!answer) {
+        console.log("Push cancelled.");
+        process.exit(0);
+    }
+    clearPromptLines(2);
+    return answer.newVersion.trim();
+}
 /**
  * Authenticates the user and returns the API key
  * Exits with error if authentication fails
  */
 async function authenticateOrFail() {
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        console.log("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-        process.exit(1);
-    }
-    await checkApiKey(apiKey);
-    return apiKey;
+    return requireAuthOrExit(false);
 }
 /**
  * Selects an entity from a list, either by options.entityName or interactive prompt
@@ -46,15 +66,13 @@ async function authenticateOrFail() {
 async function selectEntityOrFail(items, options, config) {
     const { entityType, nameFields = ['id', 'name'], formatChoice } = config;
     if (items.length === 0) {
-        console.log(`❌ No ${entityType}s found in lua.skill.yaml.`);
-        process.exit(1);
+        throw new Error(`No ${entityType}s found in lua.skill.yaml.`);
     }
     // Non-interactive: find by name
     if (options.entityName) {
         const found = items.find((item) => nameFields.some(field => item[field] === options.entityName));
         if (!found) {
-            console.log(`❌ ${entityType} "${options.entityName}" not found`);
-            process.exit(1);
+            throw new Error(`${entityType} "${options.entityName}" not found`);
         }
         writeInfo(`📦 Selected ${entityType}: ${found.name}`);
         return found;
@@ -87,19 +105,20 @@ async function selectEntityOrFail(items, options, config) {
  * Resolves version from options or interactive prompt
  * Validates semantic versioning format
  */
-async function resolveVersionOrFail(currentVersion, options) {
+async function resolveVersionOrFail(currentVersion, options, highestKnownVersion) {
     // 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)`);
-            process.exit(1);
+            throw new Error(`Invalid version format: "${options.version}". Use semantic versioning (e.g., 1.0.5)`);
         }
         writeInfo(`📝 Using version: ${options.version}`);
         return options.version;
     }
     // If force flag provided, auto-bump without prompting
     if (options.force) {
-        const newVersion = bumpPatchVersion(currentVersion);
+        // Bump from the highest known version (max of YAML and server) to avoid conflicts
+        const baseVersion = highestKnownVersion ? maxSemver(currentVersion, highestKnownVersion) : currentVersion;
+        const newVersion = incrementPatchVersion(baseVersion);
         writeInfo(`📝 Auto-bumping version: ${currentVersion} → ${newVersion}`);
         return newVersion;
     }
@@ -107,26 +126,7 @@ async function resolveVersionOrFail(currentVersion, options) {
     return await promptVersionConfirmOrUpdate(currentVersion);
 }
 /**
- * Loads bundled entity data from dist folder
- * @returns The bundled data for the entity, or exits if not found
- */
-function loadBundledEntityData(filename, entityName, entityType) {
-    const bundledPath = path.join(process.cwd(), 'dist', filename);
-    if (!fs.existsSync(bundledPath)) {
-        console.log(`❌ Bundled ${entityType.toLowerCase()} data not found.`);
-        console.log("💡 Please ensure your code is properly compiled.");
-        process.exit(1);
-    }
-    const bundled = JSON.parse(fs.readFileSync(bundledPath, 'utf8'));
-    const bundledData = bundled.find((item) => item.name === entityName) || {};
-    if (!bundledData || Object.keys(bundledData).length === 0) {
-        console.log(`\n❌ ${entityType} "${entityName}" not found in compiled code.`);
-        console.log("💡 This may have been removed or commented out in your code.");
-        console.log(`💡 Please uncomment the ${entityType.toLowerCase()} or remove it from lua.skill.yaml.`);
-        process.exit(1);
-    }
-    return bundledData;
-}
+
 /**
  * Determines if we should deploy after push based on options or prompt
  */
@@ -150,6 +150,107 @@ async function shouldDeployAfterPush(options) {
     ]);
     return answer?.deployNow || false;
 }
+// ============================================================================
+// Generic Push/Deploy (replaces per-type push/deploy functions)
+// ============================================================================
+/**
+ * Generic push for any versioned primitive (webhook, job, preprocessor, postprocessor).
+ * Skill has its own flow due to tools array + config validation.
+ */
+async function pushVersionedPrimitive(handler, options = {}) {
+    try {
+        // Step 1: Compile
+        writeProgress("📦 Compiling project...");
+        await compileCommand();
+        writeSuccess("✅ Compilation complete");
+        // Step 2: Authenticate
+        const apiKey = await authenticateOrFail();
+        writeSuccess("✅ Authentication verified");
+        // Step 3: Read config
+        const config = readYamlConfig();
+        if (!config?.agent?.agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
+        }
+        const agentId = config.agent.agentId;
+        // Step 4: Get items from YAML and select
+        const items = handler.getFromYaml(config);
+        if (items.length === 0) {
+            throw new Error(`No ${handler.displayNamePlural} found in lua.skill.yaml.`);
+        }
+        const selected = await selectEntityOrFail(items, options, {
+            entityType: handler.displayName,
+            nameFields: ['id', handler.yamlConfig.idField, 'name']
+        });
+        const entityId = selected[handler.yamlConfig.idField];
+        if (!entityId) {
+            throw new Error(`${handler.displayName} "${selected.name}" has no server ID. Run 'lua compile' first.`);
+        }
+        // Step 5: Load bundled data
+        const manifest = loadManifest();
+        const pushData = handler.prepareForPush(manifest, selected.name);
+        if (!pushData) {
+            throw new Error(`${handler.displayName} "${selected.name}" not found in compiled output.`);
+        }
+        // Step 6: Resolve version (check server for highest to avoid conflicts)
+        const serverHighest = options.force
+            ? await handler.getHighestServerVersion(apiKey, agentId, entityId)
+            : undefined;
+        const confirmedVersion = await resolveVersionOrFail(selected.version, options, serverHighest ?? undefined);
+        if (confirmedVersion !== selected.version) {
+            handler.updateVersionInYaml(selected.name, confirmedVersion);
+        }
+        // Step 7: Push
+        writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion} to server...`);
+        const result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: confirmedVersion });
+        if (!result.success) {
+            throw new Error(`Push Error: ${result.error || 'Unknown error'}`);
+        }
+        writeSuccess(`\n✅ Successfully pushed ${selected.name} v${confirmedVersion}\n`);
+        // Step 8: Deploy if requested
+        if (await shouldDeployAfterPush(options)) {
+            await genericDeployAfterPush(handler, apiKey, agentId, entityId, selected.name, confirmedVersion, options.autoDeploy || false);
+        }
+        else {
+            writeInfo(`💡 You can deploy later using: lua ${handler.displayNamePlural} production`);
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Generic deploy/publish after push for any versioned primitive.
+ */
+async function genericDeployAfterPush(handler, apiKey, agentId, entityId, entityName, version, skipConfirmation = false) {
+    try {
+        if (!skipConfirmation) {
+            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;
+            }
+        }
+        writeProgress(`🔄 Publishing ${handler.displayName} version...`);
+        const result = await handler.publishVersion(apiKey, agentId, entityId, version);
+        if (!result.success) {
+            console.error(`\n❌ Deploy Error: ${result.error || 'Unknown error'}\n`);
+            return;
+        }
+        writeSuccess(`\n✅ ${entityName} v${version} deployed to production\n`);
+        writeInfo(`💡 The new ${handler.displayName} version is now active.`);
+    }
+    catch (error) {
+        console.error(`\n❌ Error deploying ${handler.displayName}:`, error);
+        console.log(`💡 You can deploy later using: lua ${handler.displayNamePlural} production\n`);
+    }
+}
 /**
  * Main push command - pushes a skill or persona version to the server.
  *
@@ -176,33 +277,30 @@ export async function pushCommand(type, cmdObj) {
             force: cmdObj?.force || false,
             autoDeploy: cmdObj?.autoDeploy || false,
             entityName: cmdObj?.name || null,
-            version: cmdObj?.version || null
+            version: cmdObj?.setVersion || null
         };
         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);
+                throw new Error('The "all" type requires the --force flag');
             }
             return await pushAllCommand(options);
         }
         // Validate that entityName without type is not allowed
         if (options.entityName && !type) {
-            console.error('❌ Type must be specified when using the --name option.');
             console.log('\nUsage:');
-            console.log('  lua push skill --name mySkill --version 1.0.5        Push specific skill');
-            console.log('  lua push webhook --name myWebhook --version 2.0.0    Push specific webhook');
-            process.exit(1);
+            console.log('  lua push skill --name mySkill --set-version 1.0.5        Push specific skill');
+            console.log('  lua push webhook --name myWebhook --set-version 2.0.0    Push specific webhook');
+            throw new Error('Type must be specified when using the --name option.');
         }
         // 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' && type !== 'mcp') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", "mcp", or "all".`);
+            if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor' && type !== 'mcp' && type !== 'backup') {
                 console.log('\nUsage:');
                 console.log('  lua push                - Interactive selection');
                 console.log('  lua push skill          - Push a skill directly');
@@ -212,8 +310,9 @@ export async function pushCommand(type, cmdObj) {
                 console.log('  lua push preprocessor   - Push a preprocessor directly');
                 console.log('  lua push postprocessor  - Push a postprocessor directly');
                 console.log('  lua push mcp            - Push an MCP server directly');
+                console.log('  lua push backup         - Push project source backup');
                 console.log('  lua push all --force    - Push all components without prompts');
-                process.exit(1);
+                throw new Error(`Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", "mcp", "backup", or "all".`);
             }
             selectedType = type;
         }
@@ -231,7 +330,8 @@ export async function pushCommand(type, cmdObj) {
                         { name: '📥 PreProcessor', value: 'preprocessor' },
                         { name: '📤 PostProcessor', value: 'postprocessor' },
                         { name: '🔌 MCP Server', value: 'mcp' },
-                        { name: '🌙 Persona', value: 'persona' }
+                        { name: '🌙 Persona', value: 'persona' },
+                        { name: '💾 Backup (source files)', value: 'backup' }
                     ]
                 }
             ]);
@@ -243,89 +343,31 @@ export async function pushCommand(type, cmdObj) {
         }
         // Step 3: Route to appropriate function
         if (selectedType === 'skill') {
-            await pushSkillVersion(options);
+            await pushVersionedPrimitive(skillH, options);
         }
         else if (selectedType === 'webhook') {
-            await pushWebhookVersion(options);
+            await pushVersionedPrimitive(webhookH, options);
         }
         else if (selectedType === 'job') {
-            await pushJobVersion(options);
+            await pushVersionedPrimitive(jobH, options);
         }
         else if (selectedType === 'preprocessor') {
-            await pushPreProcessorVersion(options);
+            await pushVersionedPrimitive(preprocessorH, options);
         }
         else if (selectedType === 'postprocessor') {
-            await pushPostProcessorVersion(options);
+            await pushVersionedPrimitive(postprocessorH, options);
         }
         else if (selectedType === 'mcp') {
-            await pushMCPServerVersion(options);
+            await pushMCPServer(options);
+        }
+        else if (selectedType === 'backup') {
+            await pushBackupCommand({ force: options.force });
         }
         else {
             await pushPersonaVersion(options);
         }
     }, "push");
 }
-/**
- * Push skill version to the server.
- */
-async function pushSkillVersion(options = {}) {
-    // Step 1: Validate configuration
-    const yamlConfig = readSkillConfig();
-    validatePushConfig(yamlConfig);
-    const config = yamlConfig;
-    // Step 2: Get available skills and select
-    const availableSkills = getAvailableSkills(config);
-    if (availableSkills.length === 0) {
-        console.log("❌ No skills found in configuration. Please compile your skill first using 'lua compile'.");
-        process.exit(1);
-    }
-    const selectedSkill = await selectEntityOrFail(availableSkills, options, {
-        entityType: 'skill',
-        nameFields: ['skillId', 'name']
-    });
-    // Step 3: Handle version
-    const confirmedVersion = await resolveVersionOrFail(selectedSkill.version, options);
-    if (confirmedVersion !== selectedSkill.version) {
-        writeInfo(`📝 Updating version from ${selectedSkill.version} to ${confirmedVersion}`);
-        updateSkillVersionInYaml(selectedSkill.name, confirmedVersion);
-        selectedSkill.version = confirmedVersion;
-    }
-    // Step 4: Authenticate
-    const apiKey = await authenticateOrFail();
-    writeProgress("✅ Authenticated");
-    // Step 5: Compile the skill
-    writeProgress("🔄 Compiling skill...");
-    await compileCommand();
-    // Step 6: Validate and extract deploy data
-    const deployData = readDeployJson();
-    validateDeployData(deployData, selectedSkill);
-    const skillDeployData = getSkillDeployData(deployData, selectedSkill.name);
-    // Step 7: Push version to server
-    writeProgress("🔄 Pushing version to server...");
-    const result = await pushVersion(apiKey, config.agent.agentId, selectedSkill.skillId, skillDeployData);
-    if (result.success && result.data) {
-        const pushedVersion = result.data.version;
-        writeSuccess(`✅ Version ${pushedVersion} of "${selectedSkill.name}" pushed successfully`);
-        // Update YAML with the version returned from server
-        if (pushedVersion !== selectedSkill.version) {
-            writeInfo(`📝 Updating YAML with server version: ${pushedVersion}`);
-            updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
-            selectedSkill.version = pushedVersion;
-        }
-        // Step 8: Deploy if requested
-        if (await shouldDeployAfterPush(options)) {
-            await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion, options.autoDeploy || false);
-        }
-    }
-    else if (result.error) {
-        console.log(`❌ ${result.error.message}`);
-        process.exit(1);
-    }
-    else {
-        console.log("❌ Failed to push version. Please try again.");
-        process.exit(1);
-    }
-}
 /**
  * Push persona version to the server.
  *
@@ -340,16 +382,14 @@ async function pushSkillVersion(options = {}) {
  */
 async function pushPersonaVersion(options = {}) {
     // Step 1: Validate configuration
-    const config = readSkillConfig();
+    const config = readYamlConfig();
     if (!config || !config.agent?.agentId) {
-        console.log("❌ No agent configuration found. Please run 'lua init' first.");
-        process.exit(1);
+        throw new Error("No agent configuration found. Please run 'lua init' first.");
     }
     // Step 2: Load current persona from code
-    const currentPersona = loadPersonaFromCode();
+    const currentPersona = getAgentPersona();
     if (!currentPersona || !currentPersona.trim()) {
-        console.log("❌ No persona found in configuration. Please edit your persona first using 'lua persona'.");
-        process.exit(1);
+        throw new Error("No persona found in configuration. Please edit your persona first using 'lua persona'.");
     }
     writeInfo(`📦 Pushing persona for agent: ${config.agent.agentId}`);
     // Show preview of persona
@@ -396,8 +436,7 @@ async function pushPersonaVersion(options = {}) {
         }
     }
     catch (error) {
-        console.log('❌ Error creating persona version:', error);
-        process.exit(1);
+        throw error;
     }
 }
 /**
@@ -439,675 +478,47 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipCo
     }
 }
 /**
- * Push webhook version to the server.
- *
- * Steps:
- * 1. Run compilation
- * 2. Validate config and deploy data
- * 3. Select webhook to push
- * 4. Confirm or update version
- * 5. Push to server
- * 6. Optionally deploy immediately
+ * Push MCP server (non-versioned, upsert pattern).
+ * Uses the same compile→auth→config→select pattern as versioned primitives,
+ * with MCP-specific logic delegated to the handler.
  */
-async function pushWebhookVersion(options = {}) {
+async function pushMCPServer(options = {}) {
     try {
-        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
-        // Step 2: Authenticate
         const apiKey = await authenticateOrFail();
         writeSuccess("✅ Authentication verified");
-        // Step 3: Read configuration
-        const config = readSkillConfig();
+        const config = readYamlConfig();
         if (!config?.agent?.agentId) {
-            console.log("❌ No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
-            process.exit(1);
-        }
-        const webhooks = config.webhooks || [];
-        if (webhooks.length === 0) {
-            console.log("❌ No webhooks found in lua.skill.yaml.");
-            console.log("💡 Make sure you have created a webhook using LuaWebhook in your code.");
-            process.exit(1);
-        }
-        // Step 4: Select webhook
-        const selectedWebhook = await selectEntityOrFail(webhooks, options, {
-            entityType: 'webhook',
-            nameFields: ['id', 'webhookId', 'name']
+            throw new Error("No agent ID found. Run 'lua init' first.");
+        }
+        const agentId = config.agent.agentId;
+        const { mcpServerHandler } = await import('../primitives/mcp-server.handler.js');
+        const bundledServers = mcpServerHandler.loadBundledServers();
+        if (bundledServers.length === 0) {
+            throw new Error("No MCP servers found in compiled output.");
+        }
+        const selectedServer = await selectEntityOrFail(bundledServers, options, {
+            entityType: 'MCP server',
+            nameFields: ['name'],
+            formatChoice: (s) => `${s.name} (${s.transport})`,
         });
-        // Step 5: Load and validate bundled data
-        const bundledWebhookData = loadBundledEntityData('webhooks.json', selectedWebhook.name, 'Webhook');
-        // Step 6: Handle version
-        const confirmedVersion = await resolveVersionOrFail(selectedWebhook.version, options);
-        if (confirmedVersion !== selectedWebhook.version) {
-            writeInfo(`📝 Updating version from ${selectedWebhook.version} to ${confirmedVersion}`);
-            updateWebhookVersionInYaml(selectedWebhook.name, confirmedVersion);
-        }
-        // Step 7: Prepare and push webhook data
-        const webhookData = {
-            name: selectedWebhook.name,
-            version: confirmedVersion,
-            description: bundledWebhookData.description || selectedWebhook.description || `Webhook: ${selectedWebhook.name}`,
-            webhookId: selectedWebhook.webhookId,
-            querySchema: bundledWebhookData.querySchema,
-            headerSchema: bundledWebhookData.headerSchema,
-            bodySchema: bundledWebhookData.bodySchema,
-            code: bundledWebhookData.code,
-            executeFunction: bundledWebhookData.executeFunction
-        };
-        writeProgress(`\n🚀 Pushing ${selectedWebhook.name} v${confirmedVersion} to server...`);
-        const webhookApi = new WebhookApi(BASE_URLS.API, apiKey, config.agent.agentId);
-        const result = await webhookApi.pushWebhook(selectedWebhook.webhookId, webhookData);
+        writeProgress(`\n🚀 Pushing MCP server "${selectedServer.name}"...`);
+        const result = await mcpServerHandler.upsertOnServer(apiKey, agentId, selectedServer);
         if (!result.success) {
-            console.log(`\n❌ Push Error: ${result.error?.message || 'Unknown error'}\n`);
-            throw new Error(result.error?.message || 'Failed to push webhook');
-        }
-        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, options.autoDeploy || false);
-        }
-        else {
-            writeInfo("💡 You can deploy this version later using: lua webhooks production");
-        }
-    }
-    catch (error) {
-        console.log('❌ Error pushing webhook version:', error);
-        process.exit(1);
-    }
-}
-/**
- * Deploy a webhook version immediately after pushing
- */
-async function deployWebhookVersionAfterPush(apiKey, agentId, selectedWebhook, pushedVersion, skipConfirmation = false) {
-    try {
-        // 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;
-            }
-        }
-        writeProgress("🔄 Publishing webhook version...");
-        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.");
-    }
-    catch (error) {
-        console.error('\n❌ Error deploying webhook version:', error);
-        console.log('💡 You can deploy later using: lua webhooks production\n');
-    }
-}
-/**
- * Updates webhook version in lua.skill.yaml
- */
-function updateWebhookVersionInYaml(webhookName, newVersion) {
-    try {
-        const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
-        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-        const config = yaml.load(yamlContent);
-        if (config.webhooks) {
-            const webhook = config.webhooks.find((w) => w.name === webhookName);
-            if (webhook) {
-                webhook.version = newVersion;
-                fs.writeFileSync(yamlPath, yaml.dump(config, { indent: 2, lineWidth: 120, noRefs: true }));
-            }
-        }
-    }
-    catch (error) {
-        console.warn('⚠️  Could not update webhook version in YAML:', error);
-    }
-}
-/**
- * Updates job version in lua.skill.yaml
- */
-function updateJobVersionInYaml(jobName, newVersion) {
-    try {
-        const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
-        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-        const config = yaml.load(yamlContent);
-        if (config.jobs) {
-            const job = config.jobs.find((j) => j.name === jobName);
-            if (job) {
-                job.version = newVersion;
-                fs.writeFileSync(yamlPath, yaml.dump(config, { indent: 2, lineWidth: 120, noRefs: true }));
-            }
-        }
-    }
-    catch (error) {
-        console.warn('⚠️  Could not update job version in YAML:', error);
-    }
-}
-/**
- * Push job version to the server (simplified version)
- */
-async function pushJobVersion(options = {}) {
-    try {
-        // Step 1: Compile
-        writeProgress("📦 Compiling project...");
-        await compileCommand();
-        writeSuccess("✅ Compilation complete");
-        // Step 2: Authenticate
-        const apiKey = await authenticateOrFail();
-        // Step 3: Read configuration
-        const config = readSkillConfig();
-        if (!config?.agent?.agentId) {
-            console.log("❌ No agent ID found in lua.skill.yaml.");
-            process.exit(1);
-        }
-        const jobs = config.jobs || [];
-        if (jobs.length === 0) {
-            console.log("❌ No jobs found in lua.skill.yaml.");
-            console.log("💡 Make sure you have created a job using LuaJob in your code.");
-            process.exit(1);
-        }
-        // Step 4: Select job
-        const selectedJob = await selectEntityOrFail(jobs, options, {
-            entityType: 'job',
-            nameFields: ['id', 'jobId', 'name']
-        });
-        // Step 5: Load bundled data
-        const bundledJobData = loadBundledEntityData('jobs.json', selectedJob.name, 'Job');
-        // Step 6: Handle version
-        const confirmedVersion = await resolveVersionOrFail(selectedJob.version, options);
-        if (confirmedVersion !== selectedJob.version) {
-            writeInfo(`📝 Updating version from ${selectedJob.version} to ${confirmedVersion}`);
-            updateJobVersionInYaml(selectedJob.name, confirmedVersion);
-        }
-        // Step 7: Prepare and push
-        const jobData = {
-            name: selectedJob.name,
-            version: confirmedVersion,
-            description: bundledJobData.description || selectedJob.description || `Job: ${selectedJob.name}`,
-            jobId: selectedJob.jobId,
-            schedule: bundledJobData.schedule || selectedJob.schedule,
-            timeout: bundledJobData.timeout,
-            retry: bundledJobData.retry,
-            code: bundledJobData.code,
-            executeFunction: bundledJobData.executeFunction,
-            metadata: bundledJobData.metadata || selectedJob.metadata
-        };
-        writeProgress(`\n🚀 Pushing ${selectedJob.name} v${confirmedVersion} to server...`);
-        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, options.autoDeploy || false);
-        }
-        else {
-            writeInfo("💡 You can deploy this version later using: lua jobs production");
-        }
-    }
-    catch (error) {
-        console.log('❌ Error pushing job version:', error);
-        process.exit(1);
-    }
-}
-/**
- * Deploy a job version immediately after pushing
- */
-async function deployJobVersionAfterPush(apiKey, agentId, selectedJob, pushedVersion, skipConfirmation = false) {
-    try {
-        // 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;
-            }
-        }
-        writeProgress("🔄 Publishing job version...");
-        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.");
-    }
-    catch (error) {
-        console.error('\n❌ Error deploying job version:', error);
-        console.log('💡 You can deploy later using: lua jobs production\n');
-    }
-}
-/**
- * Push preprocessor version to the server.
- */
-async function pushPreProcessorVersion(options = {}) {
-    try {
-        // Step 1: Compile
-        writeProgress("📦 Compiling project...");
-        await compileCommand();
-        writeSuccess("✅ Compilation complete");
-        // Step 2: Authenticate
-        const apiKey = await authenticateOrFail();
-        // Step 3: Read configuration
-        const config = readSkillConfig();
-        if (!config?.agent?.agentId) {
-            console.log("❌ No agent ID found in lua.skill.yaml.");
-            process.exit(1);
-        }
-        const preprocessors = config.preprocessors || [];
-        if (preprocessors.length === 0) {
-            console.log("❌ No preprocessors found in lua.skill.yaml.");
-            process.exit(1);
-        }
-        // Step 4: Select preprocessor
-        const selected = await selectEntityOrFail(preprocessors, options, {
-            entityType: 'preprocessor',
-            nameFields: ['id', 'preprocessorId', 'name']
-        });
-        // Step 5: Load bundled data
-        const bundledData = loadBundledEntityData('preprocessors.json', selected.name, 'PreProcessor');
-        if (!bundledData.code) {
-            console.log(`❌ PreProcessor "${selected.name}" has no code in compiled output.`);
-            process.exit(1);
-        }
-        // Step 6: Handle version
-        const confirmedVersion = await resolveVersionOrFail(selected.version, options);
-        if (confirmedVersion !== selected.version) {
-            writeInfo(`📝 Updating version from ${selected.version} to ${confirmedVersion}`);
-            updateProcessorVersionInYaml('preprocessors', selected.name, confirmedVersion);
-        }
-        // Step 7: Prepare and push
-        const versionData = {
-            name: selected.name,
-            version: confirmedVersion,
-            description: bundledData.description || selected.description,
-            preprocessorId: selected.preprocessorId,
-            code: bundledData.code,
-            executeFunction: bundledData.executeFunction,
-            async: Boolean(bundledData.async ?? false)
-        };
-        writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
-        const api = new PreProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);
-        const result = await api.pushPreProcessor(selected.preprocessorId, versionData);
-        if (result.success) {
-            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, options.autoDeploy || false);
-            }
-            else {
-                writeInfo("💡 You can deploy this version later using: lua preprocessors production");
-            }
-        }
-        else {
-            console.log(`❌ Failed to push: ${result.error?.message}`);
-        }
-    }
-    catch (error) {
-        console.log('❌ Error pushing preprocessor:', error);
-        process.exit(1);
-    }
-}
-/**
- * Deploy a preprocessor version immediately after pushing
- */
-async function deployPreProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion, skipConfirmation = false) {
-    try {
-        // 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;
-            }
-        }
-        writeProgress("🔄 Publishing preprocessor version...");
-        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
-        const publishResponse = await api.publishPreProcessorVersion(selected.preprocessorId, pushedVersion);
-        if (!publishResponse.success) {
-            console.error(`\n❌ Deploy Error: ${publishResponse.error?.message || 'Unknown error'}\n`);
-            throw new Error(publishResponse.error?.message || 'Failed to publish preprocessor version');
-        }
-        writeSuccess(`\n✅ PreProcessor ${selected.name} v${pushedVersion} deployed successfully to production\n`);
-        writeInfo("💡 The new preprocessor version is now active for all users.");
-    }
-    catch (error) {
-        console.error('\n❌ Error deploying preprocessor version:', error);
-        console.log('💡 You can deploy later using: lua preprocessors production\n');
-    }
-}
-/**
- * Push postprocessor version to the server.
- */
-async function pushPostProcessorVersion(options = {}) {
-    try {
-        // Step 1: Compile
-        writeProgress("📦 Compiling project...");
-        await compileCommand();
-        writeSuccess("✅ Compilation complete");
-        // Step 2: Authenticate
-        const apiKey = await authenticateOrFail();
-        // Step 3: Read configuration
-        const config = readSkillConfig();
-        if (!config?.agent?.agentId) {
-            console.log("❌ No agent ID found in lua.skill.yaml.");
-            process.exit(1);
-        }
-        const postprocessors = config.postprocessors || [];
-        if (postprocessors.length === 0) {
-            console.log("❌ No postprocessors found in lua.skill.yaml.");
-            process.exit(1);
-        }
-        // Step 4: Select postprocessor
-        const selected = await selectEntityOrFail(postprocessors, options, {
-            entityType: 'postprocessor',
-            nameFields: ['id', 'postprocessorId', 'name']
-        });
-        // Step 5: Load bundled data
-        const bundledData = loadBundledEntityData('postprocessors.json', selected.name, 'PostProcessor');
-        if (!bundledData.code) {
-            console.log(`❌ PostProcessor "${selected.name}" has no code in compiled output.`);
-            process.exit(1);
-        }
-        // Step 6: Handle version
-        const confirmedVersion = await resolveVersionOrFail(selected.version, options);
-        if (confirmedVersion !== selected.version) {
-            writeInfo(`📝 Updating version from ${selected.version} to ${confirmedVersion}`);
-            updateProcessorVersionInYaml('postprocessors', selected.name, confirmedVersion);
-        }
-        // Step 7: Prepare and push
-        const versionData = {
-            name: selected.name,
-            version: confirmedVersion,
-            description: bundledData.description || selected.description,
-            postprocessorId: selected.postprocessorId,
-            code: bundledData.code,
-            executeFunction: bundledData.executeFunction
-        };
-        writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
-        const api = new PostProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);
-        const result = await api.pushPostProcessor(selected.postprocessorId, versionData);
-        if (result.success) {
-            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, options.autoDeploy || false);
-            }
-            else {
-                writeInfo("💡 You can deploy this version later using: lua postprocessors production");
-            }
-        }
-        else {
-            console.log(`❌ Failed to push: ${result.error?.message}`);
-        }
-    }
-    catch (error) {
-        console.log('❌ Error pushing postprocessor:', error);
-        process.exit(1);
-    }
-}
-/**
- * Deploy a postprocessor version immediately after pushing
- */
-async function deployPostProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion, skipConfirmation = false) {
-    try {
-        // 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;
-            }
+            throw new Error(`Failed: ${result.error}`);
         }
-        writeProgress("🔄 Publishing postprocessor version...");
-        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
-        const publishResponse = await api.publishPostProcessorVersion(selected.postprocessorId, pushedVersion);
-        if (!publishResponse.success) {
-            console.error(`\n❌ Deploy Error: ${publishResponse.error?.message || 'Unknown error'}\n`);
-            throw new Error(publishResponse.error?.message || 'Failed to publish postprocessor version');
+        writeSuccess(`\n✅ MCP server "${selectedServer.name}" pushed successfully\n`);
+        if (result.id && await shouldDeployAfterPush(options)) {
+            writeProgress("🔄 Activating MCP server...");
+            const activateResult = await mcpServerHandler.activate(apiKey, agentId, result.id);
+            if (activateResult.success)
+                writeSuccess(`✅ MCP server activated\n`);
         }
-        writeSuccess(`\n✅ PostProcessor ${selected.name} v${pushedVersion} deployed successfully to production\n`);
-        writeInfo("💡 The new postprocessor version is now active for all users.");
     }
     catch (error) {
-        console.error('\n❌ Error deploying postprocessor version:', error);
-        console.log('💡 You can deploy later using: lua postprocessors production\n');
-    }
-}
-/**
- * Updates processor version in lua.skill.yaml
- */
-function updateProcessorVersionInYaml(processorType, processorName, newVersion) {
-    try {
-        const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
-        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-        const config = yaml.load(yamlContent);
-        if (config[processorType]) {
-            const processor = config[processorType].find((p) => p.name === processorName);
-            if (processor) {
-                processor.version = newVersion;
-                fs.writeFileSync(yamlPath, yaml.dump(config, { indent: 2, lineWidth: 120, noRefs: true }));
-            }
-        }
-    }
-    catch (error) {
-        console.warn('⚠️  Could not update processor version in YAML:', error);
-    }
-}
-/**
- * Push MCP Server to the server
- */
-async function pushMCPServerVersion(options = {}) {
-    try {
-        // Step 1: Compile
-        writeProgress("📦 Compiling project...");
-        await compileCommand();
-        writeSuccess("✅ Compilation complete");
-        // Step 2: Authenticate
-        const apiKey = await authenticateOrFail();
-        writeSuccess("✅ Authentication verified");
-        // Step 3: Read configuration
-        const config = readSkillConfig();
-        if (!config?.agent?.agentId) {
-            console.log("❌ No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
-            process.exit(1);
-        }
-        const mcpServers = config.mcpServers || [];
-        if (mcpServers.length === 0) {
-            console.log("❌ No MCP servers found in lua.skill.yaml.");
-            console.log("💡 Make sure you have defined MCP servers in your LuaAgent configuration.");
-            process.exit(1);
-        }
-        // Step 4: Load bundled MCP server data
-        const bundledServersPath = path.join(process.cwd(), 'dist', 'mcp-servers.json');
-        if (!fs.existsSync(bundledServersPath)) {
-            console.log('❌ Bundled MCP server data not found.');
-            console.log("💡 Please ensure your MCP servers are properly compiled.");
-            process.exit(1);
-        }
-        const bundledServers = JSON.parse(fs.readFileSync(bundledServersPath, 'utf8'));
-        // Step 5: Select MCP server (special handling - uses bundled data with YAML IDs)
-        let selectedServer;
-        let bundledServerData;
-        if (options.entityName) {
-            bundledServerData = bundledServers.find((s) => s.id === options.entityName || s.mcpServerId === options.entityName || s.name === options.entityName);
-            if (!bundledServerData) {
-                console.log(`❌ MCP server "${options.entityName}" not found`);
-                process.exit(1);
-            }
-            const yamlEntry = mcpServers.find((s) => s.name === bundledServerData.name);
-            selectedServer = { ...bundledServerData, mcpServerId: yamlEntry?.mcpServerId };
-            writeInfo(`📦 Selected MCP server: ${selectedServer.name}`);
-        }
-        else if (bundledServers.length === 1) {
-            bundledServerData = bundledServers[0];
-            const yamlEntry = mcpServers.find((s) => s.name === bundledServerData.name);
-            selectedServer = { ...bundledServerData, mcpServerId: yamlEntry?.mcpServerId };
-            writeInfo(`📦 Pushing MCP server: ${selectedServer.name}`);
-        }
-        else {
-            const serverAnswer = await safePrompt([
-                {
-                    type: 'list',
-                    name: 'selectedServer',
-                    message: 'Select an MCP server to push:',
-                    choices: bundledServers.map((server) => {
-                        const yamlEntry = mcpServers.find((s) => s.name === server.name);
-                        return {
-                            name: `${server.name} (${server.transport})`,
-                            value: { ...server, mcpServerId: yamlEntry?.mcpServerId }
-                        };
-                    })
-                }
-            ]);
-            if (!serverAnswer) {
-                console.log("Push cancelled.");
-                return;
-            }
-            selectedServer = serverAnswer.selectedServer;
-            bundledServerData = selectedServer;
-        }
-        // Step 6: Prepare server data for push
-        // Include resolver fields for function-based env/headers/url resolution
-        const serverData = {
-            name: bundledServerData.name,
-            transport: bundledServerData.transport,
-            timeout: bundledServerData.timeout,
-            ...(bundledServerData.transport === 'stdio' ? {
-                command: bundledServerData.command,
-                args: bundledServerData.args,
-                env: bundledServerData.env,
-                envResolver: bundledServerData.envResolver, // Compressed function for runtime resolution
-            } : {
-                url: bundledServerData.url,
-                urlResolver: bundledServerData.urlResolver, // Compressed function for runtime resolution
-                headers: bundledServerData.headers,
-                headersResolver: bundledServerData.headersResolver, // Compressed function for runtime resolution
-            })
-        };
-        writeProgress(`\n🚀 Pushing MCP server "${selectedServer.name}" to server...`);
-        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, config.agent.agentId);
-        const result = await developerApi.upsertMCPServer(serverData);
-        if (result.success && result.data) {
-            writeSuccess(`\n✅ MCP server "${selectedServer.name}" pushed successfully\n`);
-            // Step 7: Activate if requested (MCP uses activate instead of deploy)
-            if (await shouldDeployAfterPush(options)) {
-                writeProgress("🔄 Activating MCP server...");
-                const activateResult = await developerApi.activateMCPServer(result.data.id);
-                if (activateResult.success) {
-                    writeSuccess(`\n✅ MCP server "${selectedServer.name}" activated successfully\n`);
-                    writeInfo("💡 The server's tools are now available to your agent.");
-                }
-                else {
-                    console.log(`❌ Failed to activate: ${activateResult.error?.message}`);
-                }
-            }
-            else {
-                writeInfo("💡 You can activate this server later using: lua mcp activate");
-            }
-        }
-        else {
-            console.log(`❌ Failed to push: ${result.error?.message}`);
-        }
-    }
-    catch (error) {
-        console.log('❌ Error pushing MCP server:', error);
-        process.exit(1);
-    }
-}
-/**
- * Deploy a version immediately after pushing
- */
-async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVersion, skipConfirmation = false) {
-    try {
-        writeProgress("\n🔄 Fetching available versions...");
-        // Fetch versions to verify the pushed version exists
-        const versionsResponse = await fetchVersions(apiKey, agentId, selectedSkill.skillId);
-        if (!versionsResponse.versions || versionsResponse.versions.length === 0) {
-            console.error("❌ No versions available. The push may have failed.");
-            return;
-        }
-        // 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;
-            }
-        }
-        // Find the pushed version in the list
-        const versionToDeploy = versionsResponse.versions.find((v) => v.version === pushedVersion);
-        if (!versionToDeploy) {
-            console.error(`\n❌ Version ${pushedVersion} not found in available versions.\n`);
-            return;
-        }
-        writeProgress("🔄 Publishing version...");
-        const publishResponse = await publishVersion(apiKey, agentId, selectedSkill.skillId, pushedVersion);
-        writeSuccess(`\n✅ Version ${pushedVersion} of "${selectedSkill.name}" deployed successfully to production\n`);
-        // Update YAML with deployed version (should already be updated from push, but ensure consistency)
-        writeInfo(`📝 Ensuring YAML is updated with deployed version: ${pushedVersion}`);
-        updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
-    }
-    catch (error) {
-        console.error('\n❌ Error deploying version:', error);
-        console.log('💡 You can deploy later using: lua deploy\n');
+        throw error;
     }
 }
 /**
@@ -1131,499 +542,141 @@ async function pushAllCommand(options) {
     writeProgress("📦 Compiling project...");
     await compileCommand();
     // Step 2: Load configuration and API key
-    const config = readSkillConfig();
+    const config = readYamlConfig();
     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);
+        throw new Error('No agent ID found in lua.skill.yaml. Run "lua init" first.');
     }
-    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 apiKey = await requireAuthOrExit(false);
+    const agentId = config.agent.agentId;
+    // Step 3: Load manifest
+    let manifest;
+    try {
+        manifest = loadManifest();
     }
-    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: []
+    catch (error) {
+        throw new Error(`Compilation output not found. Compilation may have failed. ${error.message}`);
+    }
+    // Track results and deploy queue per handler
+    const allResults = [];
+    const toDeploy = [];
+    // Icons per kind for display
+    const kindIcons = {
+        skill: '📦', webhook: '🪝', job: '⏰', preprocessor: '📥', postprocessor: '📤',
     };
-    // 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 || '',
-                    webhookId: webhookConfig.webhookId,
-                    querySchema: webhookData.querySchema,
-                    headerSchema: webhookData.headerSchema,
-                    bodySchema: webhookData.bodySchema,
-                    code: webhookData.code,
-                    executeFunction: webhookData.executeFunction
-                };
-                // 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);
-                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 || '',
-                    jobId: jobConfig.jobId,
-                    schedule: jobData.schedule || jobConfig.schedule,
-                    timeout: jobData.timeout,
-                    retry: jobData.retry,
-                    code: jobData.code,
-                    executeFunction: jobData.executeFunction,
-                    metadata: jobData.metadata
-                };
-                // 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);
-                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) {
+    // Step 4: Push all versioned primitives using handlers
+    const handlers = [skillH, webhookH, jobH, preprocessorH, postprocessorH];
+    for (const handler of handlers) {
+        const items = handler.getFromYaml(config);
+        if (items.length === 0)
+            continue;
+        const icon = kindIcons[handler.kind] || '📦';
+        writeProgress(`\n${icon} Pushing ${items.length} ${handler.displayName}(s)...`);
+        for (const item of items) {
             try {
-                const processorData = bundledPreprocessors.find((p) => p.name === processorConfig.name);
-                if (!processorData) {
-                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" not found in compiled data, skipping`);
+                const pushData = handler.prepareForPush(manifest, item.name);
+                if (!pushData) {
+                    console.warn(`⚠️  ${handler.displayName} "${item.name}" not found in compiled output, 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`);
+                const entityId = item[handler.yamlConfig.idField];
+                if (!entityId) {
+                    console.warn(`⚠️  ${handler.displayName} "${item.name}" has no server ID, skipping. Run 'lua compile' first.`);
                     continue;
                 }
-                if (!currentVersion) {
-                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no version, skipping`);
+                if (!item.version) {
+                    console.warn(`⚠️  ${handler.displayName} "${item.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 || '',
-                    preprocessorId: preprocessorId,
-                    code: processorData.code,
-                    executeFunction: processorData.executeFunction,
-                    async: Boolean(processorData.async ?? false)
-                };
-                // Push version
-                const result = await preprocessorService.pushPreProcessor(preprocessorId, versionData);
+                // Auto-bump version (check server for highest to avoid conflicts)
+                const serverHighest = await handler.getHighestServerVersion(apiKey, agentId, entityId);
+                const baseVersion = serverHighest ? maxSemver(item.version, serverHighest) : item.version;
+                const newVersion = incrementPatchVersion(baseVersion);
+                writeInfo(`  📝 ${item.name}: ${item.version} → ${newVersion}`);
+                // Push
+                const result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: newVersion });
                 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`);
+                    console.error(`  ❌ Failed to push ${item.name}: ${result.error}`);
                     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 || '',
-                    postprocessorId: postprocessorId,
-                    code: processorData.code,
-                    executeFunction: processorData.executeFunction
-                };
-                // 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
+                handler.updateVersionInYaml(item.name, newVersion, { silent: true });
+                allResults.push({ handler, name: item.name, version: newVersion, entityId });
+                writeSuccess(`  ✅ ${item.name} v${newVersion} pushed`);
                 if (options.autoDeploy) {
-                    toDeployPostprocessors.push({ postprocessorId, version: newVersion, name: processorConfig.name });
+                    toDeploy.push({ handler, name: item.name, version: newVersion, entityId });
                 }
             }
             catch (error) {
-                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+                console.error(`  ❌ Failed to push ${item.name}: ${error.message}`);
             }
         }
     }
-    // Step 9: Push MCP server configurations
-    const mcpServersJsonPath = path.join(process.cwd(), 'dist', 'mcp-servers.json');
-    if (fs.existsSync(mcpServersJsonPath)) {
-        const mcpServers = JSON.parse(fs.readFileSync(mcpServersJsonPath, 'utf8'));
-        if (mcpServers.length > 0) {
-            writeProgress(`\n🔌 Pushing ${mcpServers.length} MCP server(s)...`);
+    // Step 5: Push MCP server configurations (non-versioned, separate flow)
+    const { mcpServerHandler: mcpH } = await import('../primitives/mcp-server.handler.js');
+    const mcpServers = mcpH.loadBundledServers();
+    if (mcpServers.length > 0) {
+        writeProgress(`\n🔌 Pushing ${mcpServers.length} MCP server(s)...`);
+        for (const serverConfig of mcpServers) {
             try {
-                const DeveloperApi = (await import('../api/developer.api.service.js')).default;
-                const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
-                for (const serverConfig of mcpServers) {
-                    try {
-                        // Upsert the MCP server (create or update by name)
-                        const result = await developerApi.upsertMCPServer(serverConfig);
-                        if (result.success && result.data) {
-                            const mcpServerId = result.data.id;
-                            const isActive = result.data.active;
-                            writeSuccess(`  ✅ ${serverConfig.name} (${serverConfig.transport}) - ${isActive ? 'active' : 'inactive'}`);
-                            // Auto-activate if autoDeploy is enabled
-                            if (options.autoDeploy && !isActive) {
-                                const activateResult = await developerApi.activateMCPServer(mcpServerId);
-                                if (activateResult.success) {
-                                    writeSuccess(`     🔌 Auto-activated`);
-                                }
-                            }
-                        }
-                        else {
-                            console.error(`  ❌ Failed to push ${serverConfig.name}:`, result.error?.message);
-                        }
-                    }
-                    catch (error) {
-                        console.error(`  ❌ Failed to push ${serverConfig.name}:`, error.message);
+                const result = await mcpH.upsertOnServer(apiKey, agentId, serverConfig);
+                if (result.success && result.id) {
+                    writeSuccess(`  ✅ ${serverConfig.name} (${serverConfig.transport})`);
+                    if (options.autoDeploy && !result.active) {
+                        const activateResult = await mcpH.activate(apiKey, agentId, result.id);
+                        if (activateResult.success)
+                            writeSuccess(`     🔌 Auto-activated`);
                     }
                 }
+                else {
+                    console.error(`  ❌ Failed to push ${serverConfig.name}:`, result.error);
+                }
             }
             catch (error) {
-                console.error(`  ❌ Failed to push MCP servers:`, error.message);
+                console.error(`  ❌ Failed to push ${serverConfig.name}:`, error.message);
             }
         }
     }
-    // Step 10: 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)) {
+    // Step 6: Deploy all queued components
+    if (options.autoDeploy && toDeploy.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`);
-                }
+        for (const item of toDeploy) {
+            const deployed = await retryDeploy(async () => {
+                const result = await item.handler.publishVersion(apiKey, agentId, item.entityId, item.version);
+                if (!result.success)
+                    throw new Error(result.error || 'Deploy failed');
+            }, item.name, item.version, 3);
+            if (deployed) {
+                writeSuccess(`  🚀 ${item.name} v${item.version} deployed`);
             }
-        }
-        // 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 result = await webhookService.publishWebhookVersion(webhook.webhookId, webhook.version);
-                    if (!result.success) {
-                        throw new Error(result.error?.message || 'Failed to publish webhook');
-                    }
-                    return result;
-                }, webhook.name, webhook.version, 3);
-                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)...`);
-            const jobService = new JobApi(BASE_URLS.API, apiKey, agentId);
-            for (const job of toDeployJobs) {
-                const deployed = await retryDeploy(async () => {
-                    const result = await jobService.publishJobVersion(job.jobId, job.version);
-                    if (!result.success) {
-                        throw new Error(result.error?.message || 'Failed to publish job');
-                    }
-                    return result;
-                }, job.name, job.version, 3);
-                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(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`);
-                }
-                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(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`);
-                }
-                else {
-                    console.warn(`  ⚠️  ${processor.name} deployment failed`);
-                }
+            else {
+                console.warn(`  ⚠️  ${item.name} deployment failed`);
             }
         }
     }
-    // Step 10: Print summary
+    // Step 7: 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}`));
+    // Group results by kind for display
+    const byKind = new Map();
+    for (const r of allResults) {
+        const kind = r.handler.displayNamePlural;
+        if (!byKind.has(kind))
+            byKind.set(kind, []);
+        byKind.get(kind).push(r);
+    }
+    const summaryIcons = {
+        skills: '🛠️ ', webhooks: '🪝', jobs: '⏰', preprocessors: '📥', postprocessors: '📤',
+    };
+    for (const [kind, items] of byKind) {
+        const icon = summaryIcons[kind] || '📦';
+        console.log(`${icon} ${kind.charAt(0).toUpperCase() + kind.slice(1)} (${items.length}):`);
+        items.forEach(i => console.log(`   • ${i.name} v${i.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