lua-cli 3.26.0 → 3.27.0

package/dist/index.js

@@ -22748,12 +22748,14 @@ var ALIAS_MAP = {
       "available",
       "info",
       "disconnect",
+      "convert",
       "webhooks",
       "mcp"
     ],
     aliases: lowerKeys({
       add: "connect",
       link: "connect",
+      claim: "convert",
       edit: "update",
       modify: "update",
       ls: "list",
@@ -41446,6 +41448,109 @@ var UnifiedToApi = class extends HttpClient {
       Authorization: `Bearer ${this.apiKey}`
     });
   }
+  // ==================== Personal (user-owned) connections ====================
+  //
+  // The whole tier is agent-free: the acting principal is the API key's owner, resolved server-side
+  // from the same /profile hop a browser session uses. None of these take an agentId — that is the
+  // point, so the signatures don't pretend otherwise.
+  /**
+  * Lists the API key owner's personal connections
+  * @returns Promise resolving to an ApiResponse containing personal connections
+  */
+  async getUserConnections() {
+    return this.httpGet("/developer/unifiedto/user-connection", {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Gets a state-bound OAuth URL for a PERSONAL connection
+  * @param integrationType - The integration type
+  * @param options - Redirect pair, scopes and CSRF state
+  * @returns Promise resolving to an ApiResponse containing the authorization URL
+  */
+  async getUserAuthUrl(integrationType, options) {
+    const params = new URLSearchParams();
+    params.append("integrationType", integrationType);
+    params.append("successRedirect", options.successRedirect);
+    params.append("failureRedirect", options.failureRedirect);
+    if (options.scopes && options.scopes.length > 0) {
+      params.append("scopes", options.scopes.join(","));
+    }
+    params.append("state", options.state);
+    return this.httpGet(`/developer/unifiedto/user-connection/auth-url/v2?${params.toString()}`, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Creates a PERSONAL connection from API-key credentials
+  * @param params - Integration type and credential fields
+  * @returns Promise resolving to an ApiResponse containing the new connection id
+  */
+  async createUserTokenAuthConnection(params) {
+    return this.httpPost("/developer/unifiedto/user-connection/token-auth", params, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Finalizes a PERSONAL connection: stores it, mounts it on every private agent of the owner's,
+  * and seeds ingest triggers. Takes no displayName/hideSensitive/triggers — the user tier has none.
+  * @param params - The connection id and the OAuth scopes that were consented to
+  * @returns Promise resolving to an ApiResponse containing the agents it mounted on
+  */
+  async finalizeUserConnection(params) {
+    return this.httpPost("/developer/unifiedto/user-connection/finalize", params, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Converts an agent-owned connection you created into a personal one
+  * @param connectionId - The connection ID
+  * @returns Promise resolving to an ApiResponse containing the agents it mounted on
+  */
+  async convertConnectionToUser(connectionId) {
+    return this.httpPost("/developer/unifiedto/user-connection/convert", {
+      connectionId
+    }, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Disconnects a personal connection, sweeping every mount
+  * @param connectionId - The connection ID
+  * @param forgetMemories - Also purge what it added to memory (default true server-side)
+  * @returns Promise resolving to an ApiResponse with the number of triggers removed
+  */
+  async deleteUserConnection(connectionId, forgetMemories) {
+    return this.httpDelete(`/developer/unifiedto/user-connection/${connectionId}?forgetMemories=${forgetMemories}`, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Pauses or resumes a personal connection across every agent it is mounted on
+  * @param connectionId - The connection ID
+  * @param status - 'paused' or 'active'
+  * @returns Promise resolving to an ApiResponse with the resulting status
+  */
+  async setUserConnectionStatus(connectionId, status) {
+    return this.httpPatch(`/developer/unifiedto/user-connection/${connectionId}`, {
+      status
+    }, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
+  /**
+  * Turns a personal connection's org-memory feed on or off
+  * @param connectionId - The connection ID
+  * @param memoryFeed - Whether new items from this source should be remembered
+  * @returns Promise resolving to an ApiResponse with the resulting state
+  */
+  async setUserConnectionMemoryFeed(connectionId, memoryFeed) {
+    return this.httpPatch(`/developer/unifiedto/user-connection/${connectionId}/memory-feed`, {
+      memoryFeed
+    }, {
+      Authorization: `Bearer ${this.apiKey}`
+    });
+  }
 };
 
 // src/commands/integrations.ts
@@ -41467,7 +41572,9 @@ async function fetchAvailableIntegrations(unifiedToApi, agentId) {
     authSupport: integration.authSupport,
     oauthConfigured: integration.oauthConfigured,
     oauthScopes: integration.oauthScopes,
-    tokenFields: integration.tokenFields
+    tokenFields: integration.tokenFields,
+    orgOnly: integration.orgOnly,
+    native: integration.native
   }));
 }
 __name(fetchAvailableIntegrations, "fetchAvailableIntegrations");
@@ -41636,7 +41743,9 @@ async function executeNonInteractive12(context, action, cmdOptions) {
     authMethod: cmdOptions?.authMethod,
     scopes: cmdOptions?.scopes,
     hideSensitive: cmdOptions?.hideSensitive === "true",
+    hideSensitiveProvided: cmdOptions?.hideSensitive !== void 0,
     accountLabel: cmdOptions?.accountLabel,
+    scope: cmdOptions?.scope,
     // Trigger options
     triggers: cmdOptions?.triggers,
     customWebhook: cmdOptions?.customWebhook === true,
@@ -41656,7 +41765,22 @@ async function executeNonInteractive12(context, action, cmdOptions) {
       await updateConnectionFlow(context, options);
       break;
     case "list":
-      await listConnections(context);
+      if (options.scope === "user") {
+        await listUserConnections(context);
+      } else if (options.scope === "all") {
+        await listConnections(context);
+        await listUserConnections(context);
+      } else {
+        await listConnections(context);
+      }
+      break;
+    case "convert":
+      if (!options.connectionId) {
+        console.error("\u274C --connection-id is required for convert");
+        console.log("\n\u{1F4A1} Run 'lua integrations list' to see connection IDs");
+        throw new Error("--connection-id is required for convert");
+      }
+      await convertConnectionFlow(context, options.connectionId, cmdOptions?.force === true);
       break;
     case "available":
       await listAvailableIntegrations(context);
@@ -41677,7 +41801,11 @@ async function executeNonInteractive12(context, action, cmdOptions) {
         console.log("\n\u{1F4A1} Run 'lua integrations list' to see connection IDs");
         throw new Error("--connection-id is required for disconnect");
       }
-      await disconnectIntegration(context, options.connectionId);
+      if (options.scope === "user") {
+        await disconnectUserConnection(context, options.connectionId);
+      } else {
+        await disconnectIntegration(context, options.connectionId);
+      }
       break;
     case "webhooks":
       await webhooksSubcommand(context, cmdOptions);
@@ -41716,6 +41844,10 @@ async function interactiveIntegrationsManagement(context) {
             name: "\u{1F4CB} List connected integrations",
             value: "list"
           },
+          {
+            name: "\u{1F464} List my personal connections",
+            value: "list-user"
+          },
           {
             name: "\u{1F50D} View available integrations",
             value: "available"
@@ -41751,6 +41883,9 @@ async function interactiveIntegrationsManagement(context) {
       case "list":
         await listConnections(context);
         break;
+      case "list-user":
+        await listUserConnections(context);
+        break;
       case "available":
         await listAvailableIntegrations(context);
         break;
@@ -41913,17 +42048,83 @@ async function showIntegrationInfo(context, integrationType, jsonOutput = false)
   }
 }
 __name(showIntegrationInfo, "showIntegrationInfo");
+function agentOnlyFlagsIn(options) {
+  return [
+    options.triggers && "--triggers",
+    options.customWebhook && "--custom-webhook",
+    options.hookUrl && "--hook-url",
+    options.accountLabel && "--account-label",
+    // NOT `options.hideSensitive !== undefined`: executeNonInteractive coerces that to a boolean for
+    // every run, so its presence has to be tracked separately.
+    options.hideSensitiveProvided && "--hide-sensitive"
+  ].filter((f) => typeof f === "string" && f.length > 0);
+}
+__name(agentOnlyFlagsIn, "agentOnlyFlagsIn");
+function normalizeScopeFlag(raw) {
+  if (!raw) return void 0;
+  const normalized = raw.toLowerCase();
+  if (normalized !== "agent" && normalized !== "user") {
+    console.error(`\u274C Invalid --scope: "${raw}". Use 'agent' or 'user'`);
+    throw new Error("Invalid --scope");
+  }
+  return normalized;
+}
+__name(normalizeScopeFlag, "normalizeScopeFlag");
+async function resolveConnectScope(context, options) {
+  const flagged = normalizeScopeFlag(options.scope);
+  if (flagged) return flagged;
+  const answer = await safePrompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Who should own this connection?",
+      choices: [
+        {
+          name: `\u{1F916} This agent only \u2014 ${context.agentId} keeps the credential, and loses it when the agent goes`,
+          value: "agent"
+        },
+        {
+          name: "\u{1F464} Me \u2014 every private agent I own can use it, including ones I create later",
+          value: "user"
+        }
+      ]
+    }
+  ]);
+  return answer?.scope;
+}
+__name(resolveConnectScope, "resolveConnectScope");
 async function connectIntegrationFlow(context, options = {}) {
+  const scope = await resolveConnectScope(context, options);
+  if (!scope) return;
+  const userScope = scope === "user";
+  if (userScope) {
+    const unsupported = agentOnlyFlagsIn(options);
+    if (unsupported.length > 0) {
+      console.error(`\u274C ${unsupported.join(", ")} ${unsupported.length > 1 ? "are" : "is"} agent-scoped and cannot be used with --scope user.`);
+      console.log("\u{1F4A1} Connect at agent scope, or drop the flag. Triggers can be added later on an agent connection.");
+      throw new Error("Agent-scoped options cannot be used with --scope user");
+    }
+  }
   writeProgress("\u{1F504} Fetching integrations...");
   let availableIntegrations;
+  let agentConnectedTypes = /* @__PURE__ */ new Set();
   try {
-    availableIntegrations = await fetchAvailableIntegrations(context.unifiedToApi, context.agentId);
+    availableIntegrations = await fetchAvailableIntegrations(context.unifiedToApi, userScope ? void 0 : context.agentId);
+    if (userScope) {
+      const [personal, agentConnections] = await Promise.all([
+        context.unifiedToApi.getUserConnections(),
+        context.unifiedToApi.getConnections(context.agentId)
+      ]);
+      const personalTypes = new Set((personal.data ?? []).map((c) => c.integrationType));
+      agentConnectedTypes = new Set((agentConnections.data ?? []).filter((c) => c.status !== "deleted").map((c) => c.integrationType));
+      availableIntegrations = availableIntegrations.filter((i) => !i.orgOnly && !i.native && !personalTypes.has(i.value));
+    }
   } catch (error) {
     writeError(`\u274C Failed to fetch integrations: ${error.message}`);
     return;
   }
   if (availableIntegrations.length === 0) {
-    writeInfo("All available integrations are already connected (or none are enabled).");
+    writeInfo(userScope ? "You have already connected every integration available as a personal connection." : "All available integrations are already connected (or none are enabled).");
     console.log("\u{1F4A1} Use 'lua integrations update' to change scopes on an existing connection.\n");
     return;
   }
@@ -41932,8 +42133,8 @@ async function connectIntegrationFlow(context, options = {}) {
   if (options.integration) {
     selectedIntegration = availableIntegrations.find((i) => i.value === options.integration);
     if (!selectedIntegration) {
-      console.error(`\u274C Integration "${options.integration}" not found or already connected.`);
-      console.log("\u{1F4A1} If already connected, use 'lua integrations update --integration " + options.integration + "' to change scopes.");
+      console.error(userScope ? `\u274C "${options.integration}" is not available as a personal connection.` : `\u274C Integration "${options.integration}" not found or already connected.`);
+      console.log(userScope ? "\u{1F4A1} You may already have it, or it's org-only / a memory-source connector. Run 'lua integrations list --scope user' to check." : "\u{1F4A1} If already connected, use 'lua integrations update --integration " + options.integration + "' to change scopes.");
       if (availableIntegrations.length > 0) {
         console.log("\nAvailable integrations to connect:");
         availableIntegrations.forEach((i) => console.log(`  - ${i.value} (${i.name})`));
@@ -41993,6 +42194,22 @@ async function connectIntegrationFlow(context, options = {}) {
   console.log(`   Categories: ${selectedIntegration.categories.join(", ")}`);
   console.log(`   Auth Support: ${selectedIntegration.authSupport}`);
   console.log(`   OAuth Configured: ${selectedIntegration.oauthConfigured ? "Yes" : "No"}`);
+  console.log(`   Owner: ${userScope ? "you (every private agent you own)" : `this agent (${context.agentId})`}`);
+  if (userScope && agentConnectedTypes.has(selectedIntegration.value)) {
+    writeInfo(`This agent already has its own ${selectedIntegration.name} connection. Connecting as yourself adds a SECOND credential rather than replacing it.`);
+    const proceed = await safePrompt([
+      {
+        type: "confirm",
+        name: "go",
+        message: "Continue?",
+        default: false
+      }
+    ]);
+    if (!proceed?.go) {
+      console.log("\n\u{1F4A1} To re-home the existing one instead: lua integrations convert --connection-id <id>\n");
+      return;
+    }
+  }
   const canUseOAuth = selectedIntegration.oauthConfigured && [
     "oauth",
     "both"
@@ -42118,7 +42335,8 @@ Available scopes for ${selectedIntegration.name}:`);
     console.log("\nYou will enter these on the Unified.to authorization page.\n");
   }
   let hideSensitive = false;
-  if (options.hideSensitive !== void 0) {
+  if (userScope) {
+  } else if (options.hideSensitive !== void 0) {
     hideSensitive = options.hideSensitive;
   } else {
     const sensitiveAnswer = await safePrompt([
@@ -42136,8 +42354,14 @@ Available scopes for ${selectedIntegration.name}:`);
   let selectedTriggers = [];
   let webhookUrl = AGENT_WEBHOOK_URL;
   let isCustomWebhook = false;
+  if (userScope) {
+    writeInfo("Triggers are agent-owned \u2014 skipping. Add them later on an agent connection.");
+  }
   try {
-    const eventsResult = await context.unifiedToApi.getAvailableWebhookEventsByType(selectedIntegration.value);
+    const eventsResult = userScope ? {
+      success: false,
+      data: void 0
+    } : await context.unifiedToApi.getAvailableWebhookEventsByType(selectedIntegration.value);
     if (eventsResult.success && eventsResult.data && eventsResult.data.length > 0) {
       const availableEvents = eventsResult.data;
       if (options.customWebhook || options.hookUrl) {
@@ -42276,7 +42500,12 @@ Available triggers for ${selectedIntegration.name}:`);
   }
   writeProgress("\u{1F504} Preparing authorization...");
   const state = createOAuthState();
-  const authUrlResult = await context.unifiedToApi.getAuthUrl(selectedIntegration.value, {
+  const authUrlResult = userScope ? await context.unifiedToApi.getUserAuthUrl(selectedIntegration.value, {
+    successRedirect: CALLBACK_URL,
+    failureRedirect: CALLBACK_URL,
+    scopes: authMethod === "oauth" ? selectedScopes : void 0,
+    state
+  }) : await context.unifiedToApi.getAuthUrl(selectedIntegration.value, {
     agentId: context.agentId,
     successRedirect: CALLBACK_URL,
     failureRedirect: CALLBACK_URL,
@@ -42309,11 +42538,15 @@ Integration: ${selectedIntegration.name}`);
   const result = await callbackPromise;
   if (result.success && result.connectionId) {
     writeSuccess("\n\u2705 Authorization successful!");
-    await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive, {
-      triggers: selectedTriggers,
-      webhookUrl,
-      isCustomWebhook
-    }, options.accountLabel);
+    if (userScope) {
+      await finalizeUserConnection(context, selectedIntegration, result.connectionId, selectedScopes);
+    } else {
+      await finalizeConnection(context, selectedIntegration, result.connectionId, selectedScopes, hideSensitive, {
+        triggers: selectedTriggers,
+        webhookUrl,
+        isCustomWebhook
+      }, options.accountLabel);
+    }
   } else {
     writeError(`
 \u274C Authorization failed: ${result.error || "Unknown error"}`);
@@ -42443,6 +42676,140 @@ async function finalizeConnection(context, integration, connectionId, scopes, hi
   });
 }
 __name(finalizeConnection, "finalizeConnection");
+async function finalizeUserConnection(context, integration, connectionId, scopes) {
+  writeProgress(`\u{1F504} Setting up ${integration.name} connection...`);
+  const result = await context.unifiedToApi.finalizeUserConnection({
+    connectionId,
+    scopes: scopes.length > 0 ? scopes : void 0
+  });
+  if (!result.success || !result.data) {
+    writeError(`\u274C Failed to finalize connection: ${result.error?.message || "Unknown error"}`);
+    return;
+  }
+  const { mountedAgentIds, webhooks, failedWebhooks } = result.data;
+  console.log("\n" + "\u2500".repeat(60));
+  console.log("\u{1F389} Connection Established!");
+  console.log("\u2500".repeat(60));
+  console.log(`
+  Integration: ${integration.name}`);
+  console.log(`  Connection ID: ${connectionId}`);
+  console.log(`  Owner: you`);
+  console.log(`
+  \u{1F916} Available on ${mountedAgentIds.length} agent(s):`);
+  if (mountedAgentIds.length === 0) {
+    console.log("    (none yet \u2014 you have no private agents)");
+  } else {
+    mountedAgentIds.forEach((agentId) => {
+      console.log(`    \u2022 ${agentId}${agentId === context.agentId ? "  \u2190 this project" : ""}`);
+    });
+  }
+  console.log("    Private agents you create later are added automatically.");
+  console.log("    Publishing an agent removes its access.");
+  if (scopes.length > 0) {
+    console.log(`
+  \u{1F511} Permissions (${scopes.length}):`);
+    scopes.forEach((scopeName) => {
+      const scopeInfo = integration.oauthScopes?.find((sc) => sc.unifiedScope === scopeName);
+      console.log(`    \u2022 ${scopeInfo?.friendlyLabel || scopeName}`);
+    });
+  } else {
+    console.log(`
+  \u{1F511} Permissions: Default`);
+  }
+  if (webhooks.length > 0) {
+    console.log(`
+  \u{1F9E0} Memory sources seeded: ${webhooks.length}`);
+  }
+  if (failedWebhooks && failedWebhooks.length > 0) {
+    failedWebhooks.forEach((t) => console.log(`    \u2717 ${t.objectType}.${t.event}: ${t.error}`));
+  }
+  console.log("\n" + "\u2500".repeat(60));
+  console.log(`\u2705 ${integration.name} connected as you.`);
+  console.log(`   Manage it with: lua integrations list --scope user
+`);
+  trackEvent("cli_integration_connected", {
+    integration_type: integration.value,
+    integration_name: integration.name,
+    scope: "user",
+    mounted_agents: mountedAgentIds.length
+  });
+}
+__name(finalizeUserConnection, "finalizeUserConnection");
+async function listUserConnections(context) {
+  writeProgress("\u{1F504} Loading your connections...");
+  try {
+    const result = await context.unifiedToApi.getUserConnections();
+    const connections = result.success ? result.data || [] : [];
+    console.log("\n" + "=".repeat(60));
+    console.log("\u{1F464} Your Personal Connections");
+    console.log("=".repeat(60) + "\n");
+    if (connections.length === 0) {
+      console.log("\u2139\uFE0F  You have no personal connections yet.");
+      console.log("\u{1F4A1} Run 'lua integrations connect --scope user' to connect one.\n");
+      return;
+    }
+    for (const connection of connections) {
+      const statusIcon = connection.status === "unhealthy" ? "\u{1F534}" : connection.status === "paused" ? "\u23F8\uFE0F" : "\u{1F7E2}";
+      const mounted = connection.mountedAgentIds || [];
+      console.log(`${statusIcon} ${connection.displayName || connection.integrationType}`);
+      console.log(`   Connection: ${connection.connectionId}`);
+      console.log(`   Status: ${connection.status}`);
+      console.log(`   Available on: ${mounted.length} agent(s)${mounted.includes(context.agentId) ? " (including this project)" : ""}`);
+      if (connection.removedAgentIds && connection.removedAgentIds.length > 0) {
+        console.log(`   Removed from: ${connection.removedAgentIds.length} agent(s)`);
+      }
+      console.log(`   Memory feed: ${connection.memoryFeed ? "on" : "off"}`);
+      if (connection.createdAt) {
+        console.log(`   Connected: ${new Date(connection.createdAt).toLocaleDateString()}`);
+      }
+      console.log();
+    }
+    console.log("=".repeat(60));
+    console.log(`Total: ${connections.length} personal connection(s)
+`);
+  } catch (error) {
+    writeError(`\u274C Error loading your connections: ${error.message}`);
+  }
+}
+__name(listUserConnections, "listUserConnections");
+async function convertConnectionFlow(context, connectionId, force = false) {
+  if (!force) {
+    const ok = await safePrompt([
+      {
+        type: "confirm",
+        name: "go",
+        message: `Make ${connectionId} yours? It spreads to every private agent you own, and there is no way to convert it back.`,
+        default: false
+      }
+    ]);
+    if (!ok?.go) {
+      console.log("\nNothing changed.\n");
+      return;
+    }
+  }
+  writeProgress("\u{1F504} Making this connection yours...");
+  const result = await context.unifiedToApi.convertConnectionToUser(connectionId);
+  if (!result.success || !result.data) {
+    writeError(`\u274C Failed to convert connection: ${result.error?.message || "Unknown error"}`);
+    console.log("\u{1F4A1} Only a private-agent connection you created yourself can become personal.");
+    console.log("   A connection shared with the workspace must stop being shared first.\n");
+    return;
+  }
+  const { mountedAgentIds } = result.data;
+  writeSuccess(`
+\u2705 ${connectionId} is now yours.`);
+  console.log(`
+  \u{1F916} Available on ${mountedAgentIds.length} agent(s):`);
+  mountedAgentIds.forEach((agentId) => {
+    console.log(`    \u2022 ${agentId}${agentId === context.agentId ? "  \u2190 this project" : ""}`);
+  });
+  console.log("    Private agents you create later are added automatically.\n");
+  trackEvent("cli_integration_converted", {
+    connection_id: connectionId,
+    mounted_agents: mountedAgentIds.length
+  });
+}
+__name(convertConnectionFlow, "convertConnectionFlow");
 async function listConnections(context) {
   writeProgress("\u{1F504} Loading connections...");
   try {
@@ -42490,6 +42857,37 @@ async function listConnections(context) {
   }
 }
 __name(listConnections, "listConnections");
+async function disconnectUserConnection(context, connectionId) {
+  const forget = await safePrompt([
+    {
+      type: "confirm",
+      name: "forget",
+      message: "Also forget what this connection already added to memory? (it is kept otherwise)",
+      default: false
+    }
+  ]);
+  if (!forget) return;
+  writeProgress("\u{1F504} Disconnecting... (please wait, do not close this window)");
+  const result = await context.unifiedToApi.deleteUserConnection(connectionId, forget.forget);
+  if (!result.success) {
+    writeError(`\u274C Failed to disconnect: ${result.error?.message || "Unknown error"}`);
+    return;
+  }
+  writeSuccess("\u2705 Personal connection disconnected from every agent it was on.");
+  if (result.data?.deletedWebhooksCount) {
+    console.log(`   \u2713 Deleted ${result.data.deletedWebhooksCount} memory source(s)`);
+  }
+  if (!forget.forget) {
+    console.log("   \u2139\uFE0F  What it already added to memory was kept.");
+  }
+  console.log();
+  trackEvent("cli_integration_disconnected", {
+    scope: "user",
+    webhooks_deleted: result.data?.deletedWebhooksCount || 0,
+    forget_memories: forget.forget
+  });
+}
+__name(disconnectUserConnection, "disconnectUserConnection");
 async function disconnectIntegration(context, connectionId) {
   writeProgress(`\u{1F504} Disconnecting... (please wait, do not close this window)`);
   try {
@@ -47036,16 +47434,19 @@ Examples:
   $ lua mcp deactivate --server-name api-server Deactivate a server
   $ lua mcp delete --server-name old-server     Delete a server
 `).action(mcpCommand);
-  program2.command("integrations [action] [subaction]").description("\u{1F517} Connect third-party integrations via Unified.to").option("--integration <type>", "Integration type (e.g., linear, googlecalendar)").option("--auth-method <method>", "Authentication method: 'oauth' or 'token'").option("--scopes <scopes>", "Comma-separated OAuth scopes (or 'all' for all scopes)").option("--hide-sensitive <bool>", "Hide sensitive data from MCP tools (default: true)").option("--account-label <label>", "Account label used to distinguish multiple connected accounts").option("--connection-id <id>", "Connection ID to disconnect or pause/resume").option("--connection <id>", "Connection ID for trigger").option("--webhook-id <id>", "Trigger ID to delete/pause/resume").option("--object <type>", "Object type for webhook (e.g., task_task, calendar_event)").option("--event <type>", "Event type for webhook: created, updated, or deleted").option("--hook-url <url>", "Custom webhook URL (default: agent trigger)").option("--interval <minutes>", "Polling interval for virtual webhooks (60, 120, 240, 480, 720, 1440, 2880)").option("--triggers <events>", "Comma-separated triggers (e.g., task_task.created,task_task.updated)").option("--custom-webhook", "Use custom webhook URL instead of agent trigger").option("--json", "Output as JSON (for info and webhooks events commands)").option("--reason <text>", "Optional reason for pausing a trigger").addHelpText("after", `
+  program2.command("integrations [action] [subaction]").description("\u{1F517} Connect third-party integrations via Unified.to").option("--integration <type>", "Integration type (e.g., linear, googlecalendar)").option("--auth-method <method>", "Authentication method: 'oauth' or 'token'").option("--scopes <scopes>", "Comma-separated OAuth scopes (or 'all' for all scopes)").option("--hide-sensitive <bool>", "Hide sensitive data from MCP tools (default: true)").option("--account-label <label>", "Account label used to distinguish multiple connected accounts").option("--scope <scope>", "Who owns the connection: 'agent' (default) or 'user'").option("--force", "Skip the confirmation prompt (for convert)").option("--connection-id <id>", "Connection ID to disconnect, convert or pause/resume").option("--connection <id>", "Connection ID for trigger").option("--webhook-id <id>", "Trigger ID to delete/pause/resume").option("--object <type>", "Object type for webhook (e.g., task_task, calendar_event)").option("--event <type>", "Event type for webhook: created, updated, or deleted").option("--hook-url <url>", "Custom webhook URL (default: agent trigger)").option("--interval <minutes>", "Polling interval for virtual webhooks (60, 120, 240, 480, 720, 1440, 2880)").option("--triggers <events>", "Comma-separated triggers (e.g., task_task.created,task_task.updated)").option("--custom-webhook", "Use custom webhook URL instead of agent trigger").option("--json", "Output as JSON (for info and webhooks events commands)").option("--reason <text>", "Optional reason for pausing a trigger").addHelpText("after", `
 Arguments:
-  action                 Optional: 'connect', 'update', 'list', 'available', 'info', 'disconnect', 'webhooks'
-                         (alias: 'triggers'), or 'mcp'
+  action                 Optional: 'connect', 'update', 'list', 'available', 'info', 'disconnect',
+                         'convert', 'webhooks' (alias: 'triggers'), or 'mcp'
   subaction              For info: <integration-type>
                          For webhooks/triggers: 'list', 'events', 'create', 'delete', 'pause', or 'resume'
                          For mcp: 'list', 'activate', or 'deactivate'
 
 Options:
   --integration <type>   Integration type (linear, googlecalendar, hubspot, etc.)
+  --scope <scope>        Who owns the connection: 'agent' (default) or 'user'. 'user' is a personal
+                         connection \u2014 every private agent you own can use it, including ones you
+                         create later. Publishing an agent removes its access.
   --auth-method <method> Authentication method: 'oauth' or 'token'
   --scopes <scopes>      Comma-separated OAuth scopes, or 'all' for all available scopes
   --hide-sensitive <bool> Hide sensitive data from MCP tools (default: true, use 'false' to show)
@@ -47063,6 +47464,7 @@ Webhook/Trigger Options:
   --interval <minutes>   Polling interval for virtual webhooks (60=1h, 120=2h, etc.)
 
 Note: Only 1 connection per integration type is allowed per agent.
+Note: Triggers, account labels and --hide-sensitive are agent-scoped; they don't apply to --scope user.
 
 Examples:
   $ lua integrations                                    Interactive management
@@ -47072,7 +47474,12 @@ Examples:
   $ lua integrations connect --integration linear --triggers task_task.created,task_task.updated
   $ lua integrations update --integration linear --scopes all  Update Linear scopes
   $ lua integrations available                          List available integrations
-  $ lua integrations list                               List connected integrations
+  $ lua integrations list                               List this agent's connections
+  $ lua integrations connect --scope user               Connect as yourself (all your private agents)
+  $ lua integrations list --scope user                  List your personal connections
+  $ lua integrations list --scope all                   List both
+  $ lua integrations convert --connection-id abc123     Re-home an agent connection to yourself
+  $ lua integrations convert --connection-id abc123 --force   Same, without the confirmation
   $ lua integrations info linear                        Show Linear integration details
   $ lua integrations info linear --json                 Output as JSON (for scripting)
   $ lua integrations disconnect --connection-id abc123  Disconnect an integration