lua-cli 2.5.8 → 3.0.0-alpha.4

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';
@@ -11,6 +14,8 @@ import { readDeployJson, validatePushConfig, validateDeployData, promptSkillSele
 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 or persona version to the server.
  *
@@ -35,12 +40,16 @@ export async function pushCommand(type) {
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
-            if (type !== 'skill' && type !== 'persona') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill" or "persona".`);
+            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                - 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;
@@ -54,6 +63,10 @@ export async function pushCommand(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' }
                     ]
                 }
@@ -68,6 +81,18 @@ export async function pushCommand(type) {
         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();
         }
@@ -305,6 +330,662 @@ async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum) {
         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();
+        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);
+        }
+        // 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.WEBHOOK}/${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 {
+            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);
+        }
+        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();
+        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: '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,
+                context: bundledData.context || selected.context,
+                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");
+                }
+            }
+            else {
+                console.error(`❌ Failed to push: ${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);
+        }
+        await checkApiKey(apiKey);
+        const config = readSkillConfig();
+        if (!config?.agent?.agentId) {
+            console.error("❌ 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.");
+            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,
+                async: Boolean(bundledData.async ?? false) // Ensure boolean type
+            };
+            writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion}...`);
+            const api = new PostProcessorApi(BASE_URLS.API, apiKey, config.agent.agentId);
+            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
  */