lua-cli 3.2.0 → 3.4.0

package/dist/commands/push.js

@@ -10,7 +10,7 @@ import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
 import { safePrompt } from '../utils/prompt-handler.js';
-import { readDeployJson, validatePushConfig, validateDeployData, promptSkillSelection, promptVersionConfirmOrUpdate, getAvailableSkills, updateSkillVersionInYaml, getSkillDeployData, } from '../utils/push-helpers.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 { BASE_URLS } from '../config/constants.js';
@@ -18,6 +18,127 @@ 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 { loadPersonaFromCode } from '../utils/agent-code-utils.js';
+// ============================================================================
+// Core Push Helpers (shared by all push functions)
+// ============================================================================
+/**
+ * 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;
+}
+/**
+ * Selects an entity from a list, either by options.entityName or interactive prompt
+ * @param items - Array of items to select from
+ * @param options - Push options with entityName
+ * @param config - Configuration for selection behavior
+ */
+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);
+    }
+    // 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);
+        }
+        writeInfo(`📦 Selected ${entityType}: ${found.name}`);
+        return found;
+    }
+    // Single item: use it automatically
+    if (items.length === 1) {
+        writeInfo(`📦 Pushing ${entityType}: ${items[0].name}`);
+        return items[0];
+    }
+    // Multiple items: prompt for selection
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: `Select a ${entityType} to push:`,
+            choices: items.map((item) => ({
+                name: formatChoice ? formatChoice(item) : `${item.name} (v${item.version})`,
+                value: item
+            }))
+        }
+    ]);
+    if (!answer) {
+        console.log("Push cancelled.");
+        process.exit(0);
+    }
+    writeInfo(`📦 Selected ${entityType}: ${answer.selected.name}`);
+    return answer.selected;
+}
+/**
+ * Resolves version from options or interactive prompt
+ * Validates semantic versioning format
+ */
+async function resolveVersionOrFail(currentVersion, options) {
+    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);
+        }
+        writeInfo(`📝 Using version: ${options.version}`);
+        return options.version;
+    }
+    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
+ */
+async function shouldDeployAfterPush(options) {
+    // Auto-deploy flag takes precedence
+    if (options.autoDeploy) {
+        return true;
+    }
+    // Force mode skips the prompt (no deploy)
+    if (options.force) {
+        return false;
+    }
+    // Interactive: ask user
+    const answer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'deployNow',
+            message: 'Would you like to deploy this version to production now?',
+            default: false
+        }
+    ]);
+    return answer?.deployNow || false;
+}
 /**
  * Main push command - pushes a skill or persona version to the server.
  *
@@ -42,7 +163,9 @@ export async function pushCommand(type, cmdObj) {
         // Extract options from Commander command object
         const options = {
             force: cmdObj?.force || false,
-            autoDeploy: cmdObj?.autoDeploy || false
+            autoDeploy: cmdObj?.autoDeploy || false,
+            entityName: cmdObj?.name || null,
+            version: cmdObj?.version || null
         };
         let selectedType;
         // Handle 'all' type with force flag
@@ -56,6 +179,14 @@ export async function pushCommand(type, cmdObj) {
             }
             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);
+        }
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
@@ -101,123 +232,86 @@ export async function pushCommand(type, cmdObj) {
         }
         // Step 3: Route to appropriate function
         if (selectedType === 'skill') {
-            await pushSkillVersion();
+            await pushSkillVersion(options);
         }
         else if (selectedType === 'webhook') {
-            await pushWebhookVersion();
+            await pushWebhookVersion(options);
         }
         else if (selectedType === 'job') {
-            await pushJobVersion();
+            await pushJobVersion(options);
         }
         else if (selectedType === 'preprocessor') {
-            await pushPreProcessorVersion();
+            await pushPreProcessorVersion(options);
         }
         else if (selectedType === 'postprocessor') {
-            await pushPostProcessorVersion();
+            await pushPostProcessorVersion(options);
         }
         else if (selectedType === 'mcp') {
-            await pushMCPServerVersion();
+            await pushMCPServerVersion(options);
         }
         else {
-            await pushPersonaVersion();
+            await pushPersonaVersion(options);
         }
     }, "push");
 }
 /**
  * Push skill version to the server.
- *
- * This function performs the following steps:
- * 1. Validates configuration has required fields
- * 2. Prompts user to select a skill (if multiple skills exist)
- * 3. Prompts to confirm or update version
- * 4. Authenticates the user
- * 5. Compiles the skill (always, to ensure deploy.json is current)
- * 6. Validates deploy.json matches configuration for selected skill
- * 7. Extracts the specific skill's deploy data
- * 8. Pushes version to server
- *
- * @returns Promise that resolves when push completes
  */
