lua-cli 3.11.0 → 3.12.0

package/dist/commands/integrations.js

@@ -759,69 +759,83 @@ async function connectIntegrationFlow(context, options = {}) {
                 }
             }
             else {
-                // Interactive: show trigger selection
+                // Interactive: opt-in gate — ask before showing trigger selector
                 console.log('\n' + '─'.repeat(60));
-                console.log('📡 Webhook Triggers');
+                console.log('📡 Webhook Triggers (Optional)');
                 console.log('─'.repeat(60));
-                console.log('\nSelect events that will wake up your agent:');
-                console.log('(Space to toggle, Enter to confirm. All selected by default.)');
-                const triggerAnswer = await safePrompt([{
-                        type: 'checkbox',
-                        name: 'triggers',
-                        message: 'Select triggers:',
-                        pageSize: 15,
-                        loop: false,
-                        choices: availableEvents.map(e => ({
-                            name: `${e.friendlyDescription} [${e.webhookType}]`,
-                            value: e,
-                            checked: true // Pre-select all by default
-                        }))
+                console.log('\nTriggers wake your agent when something happens in the integration.');
+                console.log('We recommend adding only what you actually need — you can always add them later.');
+                const wantTriggersAnswer = await safePrompt([{
+                        type: 'confirm',
+                        name: 'want',
+                        message: 'Do you want to configure triggers now?',
+                        default: false,
                     }]);
-                if (triggerAnswer && triggerAnswer.triggers.length > 0) {
-                    selectedTriggers = triggerAnswer.triggers;
-                    // Ask about webhook mode only if triggers are selected
-                    const modeAnswer = await safePrompt([{
-                            type: 'list',
-                            name: 'mode',
-                            message: 'How should these events be handled?',
-                            choices: [
-                                { name: '🤖 Agent Trigger (recommended) - Events wake up your agent', value: 'agent' },
-                                { name: '🔗 Custom URL - Send events to your own webhook URL', value: 'custom' }
-                            ]
+                if (!wantTriggersAnswer)
+                    return;
+                if (wantTriggersAnswer.want) {
+                    console.log('\nSelect the events you actually need:');
+                    console.log('(Space to toggle, Enter to confirm. Nothing pre-selected.)');
+                    const triggerAnswer = await safePrompt([{
+                            type: 'checkbox',
+                            name: 'triggers',
+                            message: 'Select triggers:',
+                            pageSize: 15,
+                            loop: false,
+                            choices: availableEvents.map(e => ({
+                                name: `${e.friendlyDescription} [${e.webhookType}]`,
+                                value: e,
+                                checked: false // None pre-selected — user chooses what they need
+                            }))
                         }]);
-                    if (!modeAnswer)
-                        return;
-                    if (modeAnswer.mode === 'custom') {
-                        isCustomWebhook = true;
-                        const urlAnswer = await safePrompt([{
-                                type: 'input',
-                                name: 'url',
-                                message: 'Enter your webhook URL:',
-                                validate: (input) => {
-                                    try {
-                                        new URL(input);
-                                        return true;
-                                    }
-                                    catch {
-                                        return 'Please enter a valid URL';
-                                    }
-                                }
+                    if (triggerAnswer && triggerAnswer.triggers.length > 0) {
+                        selectedTriggers = triggerAnswer.triggers;
+                        // Ask about webhook mode only if triggers are selected
+                        const modeAnswer = await safePrompt([{
+                                type: 'list',
+                                name: 'mode',
+                                message: 'How should these events be handled?',
+                                choices: [
+                                    { name: '🤖 Agent Trigger (recommended) - Events wake up your agent', value: 'agent' },
+                                    { name: '🔗 Custom URL - Send events to your own webhook URL', value: 'custom' }
+                                ]
                             }]);
-                        if (!urlAnswer)
+                        if (!modeAnswer)
                             return;
-                        webhookUrl = urlAnswer.url;
-                    }
-                    console.log(`\n✓ ${selectedTriggers.length} trigger(s) selected`);
-                    if (isCustomWebhook) {
-                        console.log(`  → Events will be sent to: ${webhookUrl}`);
+                        if (modeAnswer.mode === 'custom') {
+                            isCustomWebhook = true;
+                            const urlAnswer = await safePrompt([{
+                                    type: 'input',
+                                    name: 'url',
+                                    message: 'Enter your webhook URL:',
+                                    validate: (input) => {
+                                        try {
+                                            new URL(input);
+                                            return true;
+                                        }
+                                        catch {
+                                            return 'Please enter a valid URL';
+                                        }
+                                    }
+                                }]);
+                            if (!urlAnswer)
+                                return;
+                            webhookUrl = urlAnswer.url;
+                        }
+                        console.log(`\n✓ ${selectedTriggers.length} trigger(s) selected`);
+                        if (isCustomWebhook) {
+                            console.log(`  → Events will be sent to: ${webhookUrl}`);
+                        }
+                        else {
+                            console.log(`  → Events will wake up your agent`);
+                        }
                     }
                     else {
-                        console.log(`  → Events will wake up your agent`);
+                        console.log(`\n⏭️  No triggers selected`);
                     }
                 }
                 else {
-                    console.log(`\n⏭️  No triggers selected - your agent won't be event-driven`);
-                    console.log(`   You can add triggers later with: lua integrations webhooks create`);
+                    console.log(`\n⏭️  Skipping triggers — your agent will use manual invocation only`);
                 }
             }
         }
@@ -974,6 +988,9 @@ async function finalizeConnection(context, integration, connectionId, scopes, hi
             failedWebhooks.forEach(t => console.log(`    ✗ ${t.objectType}.${t.event}: ${t.error}`));
         }
     }
+    else {
+        console.log(`\n  ⚡ Triggers: none (add later with: lua triggers create --connection ${connectionId})`);
+    }
     // Summary message
     console.log("\n" + "─".repeat(60));
     const capabilities = [];
@@ -999,6 +1016,7 @@ async function finalizeConnection(context, integration, connectionId, scopes, hi
         integration_name: integration.name,
         mcp_server_active: mcpServer.active,
         webhooks_count: webhooks.length,
+        triggers_skipped_at_connect: webhooks.length === 0,
     });
 }
 async function listConnections(context) {
@@ -1411,6 +1429,7 @@ async function webhooksSubcommand(context, cmdOptions) {
         hookUrl: cmdOptions?.hookUrl,
         interval: cmdOptions?.interval ? parseInt(cmdOptions.interval, 10) : undefined,
         integration: cmdOptions?.integration,
+        reason: cmdOptions?.reason,
     };
     const jsonOutput = cmdOptions?.json === true;
     switch (subAction) {
@@ -1428,12 +1447,43 @@ async function webhooksSubcommand(context, cmdOptions) {
             }
             await webhooksDeleteFlow(context, options.webhookId);
             break;
+        case 'pause':
+            if (options.webhookId) {
+                await webhooksPauseFlow(context, options.webhookId, options.reason);
+            }
+            else if (options.connectionId) {
+                await connectionPauseFlow(context, options.connectionId);
+            }
+            else {
+                console.error("❌ --webhook-id or --connection-id is required for pause");
+                console.log("\n💡 Run 'lua integrations webhooks list' to see trigger IDs");
+                throw new Error("--webhook-id or --connection-id is required for pause");
+            }
+            break;
+        case 'resume':
+            if (options.webhookId) {
+                await webhooksResumeFlow(context, options.webhookId);
+            }
+            else if (options.connectionId) {
+                await connectionResumeFlow(context, options.connectionId);
+            }
+            else {
+                console.error("❌ --webhook-id or --connection-id is required for resume");
+                console.log("\n💡 Run 'lua integrations webhooks list' to see trigger IDs");
+                throw new Error("--webhook-id or --connection-id is required for resume");
+            }
+            break;
         case 'events':
             // New: List available webhook events for a connection or integration type
             await webhooksEventsFlow(context, options, jsonOutput);
             break;
+        case '':
+            // No sub-action: open interactive trigger management menu
+            // (covers `lua triggers` and `lua integrations webhooks` run bare)
+            await webhooksInteractiveMenu(context);
+            break;
         default:
-            console.error(`❌ Invalid webhooks action: "${subAction || '(none)'}"`);
+            console.error(`❌ Invalid webhooks action: "${subAction}"`);
             console.log('\nUsage:');
             console.log('  lua integrations webhooks list                              List triggers');
             console.log('  lua integrations webhooks events --connection <id>          List available events for a connection');
@@ -1441,7 +1491,11 @@ async function webhooksSubcommand(context, cmdOptions) {
             console.log('  lua integrations webhooks create                            Create trigger (interactive)');
             console.log('  lua integrations webhooks create --connection <id> --object <type> --event <event> --hook-url <url>');
             console.log('  lua integrations webhooks delete --webhook-id <id>          Delete trigger');
-            throw new Error("Invalid webhooks action:");
+            console.log('  lua integrations webhooks pause --webhook-id <id>           Pause a trigger');
+            console.log('  lua integrations webhooks pause --connection-id <id>        Pause all triggers for a connection');
+            console.log('  lua integrations webhooks resume --webhook-id <id>          Resume a trigger');
+            console.log('  lua integrations webhooks resume --connection-id <id>       Resume all triggers for a connection');
+            throw new Error(`Invalid webhooks action: ${subAction}`);
     }
 }
 /**
@@ -1547,8 +1601,12 @@ async function webhooksInteractiveMenu(context) {
             message: 'What would you like to do?',
             choices: [
                 { name: '📋 List triggers', value: 'list' },
-                { name: '➕ Create new subscription', value: 'create' },
-                { name: '🗑️  Delete subscription', value: 'delete' },
+                { name: '➕ Create new trigger', value: 'create' },
+                { name: '⏸️  Pause a trigger', value: 'pause' },
+                { name: '▶️  Resume a trigger', value: 'resume' },
+                { name: '⏸️  Pause all triggers for a connection', value: 'pauseConn' },
+                { name: '▶️  Resume all triggers for a connection', value: 'resumeConn' },
+                { name: '🗑️  Delete a trigger', value: 'delete' },
                 { name: '← Back', value: 'back' }
             ]
         }
@@ -1562,6 +1620,18 @@ async function webhooksInteractiveMenu(context) {
         case 'create':
             await webhooksCreateFlow(context, {});
             break;
+        case 'pause':
+            await webhooksPauseInteractive(context);
+            break;
+        case 'resume':
+            await webhooksResumeInteractive(context);
+            break;
+        case 'pauseConn':
+            await connectionPauseInteractive(context);
+            break;
+        case 'resumeConn':
+            await connectionResumeInteractive(context);
+            break;
         case 'delete':
             await webhooksDeleteInteractive(context);
             break;
@@ -1595,6 +1665,8 @@ async function webhooksListFlow(context, jsonOutput = false) {
                     webhookType: wh.webhookType,
                     hookUrl: wh.hookUrl,
                     status: wh.status,
+                    userPaused: wh.userPaused ?? false,
+                    creditSuspended: wh.creditSuspended ?? false,
                     interval: wh.interval,
                     connectionId: wh.connectionId,
                 })),
@@ -1607,8 +1679,8 @@ async function webhooksListFlow(context, jsonOutput = false) {
         console.log("─".repeat(60) + "\n");
         if (webhooks.length === 0) {
             console.log("ℹ️  No triggers configured yet.\n");
-            console.log("💡 Add triggers when connecting: lua integrations connect --triggers <events>");
-            console.log("   Or manually: lua integrations webhooks create\n");
+            console.log("💡 Add triggers when connecting: lua integrations connect");
+            console.log("   Or add one now:             lua integrations webhooks create\n");
             return;
         }
         // Group by integration
@@ -1622,12 +1694,31 @@ async function webhooksListFlow(context, jsonOutput = false) {
         for (const [integration, integrationWebhooks] of byIntegration) {
             console.log(`📦 ${integration}`);
             for (const wh of integrationWebhooks) {
-                const statusIcon = wh.status === 'active' ? '✅' : '⚪';
-                const typeLabel = wh.webhookType === 'native' ? 'push' : 'poll';
                 const isAgentTrigger = wh.hookUrl.includes('webhook/unifiedto');
                 const mode = isAgentTrigger ? 'agent trigger' : 'custom URL';
-                // Show webhook ID for delete operations
-                console.log(`   ${statusIcon} ${wh.objectType}.${wh.event} (${typeLabel}, ${mode})`);
+                const typeLabel = wh.webhookType === 'native' ? 'push' : 'poll';
+                // Determine display icon + status badge
+                let statusIcon;
+                let statusBadge = '';
+                if (wh.creditSuspended) {
+                    statusIcon = '💳';
+                    statusBadge = ' (credit-suspended)';
+                }
+                else if (wh.userPaused) {
+                    statusIcon = '⏸️';
+                    statusBadge = ' (paused by you)';
+                }
+                else if (wh.status === 'active') {
+                    statusIcon = '✅';
+                }
+                else if (wh.status === 'unhealthy') {
+                    statusIcon = '🔴';
+                    statusBadge = ' (unhealthy)';
+                }
+                else {
+                    statusIcon = '⚪';
+                }
+                console.log(`   ${statusIcon} ${wh.objectType}.${wh.event}${statusBadge} (${typeLabel}, ${mode})`);
                 console.log(`      ID: ${wh.id}`);
                 if (!isAgentTrigger) {
                     console.log(`      URL: ${wh.hookUrl}`);
@@ -1647,6 +1738,257 @@ async function webhooksListFlow(context, jsonOutput = false) {
         }
     }
 }
+/**
+ * Pause a single webhook subscription (non-interactive)
+ */
+async function webhooksPauseFlow(context, webhookId, reason) {
+    writeProgress("🔄 Pausing trigger...");
+    try {
+        const result = await context.unifiedToApi.pauseWebhookSubscription(context.agentId, webhookId, reason);
+        if (result.success) {
+            writeSuccess(`⏸️  Trigger paused: ${webhookId}\n`);
+            if (reason)
+                console.log(`   Reason: ${reason}`);
+            console.log(`\n💡 Resume later with: lua integrations webhooks resume --webhook-id ${webhookId}\n`);
+            trackEvent('cli_trigger_paused', { webhook_id: webhookId });
+        }
+        else {
+            writeError(`❌ Failed to pause trigger: ${result.error?.message}`);
+        }
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Resume a single webhook subscription (non-interactive)
+ */
+async function webhooksResumeFlow(context, webhookId) {
+    writeProgress("🔄 Resuming trigger...");
+    try {
+        const result = await context.unifiedToApi.resumeWebhookSubscription(context.agentId, webhookId);
+        if (result.success) {
+            writeSuccess(`▶️  Trigger resumed: ${webhookId}\n`);
+            trackEvent('cli_trigger_resumed', { webhook_id: webhookId });
+        }
+        else {
+            const code = result.error?.code;
+            if (code === 'CREDIT_SUSPENDED') {
+                writeError(`❌ Cannot resume: this trigger is suspended due to credit depletion.`);
+                console.log(`   Add credits to your account to re-enable webhook triggers.\n`);
+            }
+            else {
+                writeError(`❌ Failed to resume trigger: ${result.error?.message}`);
+            }
+        }
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Pause all triggers for a connection (non-interactive)
+ */
+async function connectionPauseFlow(context, connectionId) {
+    writeProgress("🔄 Pausing all triggers for connection...");
+    try {
+        const result = await context.unifiedToApi.pauseConnection(context.agentId, connectionId);
+        if (result.success && result.data) {
+            writeSuccess(`⏸️  Paused ${result.data.affectedWebhooks} trigger(s) for connection ${connectionId}\n`);
+            if (result.data.failedWebhooks > 0) {
+                console.log(`   ⚠️  ${result.data.failedWebhooks} trigger(s) failed to pause at Unified.to — check logs.\n`);
+            }
+            console.log(`\n💡 Resume later with: lua integrations webhooks resume --connection-id ${connectionId}\n`);
+            trackEvent('cli_connection_paused', { connection_id: connectionId, affected: result.data.affectedWebhooks, failed: result.data.failedWebhooks });
+        }
+        else {
+            writeError(`❌ Failed to pause connection triggers: ${result.error?.message}`);
+        }
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Resume all triggers for a connection (non-interactive)
+ */
+async function connectionResumeFlow(context, connectionId) {
+    writeProgress("🔄 Resuming triggers for connection...");
+    try {
+        const result = await context.unifiedToApi.resumeConnection(context.agentId, connectionId);
+        if (result.success && result.data) {
+            writeSuccess(`▶️  Resumed ${result.data.affectedWebhooks} trigger(s) for connection ${connectionId}\n`);
+            if (result.data.skippedCreditSuspended > 0) {
+                console.log(`   ⚠️  ${result.data.skippedCreditSuspended} trigger(s) skipped — suspended due to credit depletion.`);
+                console.log(`   Add credits to your account to re-enable them.\n`);
+            }
+            if (result.data.failedWebhooks > 0) {
+                console.log(`   ⚠️  ${result.data.failedWebhooks} trigger(s) failed to resume at Unified.to — check logs.\n`);
+            }
+            trackEvent('cli_connection_resumed', { connection_id: connectionId, affected: result.data.affectedWebhooks, skipped_credit: result.data.skippedCreditSuspended, failed: result.data.failedWebhooks });
+        }
+        else {
+            writeError(`❌ Failed to resume connection triggers: ${result.error?.message}`);
+        }
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Interactive: pause a single trigger
+ */
+async function webhooksPauseInteractive(context) {
+    writeProgress("🔄 Loading triggers...");
+    try {
+        const result = await context.unifiedToApi.getWebhookSubscriptions(context.agentId);
+        if (!result.success) {
+            writeError(`❌ Failed to load triggers: ${result.error?.message}`);
+            return;
+        }
+        const webhooks = (result.data || []).filter(wh => !wh.userPaused && wh.status !== 'unhealthy');
+        if (webhooks.length === 0) {
+            console.log("\nℹ️  No active triggers to pause.\n");
+            return;
+        }
+        const webhookAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'webhook',
+                message: 'Select a trigger to pause:',
+                choices: webhooks.map(wh => ({
+                    name: `${wh.integrationType} — ${wh.objectType}.${wh.event} (${wh.id.substring(0, 8)}...)`,
+                    value: wh.id,
+                }))
+            }
+        ]);
+        if (!webhookAnswer?.webhook)
+            return;
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Pause this trigger?`,
+                default: true,
+            }
+        ]);
+        if (!confirmAnswer?.confirm) {
+            console.log("\n❌ Cancelled.\n");
+            return;
+        }
+        await webhooksPauseFlow(context, webhookAnswer.webhook);
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Interactive: resume a single trigger
+ */
+async function webhooksResumeInteractive(context) {
+    writeProgress("🔄 Loading triggers...");
+    try {
+        const result = await context.unifiedToApi.getWebhookSubscriptions(context.agentId);
+        if (!result.success) {
+            writeError(`❌ Failed to load triggers: ${result.error?.message}`);
+            return;
+        }
+        const webhooks = (result.data || []).filter(wh => wh.userPaused && !wh.creditSuspended);
+        if (webhooks.length === 0) {
+            console.log("\nℹ️  No user-paused triggers to resume.\n");
+            return;
+        }
+        const webhookAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'webhook',
+                message: 'Select a trigger to resume:',
+                choices: webhooks.map(wh => ({
+                    name: `${wh.integrationType} — ${wh.objectType}.${wh.event} (${wh.id.substring(0, 8)}...)`,
+                    value: wh.id,
+                }))
+            }
+        ]);
+        if (!webhookAnswer?.webhook)
+            return;
+        await webhooksResumeFlow(context, webhookAnswer.webhook);
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Interactive: pause all triggers for a connection
+ */
+async function connectionPauseInteractive(context) {
+    try {
+        const connectionsResult = await context.unifiedToApi.getConnections(context.agentId);
+        const connections = connectionsResult.success ? connectionsResult.data || [] : [];
+        if (connections.length === 0) {
+            console.log("\nℹ️  No connected integrations.\n");
+            return;
+        }
+        const connectionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'connection',
+                message: 'Select a connection to pause all triggers:',
+                choices: connections.map(c => ({
+                    name: `${c.integrationName || c.integrationType} (${c.id.substring(0, 8)}...)${c.allTriggersPaused ? ' [all triggers paused]' : ''}`,
+                    value: c.id,
+                }))
+            }
+        ]);
+        if (!connectionAnswer?.connection)
+            return;
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Pause all triggers for this connection?`,
+                default: true,
+            }
+        ]);
+        if (!confirmAnswer?.confirm) {
+            console.log("\n❌ Cancelled.\n");
+            return;
+        }
+        await connectionPauseFlow(context, connectionAnswer.connection);
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
+/**
+ * Interactive: resume all triggers for a connection
+ */
+async function connectionResumeInteractive(context) {
+    try {
+        const connectionsResult = await context.unifiedToApi.getConnections(context.agentId);
+        const connections = connectionsResult.success ? connectionsResult.data || [] : [];
+        if (connections.length === 0) {
+            console.log("\nℹ️  No connected integrations.\n");
+            return;
+        }
+        const connectionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'connection',
+                message: 'Select a connection to resume triggers:',
+                choices: connections.map(c => ({
+                    name: `${c.integrationName || c.integrationType} (${c.id.substring(0, 8)}...)`,
+                    value: c.id,
+                }))
+            }
+        ]);
+        if (!connectionAnswer?.connection)
+            return;
+        await connectionResumeFlow(context, connectionAnswer.connection);
+    }
+    catch (error) {
+        writeError(`❌ Error: ${error.message}`);
+    }
+}
 /**
  * Create a webhook subscription
  */
@@ -1753,27 +2095,53 @@ async function webhooksCreateFlow(context, options) {
         hookUrl = options.hookUrl;
     }
     else {
-        const webhookAnswer = await safePrompt([
+        // Ask the user whether to use the built-in agent URL or a custom endpoint.
+        const urlModeAnswer = await safePrompt([
             {
-                type: 'input',
-                name: 'hookUrl',
-                message: 'Enter the full webhook URL to receive events:',
-                validate: (input) => {
-                    if (!input.trim())
-                        return 'Webhook URL is required';
-                    try {
-                        new URL(input);
-                        return true;
-                    }
-                    catch {
-                        return 'Enter a valid URL (e.g., https://webhook.heylua.ai/myagent/handler)';
-                    }
-                }
+                type: 'list',
+                name: 'urlMode',
+                message: 'Where should events be sent?',
+                choices: [
+                    {
+                        name: '🤖 Wake up my Lua agent (recommended)',
+                        value: 'agent',
+                    },
+                    {
+                        name: '🔗 Custom webhook URL',
+                        value: 'custom',
+                    },
+                ],
+                default: 'agent',
             }
         ]);
-        if (!webhookAnswer)
+        if (!urlModeAnswer)
             return;
-        hookUrl = webhookAnswer.hookUrl.trim();
+        if (urlModeAnswer.urlMode === 'agent') {
+            hookUrl = AGENT_WEBHOOK_URL;
+        }
+        else {
+            const webhookAnswer = await safePrompt([
+                {
+                    type: 'input',
+                    name: 'hookUrl',
+                    message: 'Enter the full webhook URL to receive events:',
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'Webhook URL is required';
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'Enter a valid URL (e.g., https://webhook.heylua.ai/myagent/handler)';
+                        }
+                    }
+                }
+            ]);
+            if (!webhookAnswer)
+                return;
+            hookUrl = webhookAnswer.hookUrl.trim();
+        }
     }
     // Step 6: Get interval for virtual webhooks
     let interval;
@@ -2239,20 +2607,28 @@ function showUsage() {
     console.log('  lua integrations info <type>                  Show integration details (scopes, triggers)');
     console.log('  lua integrations info <type> --json           Output as JSON for scripting');
     console.log('  lua integrations disconnect --connection-id <id>  Disconnect an integration');
-    console.log('\nTriggers:');
+    console.log('\nTriggers (also available as: lua triggers <action>):');
     console.log('  lua integrations webhooks list                List all triggers');
+    console.log('  lua integrations webhooks list --json         Output as JSON');
     console.log('  lua integrations webhooks events --connection <id>   List available events for a connection');
     console.log('  lua integrations webhooks events --integration <type> List available events for an integration');
     console.log('  lua integrations webhooks create              Create trigger (interactive)');
     console.log('  lua integrations webhooks create --connection <id> --object <type> --event <event> --hook-url <url>');
     console.log('  lua integrations webhooks delete --webhook-id <id>  Delete a trigger');
+    console.log('  lua integrations webhooks pause --webhook-id <id>   Pause a trigger');
+    console.log('  lua integrations webhooks pause --connection-id <id> Pause all triggers for a connection');
+    console.log('  lua integrations webhooks resume --webhook-id <id>  Resume a trigger');
+    console.log('  lua integrations webhooks resume --connection-id <id> Resume all triggers for a connection');
     console.log('\nMCP Server Management:');
     console.log('  lua integrations mcp list                     List connections with MCP status');
     console.log('  lua integrations mcp activate --connection <id>   Activate MCP server');
     console.log('  lua integrations mcp deactivate --connection <id> Deactivate MCP server');
     console.log('\nTrigger Options (use with connect):');
     console.log('  --triggers <events>       Comma-separated triggers (e.g., task_task.created,task_task.updated)');
+    console.log('                            Omit to skip triggers and add them later');
     console.log('  --custom-webhook          Use custom URL instead of agent trigger');
     console.log('  --hook-url <url>          Custom URL for triggers');
+    console.log('\nPause Options (use with webhooks pause):');
+    console.log('  --reason <text>           Optional reason for pausing (informational)');
 }
 //# sourceMappingURL=integrations.js.map