npm - lua-cli - Versions diffs - 3.5.0-alpha.2 → 3.5.0-alpha.3 - Mend

lua-cli 3.5.0-alpha.2 → 3.5.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/api/unifiedto.api.service.d.ts +6 -0
package/dist/api/unifiedto.api.service.js +8 -0
package/dist/api/unifiedto.api.service.js.map +1 -1
package/dist/api/webhook.api.service.js +1 -1
package/dist/api/webhook.api.service.js.map +1 -1
package/dist/cli/command-definitions.js +31 -22
package/dist/cli/command-definitions.js.map +1 -1
package/dist/commands/integrations.d.ts +2 -2
package/dist/commands/integrations.js +741 -127
package/dist/commands/integrations.js.map +1 -1
package/dist/commands/push.js +204 -215
package/dist/commands/push.js.map +1 -1
package/dist/interfaces/unifiedto.d.ts +4 -0
package/package.json +1 -1
package/template/package.json +1 -1

package/dist/commands/integrations.js CHANGED Viewed

@@ -1,10 +1,10 @@
 /**
  * Integrations Command
- * Manages third-party account connections via Unified.to
+ * Manages third-party integrations via Unified.to
  *
  * Core concepts:
  * - Integration: A supported third-party service (e.g., Linear, Google Calendar)
- * - Connection: An authenticated link between your agent and a specific account
+ * - Connection: An authenticated link between your agent and a specific integration
  * - MCP Server: Technical implementation that exposes connection tools to the agent (auto-managed)
  *
  * Flow:
@@ -25,13 +25,16 @@ import { safePrompt } from '../utils/prompt-handler.js';
 import { validateConfig, validateAgentConfig } from '../utils/dev-helpers.js';
 import DeveloperApi from '../api/developer.api.service.js';
 import UnifiedToApi from '../api/unifiedto.api.service.js';
-import { fetchServersCore, activateServerCore, deactivateServerCore } from './mcp.js';
+import { fetchServersCore, activateServerCore, deactivateServerCore, } from './mcp.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // Configuration
 // ─────────────────────────────────────────────────────────────────────────────
 const UNIFIED_MCP_BASE_URL = 'https://mcp-api.unified.to/mcp';
 const CALLBACK_PORT = 19837; // Random high port for OAuth callback
 const CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+// Webhook trigger configuration
+const AGENT_WEBHOOK_URL = `${BASE_URLS.API}/webhook/unifiedto/data`;
+const DEFAULT_VIRTUAL_WEBHOOK_INTERVAL = 60; // minutes
 // ─────────────────────────────────────────────────────────────────────────────
 // Integration API Functions (via Lua API)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -98,7 +101,7 @@ function startCallbackServer(timeoutMs = 300000) {
             <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a2e;">
               <div style="text-align: center; color: white;">
                 <h1 style="color: #4ade80;">✅ Connection Successful!</h1>
-                <p style="color: #ccc;">Your account has been connected.</p>
+                <p style="color: #ccc;">Your integration has been connected.</p>
                 <p style="color: #888;">You can close this window and return to the terminal.</p>
               </div>
             </body>
@@ -182,7 +185,13 @@ async function executeNonInteractive(context, action, cmdOptions) {
         authMethod: cmdOptions?.authMethod,
         scopes: cmdOptions?.scopes,
         hideSensitive: cmdOptions?.hideSensitive !== 'false', // Default true, only false if explicitly set
+        // Trigger options
+        triggers: cmdOptions?.triggers,
+        customWebhook: cmdOptions?.customWebhook === true,
+        hookUrl: cmdOptions?.hookUrl,
     };
+    // Check for JSON output flag
+    const jsonOutput = cmdOptions?.json === true;
     switch (normalizedAction) {
         case 'connect':
             await connectIntegrationFlow(context, options);
@@ -201,6 +210,18 @@ async function executeNonInteractive(context, action, cmdOptions) {
         case 'available':
             await listAvailableIntegrations(context);
             break;
+        case 'info':
+            // New command: Show detailed info about an integration type
+            // Integration type can be passed as positional arg (info <type>) or as --integration flag
+            const infoIntegrationType = options.integration || cmdOptions?._?.[0];
+            if (!infoIntegrationType) {
+                console.error("❌ Integration type is required");
+                console.log("\nUsage: lua integrations info <type>");
+                console.log("       lua integrations info <type> --json");
+                process.exit(1);
+            }
+            await showIntegrationInfo(context, infoIntegrationType, jsonOutput);
+            break;
         case 'disconnect':
             if (!options.connectionId) {
                 console.error("❌ --connection-id is required for disconnect");
@@ -228,7 +249,7 @@ async function interactiveIntegrationsManagement(context) {
     let continueManaging = true;
     while (continueManaging) {
         console.log("\n" + "=".repeat(60));
-        console.log("🔗 Third-Party Integrations (via Unified.to)");
+        console.log("🔗 Integrations");
         console.log("=".repeat(60) + "\n");
         const actionAnswer = await safePrompt([
             {
@@ -236,13 +257,13 @@ async function interactiveIntegrationsManagement(context) {
                 name: 'action',
                 message: 'What would you like to do?',
                 choices: [
-                    { name: '➕ Connect a new account', value: 'connect' },
+                    { name: '➕ Connect a new integration', value: 'connect' },
                     { name: '🔄 Update connection scopes', value: 'update' },
-                    { name: '📋 List connected accounts', value: 'list' },
+                    { name: '📋 List connected integrations', value: 'list' },
                     { name: '🔍 View available integrations', value: 'available' },
-                    { name: '🔔 Manage webhook subscriptions', value: 'webhooks' },
+                    { name: '🔔 Manage triggers', value: 'webhooks' },
                     { name: '🔌 Manage MCP servers', value: 'mcp' },
-                    { name: '🗑️  Disconnect an account', value: 'disconnect' },
+                    { name: '🗑️  Disconnect an integration', value: 'disconnect' },
                     { name: '❌ Exit', value: 'exit' }
                 ]
             }
@@ -319,6 +340,130 @@ async function listAvailableIntegrations(context) {
     }
 }
 // ─────────────────────────────────────────────────────────────────────────────
+// Integration Info (Non-Interactive Discovery)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Show detailed information about an integration type
+ * Used for non-interactive discovery of OAuth scopes and webhook events
+ */
+async function showIntegrationInfo(context, integrationType, jsonOutput = false) {
+    try {
+        // Fetch integration details
+        const integrations = await fetchAvailableIntegrations(context.unifiedToApi);
+        const integration = integrations.find(i => i.value === integrationType);
+        if (!integration) {
+            if (jsonOutput) {
+                console.log(JSON.stringify({ error: `Integration not found: ${integrationType}` }));
+            }
+            else {
+                console.error(`❌ Integration not found: ${integrationType}`);
+                console.log('\nAvailable integrations:');
+                integrations.forEach(i => console.log(`  - ${i.value} (${i.name})`));
+            }
+            process.exit(1);
+        }
+        // Fetch available webhook events for this integration
+        let webhookEvents = [];
+        try {
+            const eventsResult = await context.unifiedToApi.getAvailableWebhookEventsByType(integrationType);
+            if (eventsResult.success && eventsResult.data) {
+                webhookEvents = eventsResult.data;
+            }
+        }
+        catch {
+            // Silently ignore if webhook events can't be fetched
+        }
+        if (jsonOutput) {
+            // Output as JSON for scripting
+            const output = {
+                type: integration.value,
+                name: integration.name,
+                categories: integration.categories,
+                authSupport: integration.authSupport,
+                oauthConfigured: integration.oauthConfigured,
+                oauthScopes: integration.oauthScopes || [],
+                tokenFields: integration.tokenFields || [],
+                webhookEvents: webhookEvents.map(e => ({
+                    trigger: `${e.objectType}.${e.event}`,
+                    objectType: e.objectType,
+                    event: e.event,
+                    webhookType: e.webhookType,
+                    friendlyLabel: e.friendlyLabel,
+                    friendlyDescription: e.friendlyDescription,
+                    availableFilters: e.availableFilters,
+                })),
+                webhookDefaults: {
+                    agentWebhookUrl: AGENT_WEBHOOK_URL,
+                    defaultVirtualInterval: DEFAULT_VIRTUAL_WEBHOOK_INTERVAL,
+                },
+            };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            // Human-readable output
+            console.log("\n" + "=".repeat(60));
+            console.log(`📋 Integration: ${integration.name}`);
+            console.log("=".repeat(60));
+            console.log(`\n  Type: ${integration.value}`);
+            console.log(`  Categories: ${integration.categories.join(', ')}`);
+            console.log(`  Auth Support: ${integration.authSupport}`);
+            console.log(`  OAuth Configured: ${integration.oauthConfigured ? 'Yes' : 'No'}`);
+            // OAuth Scopes
+            if (integration.oauthScopes && integration.oauthScopes.length > 0) {
+                console.log('\n  OAuth Scopes:');
+                integration.oauthScopes.forEach(s => {
+                    if (s.friendlyLabel) {
+                        console.log(`    - ${s.friendlyLabel} (${s.unifiedScope})`);
+                        if (s.friendlyDescription) {
+                            console.log(`      ${s.friendlyDescription}`);
+                        }
+                    }
+                    else {
+                        console.log(`    - ${s.unifiedScope} → [${s.originalScopes.join(', ')}]`);
+                    }
+                });
+            }
+            // Token Fields
+            if (integration.tokenFields && integration.tokenFields.length > 0) {
+                console.log('\n  Token Fields:');
+                integration.tokenFields.forEach(f => {
+                    console.log(`    - ${f.name}`);
+                    if (f.instructions) {
+                        console.log(`      💡 ${f.instructions}`);
+                    }
+                });
+            }
+            // Webhook Events/Triggers
+            if (webhookEvents.length > 0) {
+                console.log('\n  Available Triggers:');
+                webhookEvents.forEach(e => {
+                    console.log(`    - ${e.objectType}.${e.event} [${e.webhookType}] - ${e.friendlyDescription}`);
+                });
+            }
+            else {
+                console.log('\n  Available Triggers: None');
+            }
+            console.log("\n" + "=".repeat(60));
+            console.log("\n💡 Use with non-interactive commands:");
+            console.log(`   lua integrations connect --integration ${integrationType} --auth-method oauth --scopes all`);
+            if (webhookEvents.length > 0) {
+                const exampleTrigger = `${webhookEvents[0].objectType}.${webhookEvents[0].event}`;
+                console.log(`   lua integrations connect --integration ${integrationType} --triggers ${exampleTrigger}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            writeError(`❌ Failed to get integration info: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // Connect Flow
 // ─────────────────────────────────────────────────────────────────────────────
 async function connectIntegrationFlow(context, options = {}) {
@@ -527,11 +672,18 @@ async function connectIntegrationFlow(context, options = {}) {
                     message: 'Select OAuth scopes (Space to toggle, Enter to confirm, leave empty for all):',
                     pageSize: 15,
                     loop: false,
-                    choices: selectedIntegration.oauthScopes.map(s => ({
-                        name: `${s.unifiedScope}  →  [${s.originalScopes.join(', ')}]`,
-                        value: s.unifiedScope,
-                        checked: false
-                    }))
+                    choices: selectedIntegration.oauthScopes.map(s => {
+                        // Use friendly label if available, otherwise fall back to technical name
+                        const displayName = s.friendlyLabel || s.unifiedScope;
+                        const description = s.friendlyDescription
+                            ? `  (${s.friendlyDescription})`
+                            : `  →  [${s.originalScopes.join(', ')}]`;
+                        return {
+                            name: `${displayName}${description}`,
+                            value: s.unifiedScope,
+                            checked: false
+                        };
+                    })
                 }]);
             if (!scopeAnswer)
                 return;
@@ -577,7 +729,132 @@ async function connectIntegrationFlow(context, options = {}) {
             hideSensitive = sensitiveAnswer.hide;
         }
     }
-    // Step 4: Get authorization URL from Lua API
+    // Step 4: Select webhook triggers (agent wake-up events)
+    let selectedTriggers = [];
+    let webhookUrl = AGENT_WEBHOOK_URL; // Default: agent trigger mode
+    let isCustomWebhook = false;
+    try {
+        const eventsResult = await context.unifiedToApi.getAvailableWebhookEventsByType(selectedIntegration.value);
+        if (eventsResult.success && eventsResult.data && eventsResult.data.length > 0) {
+            const availableEvents = eventsResult.data;
+            // Determine webhook mode
+            if (options.customWebhook || options.hookUrl) {
+                isCustomWebhook = true;
+                if (options.hookUrl) {
+                    webhookUrl = options.hookUrl;
+                }
+            }
+            if (options.triggers) {
+                // Non-interactive: parse comma-separated triggers (e.g., 'task_task.created,task_task.updated')
+                const requestedTriggers = options.triggers.split(',').map(t => t.trim());
+                for (const trigger of requestedTriggers) {
+                    const [objectType, event] = trigger.split('.');
+                    const matchingEvent = availableEvents.find(e => e.objectType === objectType && e.event === event);
+                    if (!matchingEvent) {
+                        console.error(`❌ Invalid trigger: ${trigger}`);
+                        console.log(`\nAvailable triggers for ${selectedIntegration.name}:`);
+                        availableEvents.forEach(e => {
+                            console.log(`  - ${e.objectType}.${e.event} [${e.webhookType}] - ${e.friendlyDescription}`);
+                        });
+                        process.exit(1);
+                    }
+                    selectedTriggers.push(matchingEvent);
+                }
+                writeInfo(`Selected ${selectedTriggers.length} trigger(s)`);
+                // If custom webhook mode, prompt for URL if not provided
+                if (isCustomWebhook && !options.hookUrl) {
+                    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;
+                }
+            }
+            else {
+                // Interactive: show trigger selection
+                console.log('\n' + '─'.repeat(60));
+                console.log('📡 Webhook Triggers');
+                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
+                        }))
+                    }]);
+                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 (!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 (!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(`\n⏭️  No triggers selected - your agent won't be event-driven`);
+                    console.log(`   You can add triggers later with: lua integrations webhooks create`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Non-fatal: continue without triggers if we can't fetch events
+        writeInfo(`Note: Could not fetch available triggers (${error.message})`);
+    }
+    // Step 5: Get authorization URL from Lua API
     writeProgress("🔄 Preparing authorization...");
     const state = Buffer.from(JSON.stringify({
         agentId: context.agentId,
@@ -642,22 +919,24 @@ async function connectIntegrationFlow(context, options = {}) {
     const result = await callbackPromise;
     if (result.success && result.connectionId) {
         writeSuccess("\n✅ Authorization successful!");
-        // Finalize the connection (sets up MCP server internally)
-        await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive);
+        // Finalize the connection (sets up MCP server internally and creates webhooks)
+        await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive, {
+            triggers: selectedTriggers,
+            webhookUrl,
+            isCustomWebhook,
+        });
     }
     else {
         writeError(`\n❌ Authorization failed: ${result.error || 'Unknown error'}`);
         console.log("💡 Please try again with 'lua integrations connect'\n");
     }
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Connection Management
-// ─────────────────────────────────────────────────────────────────────────────
 /**
- * Finalizes a new connection by setting up the MCP server (internal implementation)
+ * Finalizes a new connection by setting up the MCP server and creating webhooks
  * The MCP server enables the agent to use tools from this connection
+ * Webhooks enable the agent to be triggered by events from the connection
  */
-async function finalizeConnection(context, integration, connectionId, scopes, hideSensitive = true) {
+async function finalizeConnection(context, integration, connectionId, scopes, hideSensitive = true, webhookConfig = { triggers: [], webhookUrl: '', isCustomWebhook: false }) {
     writeProgress(`🔄 Setting up ${integration.name} connection...`);
     // Build MCP URL
     let mcpUrl = `${UNIFIED_MCP_BASE_URL}?connection=${connectionId}`;
@@ -679,44 +958,154 @@ async function finalizeConnection(context, integration, connectionId, scopes, hi
         source: 'unifiedto', // Flag for runtime auth injection
         timeout: 30000,
     };
+    // ─────────────────────────────────────────────────────────────────────────
+    // Step 1: Set up MCP Server (for tools)
+    // ─────────────────────────────────────────────────────────────────────────
+    let mcpSetupSuccess = false;
+    let isActive = false;
+    let mcpError = null;
     try {
+        writeProgress(`🔄 Setting up MCP server...`);
         const result = await context.developerApi.createMCPServer(mcpServerData);
         if (result.success && result.data) {
             // Auto-activate the MCP server so the agent can use the connection immediately
             const activateResult = await context.developerApi.activateMCPServer(result.data.id);
-            const isActive = activateResult.success && activateResult.data?.active;
-            // Connection success message
-            console.log("\n" + "─".repeat(60));
-            console.log("🎉 Connection Established!");
-            console.log("─".repeat(60));
-            console.log(`\n  Integration: ${integration.name}`);
-            console.log(`  Connection ID: ${connectionId}`);
-            console.log(`  Status: ${isActive ? '🟢 Active' : '⚪ Pending'}`);
-            // Show requested scopes (actual capabilities)
-            if (scopes.length > 0) {
-                console.log(`\n  Scopes:`);
-                scopes.forEach(s => console.log(`    - ${s}`));
+            isActive = activateResult.success && activateResult.data?.active === true;
+            mcpSetupSuccess = true;
+        }
+        else {
+            mcpError = result.error?.message || 'Unknown error';
+        }
+    }
+    catch (error) {
+        mcpError = error.message || 'Unknown error';
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Step 2: Set up Webhook Triggers (for event-driven agent wake-up)
+    // ─────────────────────────────────────────────────────────────────────────
+    const createdWebhooks = [];
+    const failedWebhooks = [];
+    if (webhookConfig.triggers.length > 0) {
+        writeProgress(`🔄 Setting up ${webhookConfig.triggers.length} trigger(s)...`);
+        for (const trigger of webhookConfig.triggers) {
+            try {
+                // Use per-trigger hookUrl/interval if available, otherwise fall back to defaults
+                const hookUrl = trigger.hookUrl || webhookConfig.webhookUrl || AGENT_WEBHOOK_URL;
+                const interval = trigger.interval ?? (trigger.webhookType === 'virtual' ? DEFAULT_VIRTUAL_WEBHOOK_INTERVAL : undefined);
+                const webhookResult = await context.unifiedToApi.createWebhookSubscription(context.agentId, {
+                    connectionId,
+                    objectType: trigger.objectType,
+                    event: trigger.event,
+                    hookUrl,
+                    interval,
+                });
+                if (webhookResult.success && webhookResult.data) {
+                    createdWebhooks.push(webhookResult.data);
+                }
+                else {
+                    const errorMsg = webhookResult.error?.message || 'Unknown error';
+                    failedWebhooks.push(`${trigger.objectType}.${trigger.event}: ${errorMsg}`);
+                }
             }
-            else {
-                console.log(`\n  Scopes: Default permissions`);
+            catch (error) {
+                const errorMsg = error?.message || 'Unknown error';
+                failedWebhooks.push(`${trigger.objectType}.${trigger.event}: ${errorMsg}`);
             }
-            console.log(`  Hide Sensitive: ${hideSensitive ? '✅ Yes (recommended)' : '❌ No'}`);
-            if (!isActive) {
-                console.log(`\n⚠️  Connection is pending activation.`);
-                console.log(`   Run: lua mcp activate --server-name ${serverName}`);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Step 3: Display Results
+    // ─────────────────────────────────────────────────────────────────────────
+    console.log("\n" + "─".repeat(60));
+    console.log("🎉 Connection Established!");
+    console.log("─".repeat(60));
+    console.log(`\n  Integration: ${integration.name}`);
+    console.log(`  Connection ID: ${connectionId}`);
+    // MCP Server status
+    console.log(`\n  📦 MCP Server (Tools):`);
+    if (mcpSetupSuccess) {
+        console.log(`    Status: ${isActive ? '🟢 Active' : '🟡 Pending activation'}`);
+        console.log(`    Name: ${serverName}`);
+        console.log(`    Hide Sensitive: ${hideSensitive ? '✅ Yes' : '❌ No'}`);
+    }
+    else {
+        console.log(`    Status: ❌ Failed`);
+        console.log(`    Error: ${mcpError}`);
+    }
+    // Show requested scopes with friendly labels
+    if (scopes.length > 0) {
+        console.log(`\n  🔑 Permissions (${scopes.length}):`);
+        scopes.forEach(scopeName => {
+            const scopeInfo = integration.oauthScopes?.find(s => s.unifiedScope === scopeName);
+            if (scopeInfo?.friendlyLabel) {
+                console.log(`    • ${scopeInfo.friendlyLabel}`);
             }
             else {
-                console.log(`\n✅ Your agent can now use ${integration.name} tools!`);
+                console.log(`    • ${scopeName}`);
             }
-            console.log();
+        });
+    }
+    else {
+        console.log(`\n  🔑 Permissions: Default`);
+    }
+    // Webhook/Triggers status
+    if (webhookConfig.triggers.length > 0) {
+        console.log(`\n  ⚡ Triggers (${createdWebhooks.length}/${webhookConfig.triggers.length}):`);
+        // Compute actual URLs being used (per-trigger hookUrl or default)
+        const actualUrls = webhookConfig.triggers.map(t => t.hookUrl || webhookConfig.webhookUrl || AGENT_WEBHOOK_URL);
+        const uniqueUrls = [...new Set(actualUrls)];
+        const allAgentTriggers = uniqueUrls.every(url => url === AGENT_WEBHOOK_URL);
+        if (allAgentTriggers) {
+            console.log(`    Mode: Agent wake-up`);
+        }
+        else if (uniqueUrls.length === 1) {
+            console.log(`    Mode: Custom webhook`);
+            console.log(`    URL: ${uniqueUrls[0]}`);
         }
         else {
-            writeError(`❌ Failed to set up connection: ${result.error?.message}`);
+            console.log(`    Mode: Mixed (per-trigger URLs)`);
+        }
+        if (createdWebhooks.length > 0) {
+            createdWebhooks.forEach(wh => {
+                const trigger = webhookConfig.triggers.find(t => t.objectType === wh.objectType && t.event === wh.event);
+                const desc = trigger?.friendlyDescription || `${wh.objectType}.${wh.event}`;
+                console.log(`    ✓ ${desc}`);
+            });
+        }
+        if (failedWebhooks.length > 0) {
+            failedWebhooks.forEach(t => console.log(`    ✗ ${t}`));
         }
     }
-    catch (error) {
-        writeError(`❌ Error setting up connection: ${error.message}`);
+    // Summary message
+    console.log("\n" + "─".repeat(60));
+    const capabilities = [];
+    if (mcpSetupSuccess && isActive) {
+        capabilities.push('tools via MCP');
+    }
+    if (createdWebhooks.length > 0) {
+        // Check if any triggers use custom URLs
+        const hasCustomUrls = webhookConfig.triggers.some(t => {
+            const url = t.hookUrl || webhookConfig.webhookUrl || AGENT_WEBHOOK_URL;
+            return url !== AGENT_WEBHOOK_URL;
+        });
+        if (hasCustomUrls) {
+            capabilities.push('webhooks to custom URL');
+        }
+        else {
+            capabilities.push('event-driven triggers');
+        }
     }
+    if (capabilities.length > 0) {
+        console.log(`✅ ${integration.name} connected! Your agent now has: ${capabilities.join(', ')}`);
+    }
+    else if (mcpSetupSuccess && !isActive) {
+        console.log(`⚠️  Connection created but MCP server pending activation.`);
+        console.log(`   Run: lua mcp activate --server-name ${serverName}`);
+    }
+    else {
+        console.log(`⚠️  Connection created but setup incomplete. Check errors above.`);
+    }
+    console.log();
 }
 async function listConnections(context) {
     writeProgress("🔄 Loading connections...");
@@ -738,11 +1127,11 @@ async function listConnections(context) {
             }
         }
         console.log("\n" + "=".repeat(60));
-        console.log("🔗 Connected Accounts");
+        console.log("🔗 Connected Integrations");
         console.log("=".repeat(60) + "\n");
         if (connections.length === 0) {
-            console.log("ℹ️  No accounts connected yet.");
-            console.log("💡 Run 'lua integrations connect' to connect a new account.\n");
+            console.log("ℹ️  No integrations connected yet.");
+            console.log("💡 Run 'lua integrations connect' to connect an integration.\n");
             return;
         }
         for (const connection of connections) {
@@ -765,23 +1154,26 @@ async function listConnections(context) {
             }
             else if (connection.status === 'active') {
                 statusIcon = '🟡';
-                statusText = 'Connected (tools pending)';
+                statusText = 'Connected (MCP pending)';
             }
             console.log(`${statusIcon} ${connection.integrationName || connection.integrationType}`);
-            console.log(`   ID: ${connection.id}`);
+            console.log(`   Connection: ${connection.id}`);
             console.log(`   Status: ${statusText}`);
+            if (linkedServer) {
+                console.log(`   MCP Server: ${linkedServer.name} (${linkedServer.active ? 'active' : 'inactive'})`);
+            }
             console.log(`   Connected: ${new Date(connection.createdAt).toLocaleDateString()}`);
             console.log();
         }
         console.log("=".repeat(60));
-        console.log(`Total: ${connections.length} connection(s)\n`);
+        console.log(`Total: ${connections.length} integration(s)\n`);
     }
     catch (error) {
         writeError(`❌ Error loading connections: ${error.message}`);
     }
 }
 async function disconnectIntegration(context, connectionId) {
-    writeProgress(`🔄 Disconnecting...`);
+    writeProgress(`🔄 Disconnecting... (please wait, do not close this window)`);
     try {
         // Clean up associated MCP server (internal implementation detail)
         const mcpServers = await context.developerApi.getMCPServers();
@@ -794,9 +1186,9 @@ async function disconnectIntegration(context, connectionId) {
         // Delete the connection (also deletes webhook subscriptions)
         const deleteResult = await context.unifiedToApi.deleteConnection(connectionId, context.agentId);
         if (deleteResult.success) {
-            writeSuccess(`✅ Account disconnected successfully!`);
+            writeSuccess(`✅ Integration disconnected successfully!`);
             if (deleteResult.data?.deletedWebhooksCount && deleteResult.data.deletedWebhooksCount > 0) {
-                console.log(`   ✓ Deleted ${deleteResult.data.deletedWebhooksCount} webhook subscription(s)`);
+                console.log(`   ✓ Deleted ${deleteResult.data.deletedWebhooksCount} trigger(s)`);
             }
             console.log();
         }
@@ -817,14 +1209,14 @@ async function disconnectIntegrationInteractive(context) {
         }
         const connections = connectionsResult.data || [];
         if (connections.length === 0) {
-            console.log("\nℹ️  No accounts to disconnect.\n");
+            console.log("\nℹ️  No integrations to disconnect.\n");
             return;
         }
         const connectionAnswer = await safePrompt([
             {
                 type: 'list',
                 name: 'connection',
-                message: 'Select an account to disconnect:',
+                message: 'Select an integration to disconnect:',
                 choices: connections.map(c => ({
                     name: `${c.integrationName || c.integrationType} (${c.id.substring(0, 8)}...)`,
                     value: c.id
@@ -838,7 +1230,7 @@ async function disconnectIntegrationInteractive(context) {
             {
                 type: 'confirm',
                 name: 'confirm',
-                message: `Disconnect ${selectedConnection?.integrationName || selectedConnection?.integrationType}? Your agent will lose access to this account.`,
+                message: `Disconnect ${selectedConnection?.integrationName || selectedConnection?.integrationType}? Your agent will lose access to this integration.`,
                 default: false
             }
         ]);
@@ -873,8 +1265,8 @@ async function updateConnectionFlow(context, options = {}) {
         return;
     }
     if (connections.length === 0) {
-        writeInfo("No connections to update.");
-        console.log("💡 Run 'lua integrations connect' to connect a new account.\n");
+        writeInfo("No integrations to update.");
+        console.log("💡 Run 'lua integrations connect' to connect an integration.\n");
         return;
     }
     // Step 2: Select connection to update
@@ -953,11 +1345,18 @@ async function updateConnectionFlow(context, options = {}) {
                 message: 'Select new OAuth scopes (Space to toggle, Enter to confirm, leave empty for all):',
                 pageSize: 15,
                 loop: false,
-                choices: selectedIntegration.oauthScopes.map(s => ({
-                    name: `${s.unifiedScope}  →  [${s.originalScopes.join(', ')}]`,
-                    value: s.unifiedScope,
-                    checked: false
-                }))
+                choices: selectedIntegration.oauthScopes.map(s => {
+                    // Use friendly label if available, otherwise fall back to technical name
+                    const displayName = s.friendlyLabel || s.unifiedScope;
+                    const description = s.friendlyDescription
+                        ? `  (${s.friendlyDescription})`
+                        : `  →  [${s.originalScopes.join(', ')}]`;
+                    return {
+                        name: `${displayName}${description}`,
+                        value: s.unifiedScope,
+                        checked: false
+                    };
+                })
             }]);
         if (!scopeAnswer)
             return;
@@ -983,7 +1382,28 @@ async function updateConnectionFlow(context, options = {}) {
             hideSensitive = sensitiveAnswer.hide;
         }
     }
-    // Step 5: Confirm the update
+    // Step 5: Fetch existing triggers before deletion (so we can re-create them)
+    let existingTriggers = [];
+    try {
+        const webhooksResult = await context.unifiedToApi.getWebhookSubscriptions(context.agentId);
+        if (webhooksResult.success && webhooksResult.data && webhooksResult.data.length > 0) {
+            // Filter webhooks to only those belonging to this connection
+            const connectionWebhooks = webhooksResult.data.filter(w => w.connectionId === selectedConnection.id);
+            existingTriggers = connectionWebhooks.map(w => ({
+                objectType: w.objectType,
+                event: w.event,
+                hookUrl: w.hookUrl,
+                interval: w.interval,
+            }));
+            if (existingTriggers.length > 0) {
+                writeInfo(`Found ${existingTriggers.length} existing trigger(s) - will restore after update`);
+            }
+        }
+    }
+    catch (error) {
+        // If we can't fetch existing triggers, continue without them
+    }
+    // Step 6: Confirm the update
     if (!options.integration) {
         const confirmAnswer = await safePrompt([
             {
@@ -998,7 +1418,7 @@ async function updateConnectionFlow(context, options = {}) {
             return;
         }
     }
-    // Step 6: Delete the old connection (silently)
+    // Step 7: Delete the old connection (silently)
     writeProgress(`🔄 Updating ${selectedIntegration.name}...`);
     try {
         // Clean up old MCP server
@@ -1009,14 +1429,14 @@ async function updateConnectionFlow(context, options = {}) {
                 await context.developerApi.deleteMCPServer(associatedServer.id);
             }
         }
-        // Delete old connection
+        // Delete old connection (this also deletes associated webhooks in Unified.to)
         await context.unifiedToApi.deleteConnection(selectedConnection.id, context.agentId);
     }
     catch (error) {
         writeError(`❌ Failed to remove old connection: ${error.message}`);
         return;
     }
-    // Step 7: Create new connection with new scopes
+    // Step 8: Create new connection with new scopes
     const state = Buffer.from(JSON.stringify({
         agentId: context.agentId,
         integration: selectedIntegration.value,
@@ -1057,7 +1477,7 @@ async function updateConnectionFlow(context, options = {}) {
     catch (error) {
         // Use original auth URL if pre-fetch fails
     }
-    // Step 8: Open browser and wait for callback
+    // Step 9: Open browser and wait for callback
     console.log("\n" + "─".repeat(60));
     console.log("🌐 Re-authorizing with new scopes...");
     console.log("─".repeat(60));
@@ -1075,7 +1495,39 @@ async function updateConnectionFlow(context, options = {}) {
     const result = await callbackPromise;
     if (result.success && result.connectionId) {
         writeSuccess("\n✅ Authorization successful!");
-        await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive);
+        // Check if any triggers use custom webhooks
+        const hasCustomWebhook = existingTriggers.some(t => t.hookUrl !== AGENT_WEBHOOK_URL);
+        // Convert existing triggers to TriggerWithSettings format, preserving per-trigger hookUrl and interval
+        let triggersToRestore = [];
+        if (existingTriggers.length > 0) {
+            try {
+                const eventsResult = await context.unifiedToApi.getAvailableWebhookEventsByType(selectedIntegration.value);
+                if (eventsResult.success && eventsResult.data) {
+                    for (const trigger of existingTriggers) {
+                        const matchingEvent = eventsResult.data.find(e => e.objectType === trigger.objectType && e.event === trigger.event);
+                        if (matchingEvent) {
+                            // Preserve per-trigger hookUrl and interval from original webhook
+                            triggersToRestore.push({
+                                ...matchingEvent,
+                                hookUrl: trigger.hookUrl,
+                                interval: trigger.interval,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // If we can't match triggers, continue without them
+            }
+        }
+        await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive, {
+            triggers: triggersToRestore,
+            webhookUrl: AGENT_WEBHOOK_URL, // Default, but per-trigger hookUrl will override if set
+            isCustomWebhook: hasCustomWebhook,
+        });
+        if (triggersToRestore.length > 0) {
+            writeSuccess(`Restored ${triggersToRestore.length} trigger(s) from previous connection`);
+        }
     }
     else {
         writeError(`\n❌ Authorization failed: ${result.error || 'Unknown error'}`);
@@ -1095,12 +1547,14 @@ async function webhooksSubcommand(context, cmdOptions) {
         webhookId: cmdOptions?.webhookId,
         objectType: cmdOptions?.object,
         event: cmdOptions?.event,
-        webhook: cmdOptions?.webhook,
+        hookUrl: cmdOptions?.hookUrl,
         interval: cmdOptions?.interval ? parseInt(cmdOptions.interval, 10) : undefined,
+        integration: cmdOptions?.integration,
     };
+    const jsonOutput = cmdOptions?.json === true;
     switch (subAction) {
         case 'list':
-            await webhooksListFlow(context);
+            await webhooksListFlow(context, jsonOutput);
             break;
         case 'create':
             await webhooksCreateFlow(context, options);
@@ -1108,27 +1562,122 @@ async function webhooksSubcommand(context, cmdOptions) {
         case 'delete':
             if (!options.webhookId) {
                 console.error("❌ --webhook-id is required for delete");
-                console.log("\n💡 Run 'lua integrations webhooks list' to see webhook IDs");
+                console.log("\n💡 Run 'lua integrations webhooks list' to see trigger IDs");
                 process.exit(1);
             }
             await webhooksDeleteFlow(context, options.webhookId);
             break;
+        case 'events':
+            // New: List available webhook events for a connection or integration type
+            await webhooksEventsFlow(context, options, jsonOutput);
+            break;
         default:
             console.error(`❌ Invalid webhooks action: "${subAction || '(none)'}"`);
             console.log('\nUsage:');
-            console.log('  lua integrations webhooks list                              List webhook subscriptions');
-            console.log('  lua integrations webhooks create                            Create subscription (interactive)');
-            console.log('  lua integrations webhooks create --connection <id> --object <type> --event <event> --webhook <name>');
-            console.log('  lua integrations webhooks delete --webhook-id <id>          Delete subscription');
+            console.log('  lua integrations webhooks list                              List triggers');
+            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 trigger');
             process.exit(1);
     }
 }
+/**
+ * Show available webhook events for a connection or integration type
+ * Used for non-interactive discovery
+ */
+async function webhooksEventsFlow(context, options, jsonOutput = false) {
+    try {
+        let webhookEvents = [];
+        let sourceName = '';
+        if (options.connectionId) {
+            // Get events by connection ID
+            const eventsResult = await context.unifiedToApi.getAvailableWebhookEvents(context.agentId, options.connectionId);
+            if (eventsResult.success && eventsResult.data) {
+                webhookEvents = eventsResult.data;
+            }
+            sourceName = `connection ${options.connectionId}`;
+        }
+        else if (options.integration) {
+            // Get events by integration type
+            const eventsResult = await context.unifiedToApi.getAvailableWebhookEventsByType(options.integration);
+            if (eventsResult.success && eventsResult.data) {
+                webhookEvents = eventsResult.data;
+            }
+            sourceName = `integration ${options.integration}`;
+        }
+        else {
+            if (jsonOutput) {
+                console.log(JSON.stringify({ error: 'Either --connection or --integration is required' }));
+            }
+            else {
+                console.error("❌ Either --connection <id> or --integration <type> is required");
+                console.log("\nUsage:");
+                console.log("  lua integrations webhooks events --connection <id>");
+                console.log("  lua integrations webhooks events --integration <type>");
+            }
+            process.exit(1);
+        }
+        if (jsonOutput) {
+            const output = {
+                source: sourceName,
+                events: webhookEvents.map(e => ({
+                    trigger: `${e.objectType}.${e.event}`,
+                    objectType: e.objectType,
+                    event: e.event,
+                    webhookType: e.webhookType,
+                    friendlyLabel: e.friendlyLabel,
+                    friendlyDescription: e.friendlyDescription,
+                    availableFilters: e.availableFilters,
+                })),
+                defaults: {
+                    agentWebhookUrl: AGENT_WEBHOOK_URL,
+                    defaultVirtualInterval: DEFAULT_VIRTUAL_WEBHOOK_INTERVAL,
+                },
+            };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            console.log("\n" + "=".repeat(60));
+            console.log(`📡 Available Trigger Events for ${sourceName}`);
+            console.log("=".repeat(60) + "\n");
+            if (webhookEvents.length === 0) {
+                console.log("ℹ️  No trigger events available for this integration.\n");
+            }
+            else {
+                webhookEvents.forEach(e => {
+                    console.log(`  ${e.objectType}.${e.event} [${e.webhookType}]`);
+                    console.log(`    ${e.friendlyDescription}`);
+                    if (e.availableFilters.length > 0) {
+                        console.log(`    Filters: ${e.availableFilters.join(', ')}`);
+                    }
+                    console.log();
+                });
+                console.log("─".repeat(60));
+                console.log(`Total: ${webhookEvents.length} event(s) available`);
+                console.log("\n💡 Use with --triggers flag:");
+                const exampleTriggers = webhookEvents.slice(0, 2).map(e => `${e.objectType}.${e.event}`).join(',');
+                console.log(`   lua integrations connect --integration <type> --triggers ${exampleTriggers}\n`);
+            }
+        }
+    }
+    catch (error) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            writeError(`❌ Failed to get trigger events: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
 /**
  * Interactive webhooks menu
  */
 async function webhooksInteractiveMenu(context) {
     console.log("\n" + "─".repeat(60));
-    console.log("🔔 Webhook Subscriptions");
+    console.log("🔔 Triggers");
     console.log("─".repeat(60) + "\n");
     const actionAnswer = await safePrompt([
         {
@@ -1136,7 +1685,7 @@ async function webhooksInteractiveMenu(context) {
             name: 'action',
             message: 'What would you like to do?',
             choices: [
-                { name: '📋 List webhook subscriptions', value: 'list' },
+                { name: '📋 List triggers', value: 'list' },
                 { name: '➕ Create new subscription', value: 'create' },
                 { name: '🗑️  Delete subscription', value: 'delete' },
                 { name: '← Back', value: 'back' }
@@ -1160,35 +1709,81 @@ async function webhooksInteractiveMenu(context) {
 /**
  * List all webhook subscriptions
  */
-async function webhooksListFlow(context) {
-    writeProgress("🔄 Loading webhook subscriptions...");
+async function webhooksListFlow(context, jsonOutput = false) {
+    writeProgress("🔄 Loading triggers...");
     try {
         const result = await context.unifiedToApi.getWebhookSubscriptions(context.agentId);
         if (!result.success) {
-            writeError(`❌ Failed to load webhooks: ${result.error?.message}`);
+            if (jsonOutput) {
+                console.log(JSON.stringify({ error: result.error?.message || 'Failed to load triggers' }));
+            }
+            else {
+                writeError(`❌ Failed to load triggers: ${result.error?.message}`);
+            }
             return;
         }
         const webhooks = result.data || [];
-        console.log("\n" + "─".repeat(80));
-        console.log("🔔 Webhook Subscriptions");
-        console.log("─".repeat(80) + "\n");
+        if (jsonOutput) {
+            // Output as JSON for scripting
+            console.log(JSON.stringify({
+                triggers: webhooks.map(wh => ({
+                    id: wh.id,
+                    integrationType: wh.integrationType,
+                    objectType: wh.objectType,
+                    event: wh.event,
+                    webhookType: wh.webhookType,
+                    hookUrl: wh.hookUrl,
+                    status: wh.status,
+                    interval: wh.interval,
+                    connectionId: wh.connectionId,
+                })),
+                total: webhooks.length,
+            }, null, 2));
+            return;
+        }
+        console.log("\n" + "─".repeat(60));
+        console.log("⚡ Triggers / Webhook Subscriptions");
+        console.log("─".repeat(60) + "\n");
         if (webhooks.length === 0) {
-            console.log("ℹ️  No webhook subscriptions found.\n");
-            console.log("💡 Create one with: lua integrations webhooks create\n");
+            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");
             return;
         }
+        // Group by integration
+        const byIntegration = new Map();
         for (const wh of webhooks) {
-            const status = wh.status === 'active' ? '✅ active' : wh.status;
-            console.log(`  ID: ${wh.id}`);
-            console.log(`  Integration: ${wh.integrationType} | Event: ${wh.objectType}.${wh.event} [${wh.webhookType}]`);
-            console.log(`  URL: ${wh.hookUrl}`);
-            console.log(`  Status: ${status}`);
-            console.log("─".repeat(80));
+            const key = wh.integrationType;
+            if (!byIntegration.has(key))
+                byIntegration.set(key, []);
+            byIntegration.get(key).push(wh);
+        }
+        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})`);
+                console.log(`      ID: ${wh.id}`);
+                if (!isAgentTrigger) {
+                    console.log(`      URL: ${wh.hookUrl}`);
+                }
+            }
+            console.log();
         }
-        console.log(`\nTotal: ${webhooks.length} webhook subscription(s)\n`);
+        console.log("─".repeat(60));
+        console.log(`Total: ${webhooks.length} trigger(s)\n`);
     }
     catch (error) {
-        writeError(`❌ Error: ${error.message}`);
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            writeError(`❌ Error: ${error.message}`);
+        }
     }
 }
 /**
@@ -1212,7 +1807,7 @@ async function webhooksCreateFlow(context, options) {
     }
     if (connections.length === 0) {
         writeInfo("No connections available.");
-        console.log("💡 Run 'lua integrations connect' to connect an account first.\n");
+        console.log("💡 Run 'lua integrations connect' to connect an integration first.\n");
         return;
     }
     // Step 2: Select connection
@@ -1258,8 +1853,8 @@ async function webhooksCreateFlow(context, options) {
         return;
     }
     if (availableEvents.length === 0) {
-        writeInfo(`No webhook events available for ${selectedConnection.integrationName || selectedConnection.integrationType}.`);
-        console.log("💡 This integration may not support webhooks.\n");
+        writeInfo(`No trigger events available for ${selectedConnection.integrationName || selectedConnection.integrationType}.`);
+        console.log("💡 This integration may not support triggers.\n");
         return;
     }
     // Step 4: Select event
@@ -1274,7 +1869,7 @@ async function webhooksCreateFlow(context, options) {
         }
     }
     else {
-        console.log(`\nAvailable webhook events for ${selectedConnection.integrationName || selectedConnection.integrationType}:\n`);
+        console.log(`\nAvailable trigger events for ${selectedConnection.integrationName || selectedConnection.integrationType}:\n`);
         const eventAnswer = await safePrompt([
             {
                 type: 'list',
@@ -1293,8 +1888,8 @@ async function webhooksCreateFlow(context, options) {
     }
     // Step 5: Get webhook URL
     let hookUrl;
-    if (options.webhook) {
-        hookUrl = options.webhook;
+    if (options.hookUrl) {
+        hookUrl = options.hookUrl;
     }
     else {
         const webhookAnswer = await safePrompt([
@@ -1357,7 +1952,7 @@ async function webhooksCreateFlow(context, options) {
     // Step 7: Confirmation (interactive only)
     if (!options.connectionId) {
         console.log("\n" + "─".repeat(60));
-        console.log("📋 Webhook Subscription Summary");
+        console.log("📋 Trigger Summary");
         console.log("─".repeat(60));
         console.log(`   Connection: ${selectedConnection.integrationName || selectedConnection.integrationType}`);
         console.log(`   Event: ${selectedEvent.objectType}.${selectedEvent.event} [${selectedEvent.webhookType}]`);
@@ -1369,7 +1964,7 @@ async function webhooksCreateFlow(context, options) {
             {
                 type: 'confirm',
                 name: 'confirm',
-                message: 'Create this webhook subscription?',
+                message: 'Create this trigger?',
                 default: true
             }
         ]);
@@ -1379,7 +1974,7 @@ async function webhooksCreateFlow(context, options) {
         }
     }
     // Step 8: Create the webhook
-    writeProgress("🔄 Creating webhook subscription...");
+    writeProgress("🔄 Creating trigger...");
     try {
         const createResult = await context.unifiedToApi.createWebhookSubscription(context.agentId, {
             connectionId: selectedConnection.id,
@@ -1389,22 +1984,32 @@ async function webhooksCreateFlow(context, options) {
             interval,
         });
         if (!createResult.success || !createResult.data) {
-            writeError(`❌ Failed to create webhook: ${createResult.error?.message}`);
+            writeError(`❌ Failed to create trigger: ${createResult.error?.message}`);
             return;
         }
         const webhook = createResult.data;
+        const isAgentTrigger = webhook.hookUrl.includes('webhook/unifiedto');
+        const typeLabel = webhook.webhookType === 'native' ? 'push' : 'polling';
         console.log("\n" + "─".repeat(60));
-        writeSuccess("✅ Webhook subscription created!");
+        writeSuccess("✅ Trigger created!");
         console.log("─".repeat(60));
-        console.log(`   ID: ${webhook.id}`);
         console.log(`   Integration: ${webhook.integrationType}`);
-        console.log(`   Event: ${webhook.objectType}.${webhook.event} [${webhook.webhookType}]`);
-        console.log(`   Webhook URL: ${webhook.hookUrl}`);
+        console.log(`   Event: ${webhook.objectType}.${webhook.event}`);
+        console.log(`   Type: ${typeLabel}`);
+        console.log(`   Mode: ${isAgentTrigger ? 'Agent wake-up' : 'Custom URL'}`);
+        if (!isAgentTrigger) {
+            console.log(`   URL: ${webhook.hookUrl}`);
+        }
         if (webhook.interval)
-            console.log(`   Interval: ${formatInterval(webhook.interval)}`);
+            console.log(`   Poll interval: ${formatInterval(webhook.interval)}`);
         console.log(`   Status: ${webhook.status}`);
         console.log("─".repeat(60) + "\n");
-        console.log("💡 Ensure your webhook endpoint is deployed and ready to receive events.\n");
+        if (isAgentTrigger) {
+            console.log("💡 Your agent will now wake up when this event occurs.\n");
+        }
+        else {
+            console.log("💡 Ensure your webhook endpoint is ready to receive events.\n");
+        }
     }
     catch (error) {
         writeError(`❌ Error: ${error.message}`);
@@ -1414,23 +2019,23 @@ async function webhooksCreateFlow(context, options) {
  * Delete a webhook subscription (interactive)
  */
 async function webhooksDeleteInteractive(context) {
-    writeProgress("🔄 Loading webhook subscriptions...");
+    writeProgress("🔄 Loading triggers...");
     try {
         const result = await context.unifiedToApi.getWebhookSubscriptions(context.agentId);
         if (!result.success) {
-            writeError(`❌ Failed to load webhooks: ${result.error?.message}`);
+            writeError(`❌ Failed to load triggers: ${result.error?.message}`);
             return;
         }
         const webhooks = result.data || [];
         if (webhooks.length === 0) {
-            console.log("\nℹ️  No webhook subscriptions to delete.\n");
+            console.log("\nℹ️  No triggers to delete.\n");
             return;
         }
         const webhookAnswer = await safePrompt([
             {
                 type: 'list',
                 name: 'webhook',
-                message: 'Select a webhook subscription to delete:',
+                message: 'Select a trigger to delete:',
                 choices: webhooks.map(wh => {
                     // Show last part of URL for readability
                     const urlParts = (wh.hookUrl || '').split('/');
@@ -1449,7 +2054,7 @@ async function webhooksDeleteInteractive(context) {
             {
                 type: 'confirm',
                 name: 'confirm',
-                message: `Delete webhook subscription for ${selectedWebhook?.objectType}.${selectedWebhook?.event}?`,
+                message: `Delete trigger for ${selectedWebhook?.objectType}.${selectedWebhook?.event}?`,
                 default: false
             }
         ]);
@@ -1467,14 +2072,14 @@ async function webhooksDeleteInteractive(context) {
  * Delete a webhook subscription (non-interactive)
  */
 async function webhooksDeleteFlow(context, webhookId) {
-    writeProgress("🔄 Deleting webhook subscription...");
+    writeProgress("🔄 Deleting trigger...");
     try {
         const result = await context.unifiedToApi.deleteWebhookSubscription(context.agentId, webhookId);
         if (result.success) {
-            writeSuccess(`✅ Webhook subscription deleted: ${webhookId}\n`);
+            writeSuccess(`✅ Trigger deleted: ${webhookId}\n`);
         }
         else {
-            writeError(`❌ Failed to delete webhook: ${result.error?.message}`);
+            writeError(`❌ Failed to delete trigger: ${result.error?.message}`);
         }
     }
     catch (error) {
@@ -1758,21 +2363,30 @@ async function mcpDeactivateInteractive(context) {
 function showUsage() {
     console.log('\nUsage:');
     console.log('  lua integrations                              Interactive integration management');
-    console.log('  lua integrations connect                      Connect a new account (interactive)');
+    console.log('  lua integrations connect                      Connect a new integration (interactive)');
     console.log('  lua integrations connect --integration <type> Connect a specific integration');
+    console.log('  lua integrations connect --integration <type> --triggers <events>  Connect with triggers');
     console.log('  lua integrations update                       Update connection scopes (interactive)');
     console.log('  lua integrations update --integration <type>  Update scopes for a specific integration');
-    console.log('  lua integrations list                         List connected accounts');
+    console.log('  lua integrations list                         List connected integrations');
     console.log('  lua integrations available                    List available integrations');
-    console.log('  lua integrations disconnect --connection-id <id>  Disconnect an account');
-    console.log('\nWebhook Subscriptions:');
-    console.log('  lua integrations webhooks list                List all webhook subscriptions');
-    console.log('  lua integrations webhooks create              Create subscription (interactive)');
-    console.log('  lua integrations webhooks create --connection <id> --object <type> --event <event> --webhook <full-url>');
-    console.log('  lua integrations webhooks delete --webhook-id <id>  Delete a subscription');
+    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('  lua integrations webhooks list                List all triggers');
+    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('\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('  --custom-webhook          Use custom URL instead of agent trigger');
+    console.log('  --hook-url <url>          Custom URL for triggers');
 }
 //# sourceMappingURL=integrations.js.map