-async function pushSkillVersion() {
+async function pushSkillVersion(options = {}) {
     // Step 1: Validate configuration
     const yamlConfig = readSkillConfig();
     validatePushConfig(yamlConfig);
     const config = yamlConfig;
-    // Step 2: Get available skills and prompt for selection
+    // Step 2: Get available skills and select
     const availableSkills = getAvailableSkills(config);
     if (availableSkills.length === 0) {
-        console.error("❌ No skills found in configuration. Please compile your skill first using 'lua compile'.");
+        console.log("❌ No skills found in configuration. Please compile your skill first using 'lua compile'.");
         process.exit(1);
     }
-    let selectedSkill;
-    if (availableSkills.length === 1) {
-        // Only one skill, use it automatically
-        selectedSkill = availableSkills[0];
-        writeInfo(`📦 Pushing skill: ${selectedSkill.name}`);
-    }
-    else {
-        // Multiple skills, prompt for selection
-        selectedSkill = await promptSkillSelection(availableSkills);
-        writeInfo(`📦 Selected skill: ${selectedSkill.name}`);
-    }
-    // Step 3: Confirm or update version
-    const confirmedVersion = await promptVersionConfirmOrUpdate(selectedSkill.version);
-    let versionUpdated = false;
+    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;
-        versionUpdated = true;
     }
     // Step 4: Authenticate
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-        process.exit(1);
-    }
-    const userData = await checkApiKey(apiKey);
+    const apiKey = await authenticateOrFail();
     writeProgress("✅ Authenticated");
-    // Step 5: Compile the skill (always compile to ensure up-to-date, or if version was updated)
+    // Step 5: Compile the skill
     writeProgress("🔄 Compiling skill...");
     await compileCommand();
-    // Step 6: Validate deploy data for the selected skill
+    // Step 6: Validate and extract deploy data
     const deployData = readDeployJson();
     validateDeployData(deployData, selectedSkill);
-    // Step 7: Extract the specific skill's deploy data
     const skillDeployData = getSkillDeployData(deployData, selectedSkill.name);
-    // Step 8: Push version to server
-    const agentId = config.agent.agentId;
-    const skillId = selectedSkill.skillId;
+    // Step 7: Push version to server
     writeProgress("🔄 Pushing version to server...");
-    const result = await pushVersion(apiKey, agentId, skillId, skillDeployData);
+    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 (in case it's different)
+        // 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;
         }
-        // Ask if user wants to deploy now
-        const deployAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'deployNow',
-                message: 'Would you like to deploy this version to production now?',
-                default: false
-            }
-        ]);
-        if (deployAnswer && deployAnswer.deployNow) {
+        // Step 8: Deploy if requested
+        if (await shouldDeployAfterPush(options)) {
             await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
         }
     }
     else if (result.error) {
-        console.error(`❌ ${result.error.message}`);
+        console.log(`❌ ${result.error.message}`);
         process.exit(1);
     }
     else {
-        console.error("❌ Failed to push version. Please try again.");
+        console.log("❌ Failed to push version. Please try again.");
         process.exit(1);
     }
 }
