lua-cli 3.2.0 → 3.4.0

package/dist/commands/webhooks.js

@@ -9,22 +9,23 @@ import { BASE_URLS } from '../config/constants.js';
 import { safePrompt } from '../utils/prompt-handler.js';
 import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
 import WebhookApi from '../api/webhook.api.service.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Command Entry
+// ─────────────────────────────────────────────────────────────────────────────
 /**
- * Main webhooks command - manages agent webhooks
+ * Main webhooks command - manages agent webhooks.
  *
- * Features:
- * - View deployed webhooks
- * - View webhook versions
- * - Deploy webhook versions to production
- * - Activate/deactivate webhooks
- *
- * Note: For local testing, use `lua test webhook`
- *
- * @returns Promise that resolves when command completes
+ * Supports both interactive and non-interactive modes:
+ * - Interactive: prompts for action and webhook selection
+ * - Non-interactive: use action argument with -i and -v flags
  */
-export async function webhooksCommand() {
+export async function webhooksCommand(action, cmdObj) {
     return withErrorHandling(async () => {
-        // Step 1: Load configuration first (to get agentId)
+        const options = {
+            webhookName: cmdObj?.webhookName || null,
+            webhookVersion: cmdObj?.webhookVersion || null,
+        };
+        // Step 1: Load configuration
         const config = readSkillConfig();
         validateConfig(config);
         validateAgentConfig(config);
@@ -42,14 +43,331 @@ export async function webhooksCommand() {
             agentId,
             apiKey,
         };
-        // Start webhook management
-        await manageProductionWebhooks(context, config);
+        // Determine mode
+        if (action) {
+            await executeNonInteractive(context, config, action, options);
+        }
+        else {
+            await manageWebhooksInteractive(context, config);
+        }
     }, "webhooks");
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared Core Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Displays all webhooks with their current status.
+ */
+async function displayWebhooksCore(context, webhooks) {
+    console.log("\n" + "=".repeat(60));
+    console.log("⚙️  Production Webhooks");
+    console.log("=".repeat(60) + "\n");
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    for (const webhook of webhooks) {
+        try {
+            const response = await webhookApi.getWebhookVersions(webhook.webhookId);
+            if (response.success && response.data) {
+                const versions = response.data.versions || [];
+                const activeVersionId = response.data.activeVersionId;
+                const activeVersion = versions.find((v) => v.webhookId === activeVersionId);
+                console.log(`🪝 ${webhook.name}`);
+                console.log(`   Webhook ID: ${webhook.webhookId}`);
+                if (activeVersion) {
+                    console.log(`   Deployed Version: ${activeVersion.version} ⭐`);
+                    console.log(`   Deployed: ${new Date(activeVersion.createdAt).toLocaleString()}`);
+                }
+                else {
+                    console.log(`   Deployed Version: Not deployed`);
+                }
+                console.log(`   Total Versions: ${versions.length}`);
+                console.log();
+            }
+            else {
+                displayWebhookError(webhook, "Unable to fetch version info");
+            }
+        }
+        catch {
+            displayWebhookError(webhook, "Error loading versions");
+        }
+    }
+    console.log("=".repeat(60));
+}
+function displayWebhookError(webhook, status) {
+    console.log(`🪝 ${webhook.name}`);
+    console.log(`   Webhook ID: ${webhook.webhookId}`);
+    console.log(`   Status: ${status}`);
+    console.log();
+}
+/**
+ * Fetches and returns sorted webhook versions.
+ */
+async function fetchVersionsCore(context, webhook) {
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await webhookApi.getWebhookVersions(webhook.webhookId);
+    if (!response.success || !response.data) {
+        console.error(`❌ Failed to fetch versions: ${response.error?.message || 'Unknown error'}`);
+        return null;
+    }
+    const versions = (response.data.versions || []).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return { versions, activeVersionId: response.data.activeVersionId };
+}
+/**
+ * Displays versions for a webhook.
+ */
+function displayVersionsCore(webhook, versions, activeVersionId) {
+    console.log("\n" + "=".repeat(60));
+    console.log(`📜 Versions for ${webhook.name}`);
+    console.log("=".repeat(60) + "\n");
+    versions.forEach((version, index) => {
+        const isActive = version.webhookId === activeVersionId;
+        console.log(`${index + 1}. Version ${version.version}${isActive ? ' ⭐ DEPLOYED' : ''}`);
+        console.log(`   Created: ${new Date(version.createdAt).toLocaleString()}`);
+        console.log(`   Version ID: ${version.webhookId}`);
+        console.log();
+    });
+    console.log("=".repeat(60));
+}
+/**
+ * Deploys a specific version of a webhook.
+ */
+async function deployVersionCore(context, webhook, version) {
+    writeProgress(`🔄 Deploying version ${version} of "${webhook.name}"...`);
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const deployResponse = await webhookApi.publishWebhookVersion(webhook.webhookId, version);
+    if (!deployResponse.success) {
+        console.error(`❌ Deploy Error: ${deployResponse.error?.message || 'Unknown error'}`);
+        return false;
+    }
+    writeSuccess(`✅ Version ${version} of "${webhook.name}" deployed successfully`);
+    writeInfo("💡 The new version is now active for all users.");
+    return true;
+}
+/**
+ * Activates a webhook.
+ */
+async function activateWebhookCore(context, webhook) {
+    writeProgress(`🔄 Activating webhook "${webhook.name}"...`);
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await webhookApi.activateWebhook(webhook.webhookId);
+    if (response.success) {
+        writeSuccess(`✅ Webhook "${webhook.name}" activated successfully`);
+        writeInfo("💡 The webhook is now enabled and can receive requests.");
+        return true;
+    }
+    else {
+        console.error(`❌ Failed to activate webhook: ${response.error?.message || 'Unknown error'}`);
+        return false;
+    }
+}
+/**
+ * Deactivates a webhook.
+ */
+async function deactivateWebhookCore(context, webhook) {
+    writeProgress(`🔄 Deactivating webhook "${webhook.name}"...`);
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await webhookApi.deactivateWebhook(webhook.webhookId);
+    if (response.success) {
+        writeSuccess(`✅ Webhook "${webhook.name}" deactivated successfully`);
+        writeInfo("💡 The webhook is now disabled and will not receive requests.");
+        return true;
+    }
+    else {
+        console.error(`❌ Failed to deactivate webhook: ${response.error?.message || 'Unknown error'}`);
+        return false;
+    }
+}
+/**
+ * Deletes a webhook from the server.
+ * If the webhook has versions, it will be deactivated instead of deleted.
+ */
+async function deleteWebhookCore(context, webhook) {
+    writeProgress(`🗑️  Deleting webhook "${webhook.name}"...`);
+    const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await webhookApi.deleteWebhook(webhook.webhookId);
+    if (!response.success || !response.data) {
+        console.error(`❌ Delete Error: ${response.error?.message || 'Unknown error'}`);
+        return false;
+    }
+    if (response.data.deleted) {
+        writeSuccess(`✅ Webhook "${webhook.name}" deleted successfully`);
+        writeInfo("💡 Remove this webhook from your lua.skill.yaml to keep it in sync.");
+    }
+    else if (response.data.deactivated) {
+        writeSuccess(`⚠️  Webhook "${webhook.name}" has versions and was deactivated instead of deleted`);
+        writeInfo("💡 The webhook is now inactive and won't receive requests.");
+    }
+    return true;
+}
+/**
+ * Resolves a version string to an actual version, supporting "latest".
+ */
+function resolveVersion(versions, versionArg) {
+    if (versionArg.toLowerCase() === 'latest') {
+        return versions[0].version;
+    }
+    const exists = versions.some((v) => v.version === versionArg);
+    if (!exists) {
+        console.error(`❌ Version "${versionArg}" not found`);
+        console.log('\nAvailable versions:');
+        versions.slice(0, 5).forEach((v) => console.log(`  - ${v.version}`));
+        return null;
+    }
+    return versionArg;
+}
+/**
+ * Prompts user to select a webhook from a list.
+ */
+async function promptWebhookSelection(webhooks, message) {
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedWebhook',
+            message,
+            choices: webhooks.map((webhook) => ({
+                name: `${webhook.name} (${webhook.webhookId})`,
+                value: webhook
+            }))
+        }
+    ]);
+    return answer?.selectedWebhook || null;
+}
 /**
- * Manage production webhooks - view and deploy versions
+ * Prompts user to select a version from a list.
  */
