lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/commands/push.js

@@ -2,6 +2,9 @@
  * 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';
@@ -10,10 +13,95 @@ import { safePrompt } from '../utils/prompt-handler.js';
 import { readDeployJson, validatePushConfig, validateDeployData, promptSkillSelection, 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';
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import PostProcessorApi from '../api/postprocessor.api.service.js';
 /**
- * Main push command - pushes a skill version to the server.
+ * Main push command - pushes a skill or persona version to the server.
  *
  * This command performs the following steps:
+ * 1. If type argument provided, uses it directly
+ * 2. Otherwise, prompts user to select 'skill' or 'persona'
+ * 3. Routes to appropriate push flow
+ *
+ * Use this command to:
+ * - Upload a new version of your skill or persona
+ * - Make your skill/persona available for testing in dev mode
+ * - Prepare your skill/persona for deployment
+ *
+ * Note: This does NOT deploy to production. Use `lua deploy` for that.
+ *
+ * @param type - Optional type argument ('skill' or 'persona')
+ * @returns Promise that resolves when push completes
+ */
+export async function pushCommand(type) {
+    return withErrorHandling(async () => {
+        let selectedType;
+        // Step 1: Check if type was provided as argument
+        if (type) {
+            // Validate the provided type
+            if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
+                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", or "postprocessor".`);
+                console.log('\nUsage:');
+                console.log('  lua push                - Interactive selection');
+                console.log('  lua push skill          - Push a skill directly');
+                console.log('  lua push persona        - Push a persona directly');
+                console.log('  lua push webhook        - Push a webhook directly');
+                console.log('  lua push job            - Push a job directly');
+                console.log('  lua push preprocessor   - Push a preprocessor directly');
+                console.log('  lua push postprocessor  - Push a postprocessor directly');
+                process.exit(1);
+            }
+            selectedType = type;
+        }
+        else {
+            // Step 2: Prompt for type selection
+            const typeAnswer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'type',
+                    message: 'What would you like to push?',
+                    choices: [
+                        { name: '🛠️  Skill', value: 'skill' },
+                        { name: '🪝 Webhook', value: 'webhook' },
+                        { name: '⏰ Job', value: 'job' },
+                        { name: '📥 PreProcessor', value: 'preprocessor' },
+                        { name: '📤 PostProcessor', value: 'postprocessor' },
+                        { name: '🌙 Persona', value: 'persona' }
+                    ]
+                }
+            ]);
+            if (!typeAnswer) {
+                console.log("Push cancelled.");
+                return;
+            }
+            selectedType = typeAnswer.type;
+        }
+        // Step 3: Route to appropriate function
+        if (selectedType === 'skill') {
+            await pushSkillVersion();
+        }
+        else if (selectedType === 'webhook') {
+            await pushWebhookVersion();
+        }
+        else if (selectedType === 'job') {
+            await pushJobVersion();
+        }
+        else if (selectedType === 'preprocessor') {
+            await pushPreProcessorVersion();
+        }
+        else if (selectedType === 'postprocessor') {
+            await pushPostProcessorVersion();
+        }
+        else {
+            await pushPersonaVersion();
+        }
+    }, "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
@@ -23,98 +111,878 @@ import { fetchVersions, publishVersion, } from '../utils/deploy-api.js';
  * 7. Extracts the specific skill's deploy data
  * 8. Pushes version to server
  *
- * Use this command to:
- * - Upload a new version of your skill
- * - Make your skill available for testing in dev mode
- * - Prepare your skill for deployment
+ * @returns Promise that resolves when push completes
+ */
+async function pushSkillVersion() {
+    // Step 1: Validate configuration
+    const config = readSkillConfig();
+    validatePushConfig(config);
+    // Step 2: Get available skills and prompt for selection
+    const availableSkills = getAvailableSkills(config);
+    if (availableSkills.length === 0) {
+        console.error("❌ 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;
+    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);
+    writeProgress("✅ Authenticated");
+    // Step 5: Compile the skill (always compile to ensure up-to-date, or if version was updated)
+    writeProgress("🔄 Compiling skill...");
+    await compileCommand();
+    // Step 6: Validate deploy data for the selected skill
+    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;
+    writeProgress("🔄 Pushing version to server...");
+    const result = await pushVersion(apiKey, agentId, 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)
+        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) {
+            await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
+        }
+    }
+    else if (result.error) {
+        console.error(`❌ ${result.error.message}`);
+        process.exit(1);
+    }
+    else {
+        console.error("❌ Failed to push version. Please try again.");
+        process.exit(1);
+    }
+}
+/**
+ * Push persona version to the server.
  *
- * Note: This does NOT deploy to production. Use `lua deploy` for that.
+ * This function performs the following steps:
+ * 1. Validates configuration has required fields
+ * 2. Loads current persona from lua.skill.yaml
+ * 3. Authenticates the user
+ * 4. Pushes persona version to server
+ * 5. Optionally deploys to production
  *
  * @returns Promise that resolves when push completes
  */