@@ -233,17 +327,17 @@ async function pushSkillVersion() {
  *
  * @returns Promise that resolves when push completes
  */
-async function pushPersonaVersion() {
+async function pushPersonaVersion(options = {}) {
     // Step 1: Validate configuration
     const config = readSkillConfig();
     if (!config || !config.agent?.agentId) {
-        console.error("❌ No agent configuration found. Please run 'lua init' first.");
+        console.log("❌ No agent configuration found. Please run 'lua init' first.");
         process.exit(1);
     }
     // Step 2: Load current persona from code
     const currentPersona = loadPersonaFromCode();
     if (!currentPersona || !currentPersona.trim()) {
-        console.error("❌ No persona found in configuration. Please edit your persona first using 'lua persona'.");
+        console.log("❌ No persona found in configuration. Please edit your persona first using 'lua persona'.");
         process.exit(1);
     }
     writeInfo(`📦 Pushing persona for agent: ${config.agent.agentId}`);
@@ -254,26 +348,23 @@ async function pushPersonaVersion() {
     console.log("\nPersona preview:");
     console.log(preview);
     console.log();
-    // Step 3: Confirm push
-    const confirmAnswer = await safePrompt([
-        {
-            type: 'confirm',
-            name: 'confirm',
-            message: 'Create new persona version?',
-            default: true
+    // Step 3: Confirm push (skip if --force provided)
+    if (!options.force) {
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Create new persona version?',
+                default: true
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Push cancelled.\n");
+            return;
         }
-    ]);
-    if (!confirmAnswer || !confirmAnswer.confirm) {
-        console.log("\n❌ Push cancelled.\n");
-        return;
     }
     // Step 4: Authenticate
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-        process.exit(1);
-    }
-    await checkApiKey(apiKey);
+    const apiKey = await authenticateOrFail();
     writeProgress("✅ Authenticated");
     // Step 5: Push persona version to server
     writeProgress("🔄 Creating persona version...");
@@ -293,16 +384,8 @@ async function pushPersonaVersion() {
         const data = await response.json();
         const versionNum = data.version || data.data?.version || 'N/A';
         writeSuccess(`✅ Persona version ${versionNum} created successfully`);
-        // Step 6: Ask if user wants to deploy now
-        const deployAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'deployNow',
-                message: 'Would you like to deploy this persona version to production now?',
-                default: false
-            }
-        ]);
-        if (deployAnswer && deployAnswer.deployNow) {
+        // Step 6: Deploy if requested
+        if (await shouldDeployAfterPush(options)) {
             await deployPersonaVersionAfterPush(apiKey, config.agent.agentId, versionNum);
         }
         else {
@@ -310,7 +393,7 @@ async function pushPersonaVersion() {
         }
     }
     catch (error) {
-        console.error('❌ Error creating persona version:', error);
+        console.log('❌ Error creating persona version:', error);
         process.exit(1);
     }
 }
@@ -367,90 +450,53 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum) {
  * 5. Push to server
  * 6. Optionally deploy immediately
  */
-async function pushWebhookVersion() {
+async function pushWebhookVersion(options = {}) {
     try {
-        // Step 1: Run compilation
+        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
         // Step 2: Authenticate
-        const apiKey = await loadApiKey();
-        if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-            process.exit(1);
-        }
-        await checkApiKey(apiKey);
+        const apiKey = await authenticateOrFail();
         writeSuccess("✅ Authentication verified");
         // Step 3: Read configuration
         const config = readSkillConfig();
         if (!config?.agent?.agentId) {
-            console.error("❌ No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
+            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.error("❌ No webhooks found in lua.skill.yaml.");
+            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 to push
-        const webhookAnswer = await safePrompt([
-            {
-                type: 'list',
-                name: 'selectedWebhook',
-                message: 'Select a webhook to push:',
-                choices: webhooks.map((webhook) => ({
-                    name: `${webhook.name} (v${webhook.version})`,
-                    value: webhook
-                }))
-            }
-        ]);
-        if (!webhookAnswer) {
-            console.log("Push cancelled.");
-            return;
-        }
-        const selectedWebhook = webhookAnswer.selectedWebhook;
-        // Step 4.5: Load bundled webhook data
-        const bundledWebhooksPath = path.join(process.cwd(), 'dist', 'webhooks.json');
-        let bundledWebhookData = {};
-        if (fs.existsSync(bundledWebhooksPath)) {
-            const bundledWebhooks = JSON.parse(fs.readFileSync(bundledWebhooksPath, 'utf8'));
-            bundledWebhookData = bundledWebhooks.find((w) => w.name === selectedWebhook.name) || {};
-            // Validate that the webhook exists in compiled code
-            if (!bundledWebhookData || Object.keys(bundledWebhookData).length === 0) {
-                console.error(`\n❌ Webhook "${selectedWebhook.name}" not found in compiled code.`);
-                console.log("💡 This webhook may have been removed or commented out in your code.");
-                console.log("💡 Please uncomment the webhook or remove it from lua.skill.yaml.");
-                process.exit(1);
-            }
-        }
-        else {
-            console.error('❌ Bundled webhook data not found.');
-            console.log("💡 Please ensure your webhook code is properly compiled.");
-            process.exit(1);
-        }
-        // Step 5: Confirm or update version (same as skills)
-        const confirmedVersion = await promptVersionConfirmOrUpdate(selectedWebhook.version);
-        let versionToPush = confirmedVersion;
+        // Step 4: Select webhook
+        const selectedWebhook = await selectEntityOrFail(webhooks, options, {
+            entityType: 'webhook',
+            nameFields: ['id', 'webhookId', 'name']
+        });
+        // 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);
-            versionToPush = confirmedVersion;
         }
-        // Step 6: Prepare webhook data for push (include bundled data)
+        // Step 7: Prepare and push webhook data
         const webhookData = {
             name: selectedWebhook.name,
-            version: versionToPush,
+            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, // Bundled and compressed code for execution
-            executeFunction: bundledWebhookData.executeFunction // Raw function for display/editing
+            code: bundledWebhookData.code,
+            executeFunction: bundledWebhookData.executeFunction
         };
-        // Step 7: Push to server
-        writeProgress(`\n🚀 Pushing ${selectedWebhook.name} v${versionToPush} to server...`);
+        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: {
@@ -461,31 +507,23 @@ async function pushWebhookVersion() {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            console.error(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
+            console.log(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
             throw new Error(`HTTP error! status: ${response.status}`);
         }
-        const result = await response.json();
-        writeSuccess(`\n✅ Successfully pushed ${selectedWebhook.name} v${versionToPush}\n`);
+        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: Ask if user wants to deploy now
-        const deployAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'deployNow',
-                message: 'Would you like to deploy this webhook version to production now?',
-                default: false
-            }
-        ]);
-        if (deployAnswer && deployAnswer.deployNow) {
-            await deployWebhookVersionAfterPush(apiKey, config.agent.agentId, selectedWebhook, versionToPush);
+        // Step 8: Deploy if requested
+        if (await shouldDeployAfterPush(options)) {
+            await deployWebhookVersionAfterPush(apiKey, config.agent.agentId, selectedWebhook, confirmedVersion);
         }
         else {
             writeInfo("💡 You can deploy this version later using: lua webhooks production");
         }
     }
     catch (error) {
-        console.error('❌ Error pushing webhook version:', error);
+        console.log('❌ Error pushing webhook version:', error);
         process.exit(1);
     }
 }
@@ -574,82 +612,53 @@ function updateJobVersionInYaml(jobName, newVersion) {
 /**
  * Push job version to the server (simplified version)
  */
-async function pushJobVersion() {
+async function pushJobVersion(options = {}) {
     try {
+        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
-        const apiKey = await loadApiKey();
-        if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-            process.exit(1);
-        }
-        await checkApiKey(apiKey);
+        // Step 2: Authenticate
+        const apiKey = await authenticateOrFail();
+        // Step 3: Read configuration
         const config = readSkillConfig();
         if (!config?.agent?.agentId) {
-            console.error("❌ No agent ID found in lua.skill.yaml.");
+            console.log("❌ No agent ID found in lua.skill.yaml.");
             process.exit(1);
         }
         const jobs = config.jobs || [];
         if (jobs.length === 0) {
-            console.error("❌ No jobs found in lua.skill.yaml.");
+            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);
         }
-        const jobAnswer = await safePrompt([
-            {
-                type: 'list',
-                name: 'selectedJob',
-                message: 'Select a job to push:',
-                choices: jobs.map((job) => ({
-                    name: `${job.name} (v${job.version})`,
-                    value: job
-                }))
-            }
-        ]);
-        if (!jobAnswer)
-            return;
-        const selectedJob = jobAnswer.selectedJob;
-        // Load bundled job data
-        const bundledJobsPath = path.join(process.cwd(), 'dist', 'jobs.json');
-        let bundledJobData = {};
-        if (fs.existsSync(bundledJobsPath)) {
-            const bundledJobs = JSON.parse(fs.readFileSync(bundledJobsPath, 'utf8'));
-            bundledJobData = bundledJobs.find((j) => j.name === selectedJob.name) || {};
-            // Validate that the job exists in compiled code
-            if (!bundledJobData || Object.keys(bundledJobData).length === 0) {
-                console.error(`\n❌ Job "${selectedJob.name}" not found in compiled code.`);
-                console.log("💡 This job may have been removed or commented out in your code.");
-                console.log("💡 Please uncomment the job or remove it from lua.skill.yaml.");
-                process.exit(1);
-            }
-        }
-        else {
-            console.error('❌ Bundled job data not found.');
-            console.log("💡 Please ensure your job code is properly compiled.");
-            process.exit(1);
-        }
-        // Confirm or update version (same as skills and webhooks)
-        const confirmedVersion = await promptVersionConfirmOrUpdate(selectedJob.version);
-        let versionToPush = confirmedVersion;
+        // 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);
-            versionToPush = confirmedVersion;
         }
+        // Step 7: Prepare and push
         const jobData = {
             name: selectedJob.name,
-            version: versionToPush,
+            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, // Bundled and compressed code for execution
-            executeFunction: bundledJobData.executeFunction, // Raw function for display/editing
-            metadata: bundledJobData.metadata || selectedJob.metadata // Optional metadata
+            code: bundledJobData.code,
+            executeFunction: bundledJobData.executeFunction,
+            metadata: bundledJobData.metadata || selectedJob.metadata
         };
-        writeProgress(`\n🚀 Pushing ${selectedJob.name} v${selectedJob.version} to server...`);
+        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: {
@@ -660,28 +669,20 @@ async function pushJobVersion() {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            console.error(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
+            console.log(`\n❌ Push Error: ${response.status} - ${errorText}\n`);
             throw new Error(`HTTP error! status: ${response.status}`);
         }
-        writeSuccess(`\n✅ Successfully pushed ${selectedJob.name} v${versionToPush}\n`);
-        // Ask if user wants to deploy now
-        const deployAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'deployNow',
-                message: 'Would you like to deploy this job version to production now?',
-                default: false
-            }
-        ]);
-        if (deployAnswer && deployAnswer.deployNow) {
-            await deployJobVersionAfterPush(apiKey, config.agent.agentId, selectedJob, versionToPush);
+        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);
         }
         else {
             writeInfo("💡 You can deploy this version later using: lua jobs production");
         }
     }
     catch (error) {
-        console.error('❌ Error pushing job version:', error);
+        console.log('❌ Error pushing job version:', error);
         process.exit(1);
     }
 }
@@ -730,96 +731,71 @@ async function deployJobVersionAfterPush(apiKey, agentId, selectedJob, pushedVer
 /**
  * Push preprocessor version to the server.
  */
-async function pushPreProcessorVersion() {
+async function pushPreProcessorVersion(options = {}) {
     try {
+        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
-        const apiKey = await loadApiKey();
-        if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-            process.exit(1);
-        }
-        await checkApiKey(apiKey);
+        // Step 2: Authenticate
+        const apiKey = await authenticateOrFail();
+        // Step 3: Read configuration
         const config = readSkillConfig();
         if (!config?.agent?.agentId) {
-            console.error("❌ No agent ID found in lua.skill.yaml.");
+            console.log("❌ No agent ID found in lua.skill.yaml.");
             process.exit(1);
         }
         const preprocessors = config.preprocessors || [];
         if (preprocessors.length === 0) {
-            console.error("❌ No preprocessors found in lua.skill.yaml.");
+            console.log("❌ No preprocessors found in lua.skill.yaml.");
             process.exit(1);
         }
-        // Load bundled preprocessor data
-        const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
-        let bundledData = {};
-        if (fs.existsSync(preprocessorsPath)) {
-            const bundled = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
-            // Select preprocessor
-            const answer = await safePrompt([
-                {
-                    type: 'list',
-                    name: 'selected',
-                    message: 'Select a preprocessor to push:',
-                    choices: preprocessors.map((p) => ({
-                        name: `${p.name} (v${p.version})`,
-                        value: p
-                    }))
-                }
-            ]);
-            if (!answer)
-                return;
-            const selected = answer.selected;
-            bundledData = bundled.find((p) => p.name === selected.name) || {};
-            if (!bundledData || !bundledData.code) {
-                console.error(`❌ PreProcessor "${selected.name}" not found in compiled code.`);
-                console.log("💡 Please uncomment the preprocessor or remove it from lua.skill.yaml.");
-                process.exit(1);
-            }
-            // Version confirmation
-            const confirmedVersion = await promptVersionConfirmOrUpdate(selected.version);
-            if (confirmedVersion !== selected.version) {
-                writeInfo(`📝 Updating version from ${selected.version} to ${confirmedVersion}`);
-                updateProcessorVersionInYaml('preprocessors', selected.name, confirmedVersion);
-            }
-            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) // Ensure boolean type
-            };
-            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`);
-                // Ask if user wants to deploy now
-                const deployAnswer = await safePrompt([
-                    {
-                        type: 'confirm',
-                        name: 'deployNow',
-                        message: 'Would you like to deploy this preprocessor version to production now?',
-                        default: false
-                    }
-                ]);
-                if (deployAnswer && deployAnswer.deployNow) {
-                    await deployPreProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion);
-                }
-                else {
-                    writeInfo("💡 You can deploy this version later using: lua preprocessors production");
-                }
+        // 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);
             }
             else {
-                console.error(`❌ Failed to push: ${result.error?.message}`);
+                writeInfo("💡 You can deploy this version later using: lua preprocessors production");
             }
         }
+        else {
+            console.log(`❌ Failed to push: ${result.error?.message}`);
+        }
     }
     catch (error) {
-        console.error('❌ Error pushing preprocessor:', error);
+        console.log('❌ Error pushing preprocessor:', error);
         process.exit(1);
     }
 }
@@ -861,95 +837,70 @@ async function deployPreProcessorVersionAfterPush(apiKey, agentId, selected, pus
 /**
  * Push postprocessor version to the server.
  */
-async function pushPostProcessorVersion() {
+async function pushPostProcessorVersion(options = {}) {
     try {
+        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
-        const apiKey = await loadApiKey();
-        if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-            process.exit(1);
-        }
-        await checkApiKey(apiKey);
+        // Step 2: Authenticate
+        const apiKey = await authenticateOrFail();
+        // Step 3: Read configuration
         const config = readSkillConfig();
         if (!config?.agent?.agentId) {
-            console.error("❌ No agent ID found in lua.skill.yaml.");
+            console.log("❌ No agent ID found in lua.skill.yaml.");
             process.exit(1);
         }
         const postprocessors = config.postprocessors || [];
         if (postprocessors.length === 0) {
-            console.error("❌ No postprocessors found in lua.skill.yaml.");
+            console.log("❌ No postprocessors found in lua.skill.yaml.");
             process.exit(1);
         }
-        // Load bundled postprocessor data
-        const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
-        let bundledData = {};
-        if (fs.existsSync(postprocessorsPath)) {
-            const bundled = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
-            // Select postprocessor
-            const answer = await safePrompt([
-                {
-                    type: 'list',
-                    name: 'selected',
-                    message: 'Select a postprocessor to push:',
-                    choices: postprocessors.map((p) => ({
-                        name: `${p.name} (v${p.version})`,
-                        value: p
-                    }))
-                }
-            ]);
-            if (!answer)
-                return;
-            const selected = answer.selected;
-            bundledData = bundled.find((p) => p.name === selected.name) || {};
-            if (!bundledData || !bundledData.code) {
-                console.error(`❌ PostProcessor "${selected.name}" not found in compiled code.`);
-                console.log("💡 Please uncomment the postprocessor or remove it from lua.skill.yaml.");
-                process.exit(1);
-            }
-            // Version confirmation
-            const confirmedVersion = await promptVersionConfirmOrUpdate(selected.version);
-            if (confirmedVersion !== selected.version) {
-                writeInfo(`📝 Updating version from ${selected.version} to ${confirmedVersion}`);
-                updateProcessorVersionInYaml('postprocessors', selected.name, confirmedVersion);
-            }
-            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`);
-                // Ask if user wants to deploy now
-                const deployAnswer = await safePrompt([
-                    {
-                        type: 'confirm',
-                        name: 'deployNow',
-                        message: 'Would you like to deploy this postprocessor version to production now?',
-                        default: false
-                    }
-                ]);
-                if (deployAnswer && deployAnswer.deployNow) {
-                    await deployPostProcessorVersionAfterPush(apiKey, config.agent.agentId, selected, confirmedVersion);
-                }
-                else {
-                    writeInfo("💡 You can deploy this version later using: lua postprocessors production");
-                }
+        // 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);
             }
             else {
-                console.error(`❌ Failed to push: ${result.error?.message}`);
+                writeInfo("💡 You can deploy this version later using: lua postprocessors production");
             }
         }
