@vellumai/assistant 0.7.3 → 0.8.1

package/src/cli/commands/oauth/disconnect.ts

@@ -1,19 +1,8 @@
 import type { Command } from "commander";
 
-import {
-  disconnectOAuthProvider,
-  getActiveConnection,
-  getConnection,
-  getProvider,
-  listActiveConnectionsByProvider,
-} from "../../../oauth/oauth-store.js";
+import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
 import { getCliLogger } from "../../logger.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
-import {
-  fetchActiveConnections,
-  isManagedMode,
-  requirePlatformClient,
-} from "./shared.js";
 
 const log = getCliLogger("cli");
 
@@ -58,7 +47,6 @@ Examples:
       ) => {
         const jsonMode = shouldOutputJson(cmd);
 
-        // Helper: write an error and set exit code
         const writeError = (
           error: string,
           extra?: Record<string, unknown>,
@@ -68,213 +56,26 @@ Examples:
         };
 
         try {
-          // -------------------------------------------------------------------
-          // 1. Validate provider
-          // -------------------------------------------------------------------
-          const providerRow = getProvider(provider);
-          if (!providerRow) {
-            writeError(
-              `Unknown provider "${provider}".\n\n` +
-                `Run 'assistant oauth providers list' to see available providers.\n` +
-                `If this is a custom provider, register it first with 'assistant oauth providers register --help'.`,
-            );
-            return;
-          }
-
-          // -------------------------------------------------------------------
-          // 2. Validate mutual exclusivity
-          // -------------------------------------------------------------------
-          if (opts.account && opts.connectionId) {
-            writeError(
-              `Cannot specify both --account and --connection-id. Use one or the other.\n\n` +
-                `Run 'assistant oauth status ${provider}' to see connected accounts and IDs.`,
-            );
-            return;
-          }
-
-          // -------------------------------------------------------------------
-          // 3. Detect mode
-          // -------------------------------------------------------------------
-          const managed = isManagedMode(provider);
-
-          if (managed) {
-            // -----------------------------------------------------------------
-            // Managed path
-            // -----------------------------------------------------------------
-            const client = await requirePlatformClient(cmd);
-            if (!client) return;
-
-            const entries = await fetchActiveConnections(client, provider, cmd);
-            if (!entries) return;
-
-            let connectionId: string | undefined;
-            let accountLabel: string | undefined;
-
-            if (opts.account) {
-              // Filter connections by account_label matching the account value
-              const matching = entries.filter(
-                (c) => c.account_label === opts.account,
-              );
-              if (matching.length === 0) {
-                writeError(
-                  `No active connection found for "${provider}" with account "${opts.account}".\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see connected accounts.`,
-                );
-                return;
-              }
-              connectionId = matching[0].id;
-              accountLabel = matching[0].account_label;
-            } else if (opts.connectionId) {
-              // Verify the supplied ID belongs to this provider
-              const match = entries.find((c) => c.id === opts.connectionId);
-              if (!match) {
-                writeError(
-                  `Connection "${opts.connectionId}" is not an active ${provider} connection.\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see active connections.`,
-                );
-                return;
-              }
-              connectionId = match.id;
-              accountLabel = match.account_label;
-            } else {
-              // Neither specified — auto-resolve
-              if (entries.length === 0) {
-                writeError(
-                  `No active connections found for "${provider}".\n\n` +
-                    `Run 'assistant oauth status ${provider}' to check connection status.`,
-                );
-                return;
-              }
+          const body: Record<string, unknown> = { provider };
+          if (opts.account) body.account = opts.account;
+          if (opts.connectionId) body.connection_id = opts.connectionId;
 
-              if (entries.length > 1) {
-                const connectionList = entries.map((c) => ({
-                  id: c.id,
-                  account: c.account_label ?? null,
-                }));
-                writeError(
-                  `Multiple active connections for "${provider}". ` +
-                    `Specify which one to disconnect with --account or --connection-id.\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see connected accounts and IDs.`,
-                  { connections: connectionList },
-                );
-                return;
-              }
+          const r = await cliIpcCall<{
+            ok: boolean;
+            provider: string;
+            connectionId: string;
+            account?: string;
+          }>("oauth_disconnect", { body });
 
-              connectionId = entries[0].id;
-              accountLabel = entries[0].account_label;
-            }
+          if (!r.ok) return exitFromIpcResult(r);
 
-            // Call platform /disconnect/ endpoint
-            const disconnectPath = `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/oauth/connections/${encodeURIComponent(connectionId)}/disconnect/`;
-            const disconnectResponse = await client.fetch(disconnectPath, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-            });
+          const result = r.result!;
+          writeOutput(cmd, result);
 
-            if (!disconnectResponse.ok) {
-              const errorText = await disconnectResponse.text().catch(() => "");
-              writeError(
-                `Platform returned HTTP ${disconnectResponse.status}${errorText ? `: ${errorText}` : ""}`,
-              );
-              return;
-            }
-
-            const result: Record<string, unknown> = {
-              ok: true,
-              provider: provider,
-              connectionId,
-            };
-            if (accountLabel) result.account = accountLabel;
-            writeOutput(cmd, result);
-
-            if (!jsonMode) {
-              log.info(`Disconnected ${provider} connection ${connectionId}`);
-            }
-          } else {
-            // -----------------------------------------------------------------
-            // BYO path
-            // -----------------------------------------------------------------
-            let connectionId: string | undefined;
-            let accountLabel: string | undefined;
-
-            if (opts.account) {
-              const conn = getActiveConnection(provider, {
-                account: opts.account,
-              });
-              if (!conn) {
-                writeError(
-                  `No active connection found for "${provider}" with account "${opts.account}".\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see connected accounts.`,
-                );
-                return;
-              }
-              connectionId = conn.id;
-              accountLabel = conn.accountInfo ?? undefined;
-            } else if (opts.connectionId) {
-              const conn = getConnection(opts.connectionId);
-              if (!conn || conn.provider !== provider) {
-                writeError(
-                  `Connection "${opts.connectionId}" is not an active ${provider} connection.\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see active connections.`,
-                );
-                return;
-              }
-              connectionId = conn.id;
-              accountLabel = conn.accountInfo ?? undefined;
-            } else {
-              // Neither specified — auto-resolve
-              const active = listActiveConnectionsByProvider(provider);
-
-              if (active.length === 0) {
-                writeError(
-                  `No active connections found for "${provider}".\n\n` +
-                    `Run 'assistant oauth status ${provider}' to check connection status.`,
-                );
-                return;
-              }
-
-              if (active.length > 1) {
-                const connectionList = active.map((c) => ({
-                  id: c.id,
-                  account: c.accountInfo ?? null,
-                }));
-                writeError(
-                  `Multiple active connections for "${provider}". ` +
-                    `Specify which one to disconnect with --account or --connection-id.\n\n` +
-                    `Run 'assistant oauth status ${provider}' to see connected accounts and IDs.`,
-                  { connections: connectionList },
-                );
-                return;
-              }
-
-              connectionId = active[0].id;
-              accountLabel = active[0].accountInfo ?? undefined;
-            }
-
-            // Disconnect the OAuth connection (tokens + connection row)
-            const oauthResult = await disconnectOAuthProvider(
-              provider,
-              undefined,
-              connectionId,
+          if (!jsonMode) {
+            log.info(
+              `Disconnected ${result.provider} connection ${result.connectionId}`,
             );
-            if (oauthResult === "error") {
-              writeError(
-                `Failed to disconnect OAuth provider "${provider}" — please try again.`,
-              );
-              return;
-            }
-
-            const result: Record<string, unknown> = {
-              ok: true,
-              provider: provider,
-              connectionId,
-            };
-            if (accountLabel) result.account = accountLabel;
-            writeOutput(cmd, result);
-
-            if (!jsonMode) {
-              log.info(`Disconnected ${provider} connection ${connectionId}`);
-            }
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);

package/src/cli/commands/oauth/index.ts

@@ -1,5 +1,6 @@
 import type { Command } from "commander";
 
+import { registerCommand } from "../../lib/register-command.js";
 import { registerAppCommands } from "./apps.js";
 import { registerConnectCommand } from "./connect.js";
 import { registerDisconnectCommand } from "./disconnect.js";
@@ -11,16 +12,17 @@ import { registerStatusCommand } from "./status.js";
 import { registerTokenCommand } from "./token.js";
 
 export function registerOAuthCommand(program: Command): void {
-  const oauth = program
-    .command("oauth")
-    .description(
+  registerCommand(program, {
+    name: "oauth",
+    transport: "ipc",
+    description:
       "Manage the full OAuth lifecycle — registering providers, creating apps, connecting accounts, and making authenticated requests",
-    )
-    .option("--json", "Machine-readable compact JSON output");
+    build: (oauth) => {
+      oauth.option("--json", "Machine-readable compact JSON output");
 
-  oauth.addHelpText(
-    "after",
-    `
+      oauth.addHelpText(
+        "after",
+        `
 OAuth providers may support up to two modes – "managed" and "your-own".
   managed:
     Requires a Vellum Platform account. For providers that support it, managed mode offloads the burden of needing to create and register an oauth app.
@@ -43,59 +45,61 @@ Examples:
   assistant oauth ping google
   assistant oauth request --provider google /gmail/v1/users/me/messages
   assistant oauth disconnect google`,
-  );
+      );
 
-  // ---------------------------------------------------------------------------
-  // providers — subcommand group
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // providers — subcommand group
+      // -----------------------------------------------------------------------
 
-  registerProviderCommands(oauth);
+      registerProviderCommands(oauth);
 
-  // ---------------------------------------------------------------------------
-  // mode — get or set OAuth mode (managed vs your-own) for a provider
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // mode — get or set OAuth mode (managed vs your-own) for a provider
+      // -----------------------------------------------------------------------
 
-  registerModeCommand(oauth);
+      registerModeCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // apps — subcommand group
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // apps — subcommand group
+      // -----------------------------------------------------------------------
 
-  registerAppCommands(oauth);
+      registerAppCommands(oauth);
 
-  // ---------------------------------------------------------------------------
-  // connect — unified connect command (auto-detects managed vs BYO)
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // connect — unified connect command (auto-detects managed vs BYO)
+      // -----------------------------------------------------------------------
 
-  registerConnectCommand(oauth);
+      registerConnectCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // status — unified connection status
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // status — unified connection status
+      // -----------------------------------------------------------------------
 
-  registerStatusCommand(oauth);
+      registerStatusCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // ping — ping to see if a provider is connected and healthy
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // ping — ping to see if a provider is connected and healthy
+      // -----------------------------------------------------------------------
 
-  registerPingCommand(oauth);
+      registerPingCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // request — curl-like authenticated request command
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // request — curl-like authenticated request command
+      // -----------------------------------------------------------------------
 
-  registerRequestCommand(oauth);
+      registerRequestCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // disconnect — unified disconnect with auto-detected managed/BYO routing
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // disconnect — unified disconnect with auto-detected managed/BYO routing
+      // -----------------------------------------------------------------------
 
-  registerDisconnectCommand(oauth);
+      registerDisconnectCommand(oauth);
 
-  // ---------------------------------------------------------------------------
-  // token — retrieve a valid oauth token (your-own mode only)
-  // ---------------------------------------------------------------------------
+      // -----------------------------------------------------------------------
+      // token — retrieve a valid oauth token (your-own mode only)
+      // -----------------------------------------------------------------------
 
-  registerTokenCommand(oauth);
+      registerTokenCommand(oauth);
+    },
+  });
 }

package/src/cli/commands/oauth/mode.ts

@@ -1,51 +1,8 @@
 import type { Command } from "commander";
 
-import {
-  getConfig,
-  loadRawConfig,
-  saveRawConfig,
-  setNestedValue,
-} from "../../../config/loader.js";
-import {
-  getServiceMode,
-  type Services,
-} from "../../../config/schemas/services.js";
-import {
-  getProvider,
-  listActiveConnectionsByProvider,
-} from "../../../oauth/oauth-store.js";
-import { VellumPlatformClient } from "../../../platform/client.js";
+import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
 import { getCliLogger } from "../../logger.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
-import {
-  fetchActiveConnections,
-  getManagedServiceConfigKey,
-  requirePlatformConnection,
-} from "./shared.js";
-
-/**
- * Best-effort helper to count active platform connections for a provider.
- * Returns 0 if the platform client cannot be created or the fetch fails.
- *
- * Uses `VellumPlatformClient.create()` directly (instead of the error-writing
- * `requirePlatformClient`) so that a missing platform session doesn't pollute
- * command output or set a non-zero exit code.
- */
-async function countManagedConnections(
-  provider: string,
-  cmd: Command,
-): Promise<number> {
-  try {
-    const client = await VellumPlatformClient.create();
-    if (!client || !client.platformAssistantId) return 0;
-    const entries = await fetchActiveConnections(client, provider, cmd, {
-      silent: true,
-    });
-    return entries?.length ?? 0;
-  } catch {
-    return 0;
-  }
-}
 
 const log = getCliLogger("cli");
 
@@ -82,180 +39,67 @@ Examples:
     )
     .action(async (provider: string, opts: { set?: string }, cmd: Command) => {
       try {
-        // -----------------------------------------------------------------
-        // Validate provider
-        // -----------------------------------------------------------------
-        const providerRow = getProvider(provider);
-
-        if (!providerRow) {
-          writeOutput(cmd, {
-            ok: false,
-            error:
-              `Unknown provider "${provider}". ` +
-              `Run 'assistant oauth providers list' to see available providers.`,
+        if (opts.set === undefined) {
+          // GET mode
+          const r = await cliIpcCall<{
+            ok: boolean;
+            provider: string;
+            mode: string;
+            managedModeSupported: boolean;
+          }>("oauth_mode_get", {
+            queryParams: { provider },
           });
-          process.exitCode = 1;
-          return;
-        }
 
-        const managedKey = getManagedServiceConfigKey(provider);
+          if (!r.ok) return exitFromIpcResult(r);
 
-        // -----------------------------------------------------------------
-        // GET mode (no --set flag)
-        // -----------------------------------------------------------------
-        if (opts.set === undefined) {
-          if (managedKey === null) {
-            // Provider has no managedServiceConfigKey
-            if (shouldOutputJson(cmd)) {
-              writeOutput(cmd, {
-                ok: true,
-                provider: provider,
-                mode: "your-own",
-                managedModeSupported: false,
-              });
-            } else {
-              log.info(
-                `${provider} mode: your-own (managed mode not available for this provider)`,
-              );
-            }
-            return;
-          }
-
-          // Provider supports managed mode — read current config value
-          const services: Services = getConfig().services;
-          const currentMode = getServiceMode(
-            services,
-            managedKey as keyof Services,
-          );
+          const result = r.result!;
 
           if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, {
-              ok: true,
-              provider: provider,
-              mode: currentMode,
-              managedModeSupported: true,
-            });
+            writeOutput(cmd, result);
           } else {
-            log.info(`${provider} mode: ${currentMode}`);
-          }
-          return;
-        }
-
-        // -----------------------------------------------------------------
-        // SET mode (--set flag present)
-        // -----------------------------------------------------------------
-        const newMode = opts.set;
-
-        // Validate mode value
-        if (newMode !== "managed" && newMode !== "your-own") {
-          writeOutput(cmd, {
-            ok: false,
-            error: `Invalid mode "${newMode}". Valid values are "managed" or "your-own".`,
-          });
-          process.exitCode = 1;
-          return;
-        }
-
-        // Provider has no managedServiceConfigKey — it is always "your-own"
-        if (managedKey === null) {
-          if (newMode === "your-own") {
-            // Already your-own — successful no-op
-            if (shouldOutputJson(cmd)) {
-              writeOutput(cmd, {
-                ok: true,
-                provider: provider,
-                mode: "your-own",
-                changed: false,
-                managedModeSupported: false,
-              });
-            } else {
+            if (!result.managedModeSupported) {
               log.info(
-                `${provider} is already set to your-own (managed mode not available for this provider)`,
+                `${provider} mode: your-own (managed mode not available for this provider)`,
               );
+            } else {
+              log.info(`${provider} mode: ${result.mode}`);
             }
-            return;
-          }
-
-          // Requesting managed on a provider that doesn't support it
-          writeOutput(cmd, {
-            ok: false,
-            error:
-              `Managed mode is not available for ${provider}. ` +
-              `Only providers with platform-managed OAuth support can be switched to managed mode.`,
-          });
-          process.exitCode = 1;
-          return;
-        }
-
-        // Require platform connection when switching to managed mode
-        if (newMode === "managed") {
-          const connected = await requirePlatformConnection(cmd);
-          if (!connected) return;
-        }
-
-        // Read current mode
-        const services: Services = getConfig().services;
-        const currentMode = getServiceMode(
-          services,
-          managedKey as keyof Services,
-        );
-
-        // Same mode — no-op
-        if (currentMode === newMode) {
-          if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, {
-              ok: true,
-              provider: provider,
-              mode: newMode,
-              changed: false,
-              managedModeSupported: true,
-            });
-          } else {
-            log.info(`${provider} is already set to ${newMode}`);
           }
           return;
         }
 
-        // Write the new mode
-        const raw = loadRawConfig();
-        setNestedValue(raw, `services.${managedKey}.mode`, newMode);
-        saveRawConfig(raw);
+        // SET mode
+        const r = await cliIpcCall<{
+          ok: boolean;
+          provider: string;
+          mode: string;
+          changed: boolean;
+          managedModeSupported: boolean;
+          hint?: string;
+        }>("oauth_mode_set", {
+          body: { provider, mode: opts.set },
+        });
 
-        // Best-effort check for active connections on old and new modes
-        let oldModeConnections = 0;
-        let newModeConnections = 0;
-        if (currentMode === "managed") {
-          // Old mode was managed — check platform connections
-          oldModeConnections = await countManagedConnections(provider, cmd);
-          // New mode is your-own — check local connections
-          newModeConnections = listActiveConnectionsByProvider(provider).length;
-        } else {
-          // Old mode was your-own — check local connections
-          oldModeConnections = listActiveConnectionsByProvider(provider).length;
-          // New mode is managed — check platform connections
-          newModeConnections = await countManagedConnections(provider, cmd);
-        }
+        if (!r.ok) return exitFromIpcResult(r);
 
-        // Build hint if there are connections on the old mode but none on the new
-        let hint: string | undefined;
-        if (oldModeConnections > 0 && newModeConnections === 0) {
-          hint = `No active connections in ${newMode} mode. Run 'assistant oauth connect ${provider}' to connect.`;
-        }
+        const result = r.result!;
 
         if (shouldOutputJson(cmd)) {
-          const result: Record<string, unknown> = {
-            ok: true,
-            provider: provider,
-            mode: newMode,
-            changed: true,
-            managedModeSupported: true,
-          };
-          if (hint) result.hint = hint;
           writeOutput(cmd, result);
         } else {
-          log.info(`${provider} mode changed to ${newMode}`);
-          if (hint) {
-            process.stderr.write(hint + "\n");
+          if (!result.changed) {
+            if (!result.managedModeSupported) {
+              log.info(
+                `${provider} is already set to your-own (managed mode not available for this provider)`,
+              );
+            } else {
+              log.info(`${provider} is already set to ${result.mode}`);
+            }
+          } else {
+            log.info(`${provider} mode changed to ${result.mode}`);
+            if (result.hint) {
+              process.stderr.write(result.hint + "\n");
+            }
           }
         }
       } catch (err) {