-export async function pushCommand() {
-    return withErrorHandling(async () => {
-        // Step 1: Validate configuration
+async function pushPersonaVersion() {
+    // Step 1: Validate configuration
+    const config = readSkillConfig();
+    if (!config || !config.agent?.agentId) {
+        console.error("❌ No agent configuration found. Please run 'lua init' first.");
+        process.exit(1);
+    }
+    // Step 2: Load current persona
+    const currentPersona = config.agent?.persona || '';
+    if (!currentPersona || !currentPersona.trim()) {
+        console.error("❌ No persona found in configuration. Please edit your persona first using 'lua persona'.");
+        process.exit(1);
+    }
+    writeInfo(`📦 Pushing persona for agent: ${config.agent.agentId}`);
+    // Show preview of persona
+    const preview = currentPersona.length > 200
+        ? currentPersona.substring(0, 200) + '...'
+        : currentPersona;
+    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
+        }
+    ]);
+    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);
+    writeProgress("✅ Authenticated");
+    // Step 5: Push persona version to server
+    writeProgress("🔄 Creating persona version...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${config.agent.agentId}/persona/version`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ persona: currentPersona })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error! status: ${response.status}, ${errorText}`);
+        }
+        const 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) {
+            await deployPersonaVersionAfterPush(apiKey, config.agent.agentId, versionNum);
+        }
+        else {
+            writeInfo("💡 You can deploy this version later using: lua deploy");
+        }
+    }
+    catch (error) {
+        console.error('❌ Error creating persona version:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Deploy a persona version immediately after pushing
+ */
+async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum) {
+    try {
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy this persona version?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled. Persona version created but not deployed.\n");
+            return;
+        }
+        writeProgress("🔄 Deploying persona version...");
+        const deployResponse = await fetch(`${BASE_URLS.API}/developer/agents/${agentId}/persona/version/${versionNum}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!deployResponse.ok) {
+            const errorText = await deployResponse.text();
+            console.error(`\n❌ Deploy Error: ${deployResponse.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${deployResponse.status}`);
+        }
+        writeSuccess(`\n✅ Persona version ${versionNum} deployed successfully to production\n`);
+        writeInfo("💡 The new persona is now active for all users.");
+    }
+    catch (error) {
+        console.error('\n❌ Error deploying persona version:', error);
+        console.log('💡 You can deploy later using: lua persona\n');
+    }
+}
+/**
+ * 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
+ */
+async function pushWebhookVersion() {
+    try {
+        // Step 1: Run compilation
+        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);
+        writeSuccess("✅ Authentication verified");
+        // Step 3: Read configuration
         const config = readSkillConfig();
-        validatePushConfig(config);
-        // Step 2: Get available skills and prompt for selection
-        const availableSkills = getAvailableSkills(config);
-        if (availableSkills.length === 0) {
-            console.error("❌ No skills found in configuration. Please compile your skill first using 'lua compile'.");
+        if (!config?.agent?.agentId) {
+            console.error("❌ 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("💡 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);
         }
-        let selectedSkill;
-        if (availableSkills.length === 1) {
-            // Only one skill, use it automatically
-            selectedSkill = availableSkills[0];
-            writeInfo(`📦 Pushing skill: ${selectedSkill.name}`);
+        // Step 5: Confirm or update version (same as skills)
+        const confirmedVersion = await promptVersionConfirmOrUpdate(selectedWebhook.version);
+        let versionToPush = confirmedVersion;
+        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)
+        const webhookData = {
+            name: selectedWebhook.name,
+            version: versionToPush,
+            description: bundledWebhookData.description || selectedWebhook.description || `Webhook: ${selectedWebhook.name}`,
+            context: bundledWebhookData.context || selectedWebhook.context || '',
+            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
+        };
+        // Step 7: Push to server
+        writeProgress(`\n🚀 Pushing ${selectedWebhook.name} v${versionToPush} to server...`);
+        const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${config.agent.agentId}/${selectedWebhook.webhookId}/version`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(webhookData)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`\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`);
+        writeInfo(`📦 Webhook URL: ${BASE_URLS.API}/webhooks/${config.agent.agentId}/${selectedWebhook.webhookId}`);
+        // 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);
         }
         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;
-        if (confirmedVersion !== selectedSkill.version) {
-            writeInfo(`📝 Updating version from ${selectedSkill.version} to ${confirmedVersion}`);
-            updateSkillVersionInYaml(selectedSkill.name, confirmedVersion);
-            selectedSkill.version = confirmedVersion;
-            versionUpdated = true;
-        }
-        // Step 4: Authenticate
+            writeInfo("💡 You can deploy this version later using: lua webhooks production");
+        }
+    }
+    catch (error) {
+        console.error('❌ Error pushing webhook version:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Deploy a webhook version immediately after pushing
+ */
+async function deployWebhookVersionAfterPush(apiKey, agentId, selectedWebhook, pushedVersion) {
+    try {
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+            return;
+        }
+        writeProgress("🔄 Publishing webhook version...");
+        const publishResponse = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${selectedWebhook.webhookId}/${pushedVersion}/publish`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!publishResponse.ok) {
+            const errorText = await publishResponse.text();
+            console.error(`\n❌ Deploy Error: ${publishResponse.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${publishResponse.status}`);
+        }
+        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() {
+    try {
+        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);
         }
-        const userData = await checkApiKey(apiKey);
-        writeProgress("✅ Authenticated");
-        // Step 5: Compile the skill (always compile to ensure up-to-date, or if version was updated)
-        writeProgress("🔄 Compiling skill...");
+        await checkApiKey(apiKey);
+        const config = readSkillConfig();
+        if (!config?.agent?.agentId) {
+            console.error("❌ 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("💡 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;
+        if (confirmedVersion !== selectedJob.version) {
+            writeInfo(`📝 Updating version from ${selectedJob.version} to ${confirmedVersion}`);
+            updateJobVersionInYaml(selectedJob.name, confirmedVersion);
+            versionToPush = confirmedVersion;
+        }
+        const jobData = {
+            name: selectedJob.name,
+            version: versionToPush,
+            description: bundledJobData.description || selectedJob.description || `Job: ${selectedJob.name}`,
+            context: bundledJobData.context || selectedJob.context || '',
+            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
+        };
+        writeProgress(`\n🚀 Pushing ${selectedJob.name} v${selectedJob.version} to server...`);
+        const response = await fetch(`${BASE_URLS.API}/developer/jobs/${config.agent.agentId}/${selectedJob.jobId}/version`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(jobData)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`\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);
+        }
+        else {
+            writeInfo("💡 You can deploy this version later using: lua jobs production");
+        }
+    }
+    catch (error) {
+        console.error('❌ Error pushing job version:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Deploy a job version immediately after pushing
+ */
+async function deployJobVersionAfterPush(apiKey, agentId, selectedJob, pushedVersion) {
+    try {
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+            return;
+        }
+        writeProgress("🔄 Publishing job version...");
+        const publishResponse = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${selectedJob.jobId}/${pushedVersion}/publish`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!publishResponse.ok) {
+            const errorText = await publishResponse.text();
+            console.error(`\n❌ Deploy Error: ${publishResponse.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${publishResponse.status}`);
+        }
+        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() {
+    try {
+        writeProgress("📦 Compiling project...");
         await compileCommand();
-        // Step 6: Validate deploy data for the selected skill
-        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;
-        writeProgress("🔄 Pushing version to server...");
-        const result = await pushVersion(apiKey, agentId, 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)
-            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([
+        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);
+        const config = readSkillConfig();
+        if (!config?.agent?.agentId) {
+            console.error("❌ 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.");
+            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: 'confirm',
-                    name: 'deployNow',
-                    message: 'Would you like to deploy this version to production now?',
-                    default: false
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select a preprocessor to push:',
+                    choices: preprocessors.map((p) => ({
+                        name: `${p.name} (v${p.version})`,
+                        value: p
+                    }))
                 }
             ]);
-            if (deployAnswer && deployAnswer.deployNow) {
-                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
+            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,
+                context: bundledData.context || selected.context,
+                preprocessorId: selected.preprocessorId,
+                code: bundledData.code,
+                executeFunction: bundledData.executeFunction
+            };
+            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");
+                }
+            }
+            else {
+                console.error(`❌ Failed to push: ${result.error?.message}`);
             }
         }
-        else if (result.error) {
-            console.error(`❌ ${result.error.message}`);
+    }
+    catch (error) {
+        console.error('❌ Error pushing preprocessor:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Deploy a preprocessor version immediately after pushing
+ */
+async function deployPreProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion) {
+    try {
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy?',
+                default: false
+            }
+        ]);
+        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() {
+    try {
+        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);
         }
-        else {
-            console.error("❌ Failed to push version. Please try again.");
+        await checkApiKey(apiKey);
+        const config = readSkillConfig();
+        if (!config?.agent?.agentId) {
+            console.error("❌ No agent ID found in lua.skill.yaml.");
             process.exit(1);
         }
-    }, "push");
+        const postprocessors = config.postprocessors || [];
+        if (postprocessors.length === 0) {
+            console.error("❌ 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,
+                context: bundledData.context || selected.context,
+                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");
+                }
+            }
+            else {
+                console.error(`❌ Failed to push: ${result.error?.message}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error('❌ Error pushing postprocessor:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Deploy a postprocessor version immediately after pushing
+ */
+async function deployPostProcessorVersionAfterPush(apiKey, agentId, selected, pushedVersion) {
+    try {
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+            return;
+        }
+        writeProgress("🔄 Publishing postprocessor version...");
+        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        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✅ 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);
+    }
 }
 /**
  * Deploy a version immediately after pushing