+        else {
+            console.log(`❌ Failed to push: ${result.error?.message}`);
+        }
     }
     catch (error) {
-        console.error('❌ Error pushing postprocessor:', error);
+        console.log('❌ Error pushing postprocessor:', error);
         process.exit(1);
     }
 }
@@ -1011,65 +962,78 @@ function updateProcessorVersionInYaml(processorType, processorName, newVersion)
 /**
  * Push MCP Server to the server
  */
-async function pushMCPServerVersion() {
+async function pushMCPServerVersion(options = {}) {
     try {
-        // Step 1: Run compilation
+        // Step 1: Compile
         writeProgress("📦 Compiling project...");
         await compileCommand();
         writeSuccess("✅ Compilation complete");
         // Step 2: Authenticate
-        const apiKey = await loadApiKey();
-        if (!apiKey) {
-            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
-            process.exit(1);
-        }
-        await checkApiKey(apiKey);
+        const apiKey = await authenticateOrFail();
         writeSuccess("✅ Authentication verified");
         // Step 3: Read configuration
         const config = readSkillConfig();
         if (!config?.agent?.agentId) {
-            console.error("❌ No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
+            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.error("❌ No MCP servers found in lua.skill.yaml.");
+            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 first (has full config)
+        // Step 4: Load bundled MCP server data
         const bundledServersPath = path.join(process.cwd(), 'dist', 'mcp-servers.json');
-        let bundledServers = [];
-        if (fs.existsSync(bundledServersPath)) {
-            bundledServers = JSON.parse(fs.readFileSync(bundledServersPath, 'utf8'));
-        }
-        else {
-            console.error('❌ Bundled MCP server data not found.');
+        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);
         }
-        // Step 5: Select MCP server to push (use bundled data for display, YAML for ID tracking)
-        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 }
-                    };
-                })
+        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);
             }