-async function manageProductionWebhooks(context, config) {
+async function promptVersionSelection(versions, activeVersionId) {
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedVersion',
+            message: 'Select a version to deploy:',
+            choices: versions.map((version) => {
+                const isActive = version.webhookId === activeVersionId;
+                return {
+                    name: `Version ${version.version} (${new Date(version.createdAt).toLocaleDateString()})${isActive ? ' ⭐ CURRENT' : ''}`,
+                    value: version
+                };
+            })
+        }
+    ]);
+    return answer?.selectedVersion || null;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Non-Interactive Mode
+// ─────────────────────────────────────────────────────────────────────────────
+async function executeNonInteractive(context, config, action, options) {
+    const validActions = ['view', 'versions', 'deploy', 'activate', 'deactivate', 'delete'];
+    const normalizedAction = action.toLowerCase();
+    if (!validActions.includes(normalizedAction)) {
+        console.error(`❌ Invalid action: "${action}"`);
+        console.log('\nValid actions: view, versions, deploy, activate, deactivate, delete');
+        console.log('\nExamples:');
+        console.log('  lua webhooks view                           List all webhooks');
+        console.log('  lua webhooks activate -i myWebhook          Activate a webhook');
+        console.log('  lua webhooks deploy -i myWebhook -v 1.0.3   Deploy specific version');
+        console.log('  lua webhooks delete -i myWebhook            Delete a webhook');
+        process.exit(1);
+    }
+    const webhooks = config.webhooks || [];
+    // View action doesn't require webhook selection
+    if (normalizedAction === 'view') {
+        if (webhooks.length === 0) {
+            console.log("ℹ️  No webhooks found in configuration.");
+            return;
+        }
+        await displayWebhooksCore(context, webhooks);
+        return;
+    }
+    // All other actions require webhook selection
+    if (!options.webhookName) {
+        console.error(`❌ --webhook-name is required for action "${normalizedAction}"`);
+        console.log(`\nUsage: lua webhooks ${normalizedAction} --webhook-name <name>`);
+        process.exit(1);
+    }
+    let selectedWebhook = webhooks.find((w) => w.webhookId === options.webhookName || w.name === options.webhookName);
+    // For delete action, also check server webhooks (for orphaned webhooks not in local YAML)
+    if (!selectedWebhook && normalizedAction === 'delete') {
+        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const serverResponse = await webhookApi.getWebhooks();
+        if (serverResponse.success && serverResponse.data?.webhooks) {
+            const serverWebhook = serverResponse.data.webhooks.find((w) => w.id === options.webhookName || w.name === options.webhookName);
+            if (serverWebhook) {
+                // Map server webhook format to local format for deleteWebhookCore
+                selectedWebhook = {
+                    name: serverWebhook.name,
+                    webhookId: serverWebhook.id,
+                };
+            }
+        }
+    }
+    if (!selectedWebhook) {
+        console.error(`❌ Webhook "${options.webhookName}" not found`);
+        console.log('\nAvailable webhooks in local config:');
+        webhooks.forEach((w) => console.log(`  - ${w.name} (${w.webhookId})`));
+        if (normalizedAction === 'delete') {
+            console.log('\n💡 Tip: The webhook may have already been deleted from the server.');
+        }
+        process.exit(1);
+    }
+    switch (normalizedAction) {
+        case 'versions': {
+            const data = await fetchVersionsCore(context, selectedWebhook);
+            if (!data)
+                process.exit(1);
+            if (data.versions.length === 0) {
+                console.log(`ℹ️  No versions found for ${selectedWebhook.name}.`);
+                console.log("💡 Push a version first using 'lua push webhook'.");
+                return;
+            }
+            displayVersionsCore(selectedWebhook, data.versions, data.activeVersionId);
+            break;
+        }
+        case 'deploy': {
+            if (!options.webhookVersion) {
+                console.error('❌ --webhook-version is required for deploy action');
+                console.log('\nUsage: lua webhooks deploy --webhook-name myWebhook --webhook-version 1.0.3');
+                console.log('       lua webhooks deploy -i myWebhook -v latest');
+                process.exit(1);
+            }
+            const data = await fetchVersionsCore(context, selectedWebhook);
+            if (!data)
+                process.exit(1);
+            if (data.versions.length === 0) {
+                console.error(`❌ No versions found for ${selectedWebhook.name}.`);
+                console.log("💡 Push a version first using 'lua push webhook'.");
+                process.exit(1);
+            }
+            const resolvedVersion = resolveVersion(data.versions, options.webhookVersion);
+            if (!resolvedVersion)
+                process.exit(1);
+            const success = await deployVersionCore(context, selectedWebhook, resolvedVersion);
+            if (!success)
+                process.exit(1);
+            break;
+        }
+        case 'activate': {
+            const success = await activateWebhookCore(context, selectedWebhook);
+            if (!success)
+                process.exit(1);
+            break;
+        }
+        case 'deactivate': {
+            const success = await deactivateWebhookCore(context, selectedWebhook);
+            if (!success)
+                process.exit(1);
+            break;
+        }
+        case 'delete': {
+            const success = await deleteWebhookCore(context, selectedWebhook);
+            if (!success)
+                process.exit(1);
+            break;
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Interactive Mode
+// ─────────────────────────────────────────────────────────────────────────────
+async function manageWebhooksInteractive(context, config) {
     let continueManaging = true;
     while (continueManaging) {
         console.log("\n" + "=".repeat(60));
@@ -66,6 +384,7 @@ async function manageProductionWebhooks(context, config) {
                     { name: '🚀 Deploy a version', value: 'deploy' },
                     { name: '✅ Activate a webhook', value: 'activate' },
                     { name: '🚫 Deactivate a webhook', value: 'deactivate' },
+                    { name: '🗑️  Delete a webhook', value: 'delete' },
                     { name: '❌ Exit', value: 'exit' }
                 ]
             }
@@ -75,19 +394,22 @@ async function manageProductionWebhooks(context, config) {
         const { action } = actionAnswer;
         switch (action) {
             case 'view':
-                await viewDeployedWebhooks(context, config);
+                await viewWebhooksInteractive(context, config);
                 break;
             case 'versions':
-                await viewWebhookVersions(context, config);
+                await viewVersionsInteractive(context, config);
                 break;
             case 'deploy':
-                await deployWebhookVersion(context, config);
+                await deployVersionInteractive(context, config);
                 break;
             case 'activate':
-                await activateWebhook(context, config);
+                await activateWebhookInteractive(context, config);
                 break;
             case 'deactivate':
-                await deactivateWebhook(context, config);
+                await deactivateWebhookInteractive(context, config);
+                break;
+            case 'delete':
+                await deleteWebhookInteractive(context, config);
                 break;
             case 'exit':
                 continueManaging = false;
@@ -96,303 +418,112 @@ async function manageProductionWebhooks(context, config) {
         }
     }
 }
-/**
- * View deployed webhooks in production
- */
-async function viewDeployedWebhooks(context, config) {
+async function viewWebhooksInteractive(context, config) {
     writeProgress("🔄 Loading webhook information...");
-    try {
-        const webhooks = config.webhooks || [];
-        if (webhooks.length === 0) {
-            console.log("\nℹ️  No webhooks found in configuration.\n");
-            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
-            return;
-        }
-        console.log("\n" + "=".repeat(60));
-        console.log("⚙️  Production Webhooks");
-        console.log("=".repeat(60) + "\n");
-        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
-        // Fetch version info for each webhook
-        for (const webhook of webhooks) {
-            try {
-                const response = await webhookApi.getWebhookVersions(webhook.webhookId);
-                if (response.success && response.data) {
-                    const versions = response.data.versions || [];
-                    const activeVersionId = response.data.activeVersionId;
-                    // Find active version
-                    const activeVersion = versions.find((v) => v.webhookId === activeVersionId);
-                    console.log(`🪝 ${webhook.name}`);
-                    console.log(`   Webhook ID: ${webhook.webhookId}`);
-                    if (activeVersion) {
-                        console.log(`   Deployed Version: ${activeVersion.version} ⭐`);
-                        const date = new Date(activeVersion.createdAt);
-                        console.log(`   Deployed: ${date.toLocaleString()}`);
-                    }
-                    else {
-                        console.log(`   Deployed Version: Not deployed`);
-                    }
-                    console.log(`   Total Versions: ${versions.length}`);
-                    console.log();
-                }
-                else {
-                    console.log(`🪝 ${webhook.name}`);
-                    console.log(`   Webhook ID: ${webhook.webhookId}`);
-                    console.log(`   Status: Unable to fetch version info`);
-                    console.log();
-                }
-            }
-            catch (error) {
-                console.log(`🪝 ${webhook.name}`);
-                console.log(`   Webhook ID: ${webhook.webhookId}`);
-                console.log(`   Status: Error loading versions`);
-                console.log();
-            }
-        }
-        console.log("=".repeat(60) + "\n");
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
     }
-    catch (error) {
-        console.error('❌ Error loading webhook information:', error);
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    else {
+        await displayWebhooksCore(context, webhooks);
+        console.log();
     }
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
-/**
- * View versions for a specific webhook
- */
-async function viewWebhookVersions(context, config) {
+async function viewVersionsInteractive(context, config) {
     const webhooks = config.webhooks || [];
     if (webhooks.length === 0) {
         console.log("\nℹ️  No webhooks found in configuration.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
         return;
     }
-    // Prompt to select a webhook
-    const webhookAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selectedWebhook',
-            message: 'Select a webhook to view versions:',
-            choices: webhooks.map((webhook) => ({
-                name: `${webhook.name} (${webhook.webhookId})`,
-                value: webhook
-            }))
-        }
-    ]);
-    if (!webhookAnswer)
+    const selectedWebhook = await promptWebhookSelection(webhooks, 'Select a webhook to view versions:');
+    if (!selectedWebhook)
         return;
-    const selectedWebhook = webhookAnswer.selectedWebhook;
     writeProgress(`🔄 Loading versions for ${selectedWebhook.name}...`);
-    try {
-        const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${context.agentId}/${selectedWebhook.webhookId}/versions`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const data = await response.json();
-        const versions = data.data?.versions || data.versions || [];
-        const activeVersionId = data.data?.activeVersionId || data.activeVersionId;
-        if (versions.length === 0) {
-            console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
-            console.log("💡 Push a version first using 'lua push webhook'.\n");
-            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
-            return;
-        }
-        console.log("\n" + "=".repeat(60));
-        console.log(`📜 Versions for ${selectedWebhook.name}`);
-        console.log("=".repeat(60) + "\n");
-        // Sort versions by date (newest first)
-        const sortedVersions = versions.sort((a, b) => {
-            const dateA = new Date(a.createdAt).getTime();
-            const dateB = new Date(b.createdAt).getTime();
-            return dateB - dateA;
-        });
-        sortedVersions.forEach((version, index) => {
-            const isActive = version.webhookId === activeVersionId;
-            const date = new Date(version.createdAt);
-            console.log(`${index + 1}. Version ${version.version}${isActive ? ' ⭐ DEPLOYED' : ''}`);
-            console.log(`   Created: ${date.toLocaleString()}`);
-            console.log(`   Version ID: ${version.webhookId}`);
-            console.log();
-        });
-        console.log("=".repeat(60) + "\n");
+    const data = await fetchVersionsCore(context, selectedWebhook);
+    if (!data) {
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
     }
-    catch (error) {
-        console.error('❌ Error loading versions:', error);
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    if (data.versions.length === 0) {
+        console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
+        console.log("💡 Push a version first using 'lua push webhook'.\n");
+    }
+    else {
+        displayVersionsCore(selectedWebhook, data.versions, data.activeVersionId);
+        console.log();
     }
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
-/**
- * Deploy a webhook version to production
- */
-async function deployWebhookVersion(context, config) {
+async function deployVersionInteractive(context, config) {
     const webhooks = config.webhooks || [];
     if (webhooks.length === 0) {
         console.log("\nℹ️  No webhooks found in configuration.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
         return;
     }
-    // Prompt to select a webhook
-    const webhookAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selectedWebhook',
-            message: 'Select a webhook to deploy:',
-            choices: webhooks.map((webhook) => ({
-                name: `${webhook.name} (${webhook.webhookId})`,
-                value: webhook
-            }))
-        }
-    ]);
-    if (!webhookAnswer)
+    const selectedWebhook = await promptWebhookSelection(webhooks, 'Select a webhook to deploy:');
+    if (!selectedWebhook)
         return;
-    const selectedWebhook = webhookAnswer.selectedWebhook;
     writeProgress(`🔄 Loading versions for ${selectedWebhook.name}...`);
-    try {
-        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
-        const response = await webhookApi.getWebhookVersions(selectedWebhook.webhookId);
-        if (!response.success || !response.data) {
-            throw new Error(response.error?.message || 'Failed to fetch versions');
-        }
-        const versions = response.data.versions || [];
-        const activeVersionId = response.data.activeVersionId;
-        if (versions.length === 0) {
-            console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
-            console.log("💡 Push a version first using 'lua push webhook'.\n");
-            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
-            return;
-        }
-        // Sort versions by date (newest first)
-        const sortedVersions = versions.sort((a, b) => {
-            const dateA = new Date(a.createdAt).getTime();
-            const dateB = new Date(b.createdAt).getTime();
-            return dateB - dateA;
-        });
-        // Prompt to select a version
-        const versionAnswer = await safePrompt([
-            {
-                type: 'list',
-                name: 'selectedVersion',
-                message: 'Select a version to deploy:',
-                choices: sortedVersions.map((version) => {
-                    const isActive = version.webhookId === activeVersionId;
-                    const date = new Date(version.createdAt);
-                    return {
-                        name: `Version ${version.version} (${date.toLocaleDateString()})${isActive ? ' ⭐ CURRENT' : ''}`,
-                        value: version
-                    };
-                })
-            }
-        ]);
-        if (!versionAnswer)
-            return;
-        const selectedVersion = versionAnswer.selectedVersion;
-        // Show warning
-        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
-        console.log("⚠️  This will affect ALL users immediately.\n");
-        console.log(`Webhook: ${selectedWebhook.name}`);
-        console.log(`Version: ${selectedVersion.version}\n`);
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you absolutely sure you want to deploy this version?',
-                default: false
-            }
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log("\n❌ Deployment cancelled.\n");
-            return;
-        }
-        writeProgress("🔄 Deploying version...");
-        // Reuse the same webhookApi instance
-        const deployResponse = await webhookApi.publishWebhookVersion(selectedWebhook.webhookId, selectedVersion.version);
-        if (!deployResponse.success) {
-            console.error(`\n❌ Deploy Error: ${deployResponse.error?.message || 'Unknown error'}\n`);
-            throw new Error(deployResponse.error?.message || 'Failed to publish webhook version');
-        }
-        writeSuccess(`\n✅ Version ${selectedVersion.version} of "${selectedWebhook.name}" deployed successfully to production\n`);
-        writeInfo("💡 The new version is now active for all users.");
+    const data = await fetchVersionsCore(context, selectedWebhook);
+    if (!data) {
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
     }
-    catch (error) {
-        console.error('\n❌ Error deploying version:', error);
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
-    }
-}
-/**
- * Activate a webhook
- */
-async function activateWebhook(context, config) {
-    const webhooks = config.webhooks || [];
-    if (webhooks.length === 0) {
-        console.log("\nℹ️  No webhooks found in configuration.\n");
+    if (data.versions.length === 0) {
+        console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
+        console.log("💡 Push a version first using 'lua push webhook'.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
         return;
     }
-    // Prompt to select a webhook
-    const webhookAnswer = await safePrompt([
+    const selectedVersion = await promptVersionSelection(data.versions, data.activeVersionId);
+    if (!selectedVersion)
+        return;
+    // Show warning and confirm
+    console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+    console.log("⚠️  This will affect ALL users immediately.\n");
+    console.log(`Webhook: ${selectedWebhook.name}`);
+    console.log(`Version: ${selectedVersion.version}\n`);
+    const confirmAnswer = await safePrompt([
         {
-            type: 'list',
-            name: 'selectedWebhook',
-            message: 'Select a webhook to activate:',
-            choices: webhooks.map((webhook) => ({
-                name: `${webhook.name} (${webhook.webhookId})`,
-                value: webhook
-            }))
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you absolutely sure you want to deploy this version?',
+            default: false
         }
     ]);
-    if (!webhookAnswer)
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deployment cancelled.\n");
         return;
-    const selectedWebhook = webhookAnswer.selectedWebhook;
-    writeProgress(`🔄 Activating webhook "${selectedWebhook.name}"...`);
-    try {
-        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
-        const response = await webhookApi.activateWebhook(selectedWebhook.webhookId);
-        if (!response.success) {
-            console.error(`\n❌ Error: ${response.error?.message || 'Unknown error'}\n`);
-            throw new Error(response.error?.message || 'Failed to activate webhook');
-        }
-        writeSuccess(`\n✅ Webhook "${selectedWebhook.name}" activated successfully\n`);
-        writeInfo("💡 The webhook is now enabled and can receive requests.");
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
     }
-    catch (error) {
-        console.error('\n❌ Error activating webhook:', error);
+    await deployVersionCore(context, selectedWebhook, selectedVersion.version);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+async function activateWebhookInteractive(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
     }
+    const selectedWebhook = await promptWebhookSelection(webhooks, 'Select a webhook to activate:');
+    if (!selectedWebhook)
+        return;
+    await activateWebhookCore(context, selectedWebhook);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
-/**
- * Deactivate a webhook
- */
-async function deactivateWebhook(context, config) {
+async function deactivateWebhookInteractive(context, config) {
     const webhooks = config.webhooks || [];
     if (webhooks.length === 0) {
         console.log("\nℹ️  No webhooks found in configuration.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
         return;
     }
-    // Prompt to select a webhook
-    const webhookAnswer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selectedWebhook',
-            message: 'Select a webhook to deactivate:',
-            choices: webhooks.map((webhook) => ({
-                name: `${webhook.name} (${webhook.webhookId})`,
-                value: webhook
-            }))
-        }
-    ]);
-    if (!webhookAnswer)
+    const selectedWebhook = await promptWebhookSelection(webhooks, 'Select a webhook to deactivate:');
+    if (!selectedWebhook)
         return;
-    const selectedWebhook = webhookAnswer.selectedWebhook;
-    // Confirm deactivation
     const confirmAnswer = await safePrompt([
         {
             type: 'confirm',
@@ -405,21 +536,34 @@ async function deactivateWebhook(context, config) {
         console.log("\n❌ Deactivation cancelled.\n");
         return;
     }
-    writeProgress(`🔄 Deactivating webhook "${selectedWebhook.name}"...`);
-    try {
-        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
-        const response = await webhookApi.deactivateWebhook(selectedWebhook.webhookId);
-        if (!response.success) {
-            console.error(`\n❌ Error: ${response.error?.message || 'Unknown error'}\n`);
-            throw new Error(response.error?.message || 'Failed to deactivate webhook');
-        }
-        writeSuccess(`\n✅ Webhook "${selectedWebhook.name}" deactivated successfully\n`);
-        writeInfo("💡 The webhook is now disabled and will not receive requests.");
+    await deactivateWebhookCore(context, selectedWebhook);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+async function deleteWebhookInteractive(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
         await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
     }
-    catch (error) {
-        console.error('\n❌ Error deactivating webhook:', error);
-        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    const selectedWebhook = await promptWebhookSelection(webhooks, 'Select a webhook to delete:');
+    if (!selectedWebhook)
+        return;
+    console.log("\n⚠️  WARNING: You are about to delete a webhook!");
+    console.log("⚠️  If the webhook has versions, it will be deactivated instead.\n");
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete "${selectedWebhook.name}"?`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deletion cancelled.\n");
+        return;
     }
+    await deleteWebhookCore(context, selectedWebhook);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
 //# sourceMappingURL=webhooks.js.map