-        ]);
-        if (!serverAnswer) {
-            console.log("Push cancelled.");
-            return;
+            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;
         }
-        const selectedServer = serverAnswer.selectedServer;
-        const 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,
@@ -1077,28 +1041,22 @@ async function pushMCPServerVersion() {
             ...(bundledServerData.transport === 'stdio' ? {
                 command: bundledServerData.command,
                 args: bundledServerData.args,
-                env: bundledServerData.env
+                env: bundledServerData.env,
+                envResolver: bundledServerData.envResolver, // Compressed function for runtime resolution
             } : {
                 url: bundledServerData.url,
-                headers: bundledServerData.headers
+                urlResolver: bundledServerData.urlResolver, // Compressed function for runtime resolution
+                headers: bundledServerData.headers,
+                headersResolver: bundledServerData.headersResolver, // Compressed function for runtime resolution
             })
         };
-        // Step 7: Push to server (upsert)
         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`);
-            // Ask if user wants to activate now
-            const activateAnswer = await safePrompt([
-                {
-                    type: 'confirm',
-                    name: 'activateNow',
-                    message: 'Would you like to activate this MCP server now?',
-                    default: false
-                }
-            ]);
-            if (activateAnswer && activateAnswer.activateNow) {
+            // 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) {
@@ -1106,7 +1064,7 @@ async function pushMCPServerVersion() {
                     writeInfo("💡 The server's tools are now available to your agent.");
                 }
                 else {
-                    console.error(`❌ Failed to activate: ${activateResult.error?.message}`);
+                    console.log(`❌ Failed to activate: ${activateResult.error?.message}`);
                 }
             }
             else {
@@ -1114,11 +1072,11 @@ async function pushMCPServerVersion() {
             }
         }
         else {
-            console.error(`❌ Failed to push: ${result.error?.message}`);
+            console.log(`❌ Failed to push: ${result.error?.message}`);
         }
     }
     catch (error) {
-        console.error('❌ Error pushing MCP server:', error);
+        console.log('❌ Error pushing MCP server:', error);
         process.exit(1);
     }
 }