@vellumai/assistant 0.5.11 → 0.5.13

package/src/cli/commands/oauth/__tests__/providers-update.test.ts

@@ -0,0 +1,416 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockGetProvider: (
+  key: string,
+) => Record<string, unknown> | undefined = () => undefined;
+
+let mockUpdateProvider: (
+  key: string,
+  params: Record<string, unknown>,
+) => Record<string, unknown> | undefined = () => undefined;
+
+let mockUpdateProviderCalls: Array<{
+  key: string;
+  params: Record<string, unknown>;
+}> = [];
+
+let mockSeededProviderKeys = new Set<string>(["google", "slack", "github"]);
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../config/loader.js", () => ({
+  getConfig: () => ({ services: {} }),
+  loadConfig: () => ({ services: {} }),
+  API_KEY_PROVIDERS: [],
+}));
+
+mock.module("../../../../oauth/oauth-store.js", () => ({
+  getProvider: (key: string) => mockGetProvider(key),
+  updateProvider: (key: string, params: Record<string, unknown>) => {
+    mockUpdateProviderCalls.push({ key, params });
+    return mockUpdateProvider(key, params);
+  },
+  listProviders: () => [],
+  registerProvider: () => ({}),
+  seedProviders: () => {},
+  getConnection: () => undefined,
+  getConnectionByProvider: () => undefined,
+  getActiveConnection: () => undefined,
+  listActiveConnectionsByProvider: () => [],
+  isProviderConnected: () => false,
+  createConnection: () => ({}),
+  updateConnection: () => ({}),
+  deleteConnection: () => false,
+  upsertApp: async () => ({}),
+  getApp: () => undefined,
+  getAppByProviderAndClientId: () => undefined,
+  getMostRecentAppByProvider: () => undefined,
+  listApps: () => [],
+  deleteApp: async () => false,
+  listConnections: () => [],
+}));
+
+mock.module("../../../../oauth/seed-providers.js", () => ({
+  SEEDED_PROVIDER_KEYS: mockSeededProviderKeys,
+  PROVIDER_SEED_DATA: {},
+  seedAllProviders: () => {},
+}));
+
+mock.module("../../../../inbound/public-ingress-urls.js", () => ({
+  getOAuthCallbackUrl: () => null,
+}));
+
+mock.module("../../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Import module under test (after mocks are registered)
+// ---------------------------------------------------------------------------
+
+const { registerProviderCommands } = await import("../providers.js");
+
+// ---------------------------------------------------------------------------
+// Test helper
+// ---------------------------------------------------------------------------
+
+async function runCommand(
+  args: string[],
+): Promise<{ stdout: string; exitCode: number }> {
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const stdoutChunks: string[] = [];
+
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.stderr.write = (() => true) as typeof process.stderr.write;
+
+  process.exitCode = 0;
+
+  try {
+    const program = new Command();
+    program.exitOverride();
+    program.option("--json", "JSON output");
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: (str: string) => stdoutChunks.push(str),
+    });
+    registerProviderCommands(program);
+    await program.parseAsync(["node", "assistant", ...args]);
+  } catch {
+    if (process.exitCode === 0) process.exitCode = 1;
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+
+  return { exitCode, stdout: stdoutChunks.join("") };
+}
+
+// ---------------------------------------------------------------------------
+// Sample provider row
+// ---------------------------------------------------------------------------
+
+const sampleProviderRow = {
+  providerKey: "custom-api",
+  authUrl: "https://custom-api.example.com/oauth/authorize",
+  tokenUrl: "https://custom-api.example.com/oauth/token",
+  tokenEndpointAuthMethod: null,
+  userinfoUrl: null,
+  baseUrl: null,
+  defaultScopes: "[]",
+  scopePolicy: "{}",
+  extraParams: null,
+  callbackTransport: null,
+  managedServiceConfigKey: null,
+  pingUrl: null,
+  pingMethod: null,
+  pingHeaders: null,
+  pingBody: null,
+  displayName: null,
+  description: null,
+  dashboardUrl: null,
+  clientIdPlaceholder: null,
+  requiresClientSecret: 1,
+  loopbackPort: null,
+  injectionTemplates: null,
+  appType: null,
+  setupNotes: null,
+  identityUrl: null,
+  identityMethod: null,
+  identityHeaders: null,
+  identityBody: null,
+  identityResponsePaths: null,
+  identityFormat: null,
+  identityOkField: null,
+  createdAt: Date.now(),
+  updatedAt: Date.now(),
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant oauth providers update", () => {
+  beforeEach(() => {
+    mockGetProvider = () => undefined;
+    mockUpdateProvider = () => undefined;
+    mockUpdateProviderCalls = [];
+    mockSeededProviderKeys = new Set(["google", "slack", "github"]);
+    process.exitCode = 0;
+  });
+
+  // -------------------------------------------------------------------------
+  // Provider not found
+  // -------------------------------------------------------------------------
+
+  test("provider not found returns error with hint", async () => {
+    mockGetProvider = () => undefined;
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "nonexistent",
+      "--display-name",
+      "Foo",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("not found");
+    expect(parsed.error).toContain("providers list");
+  });
+
+  // -------------------------------------------------------------------------
+  // Built-in provider
+  // -------------------------------------------------------------------------
+
+  test("built-in provider returns error suggesting register", async () => {
+    mockGetProvider = () => ({
+      ...sampleProviderRow,
+      providerKey: "google",
+    });
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "google",
+      "--display-name",
+      "Foo",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Cannot update built-in");
+    expect(parsed.error).toContain("providers register");
+  });
+
+  // -------------------------------------------------------------------------
+  // No options provided
+  // -------------------------------------------------------------------------
+
+  test("no options provided returns error", async () => {
+    mockGetProvider = () => ({ ...sampleProviderRow });
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "custom-api",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Nothing to update");
+  });
+
+  // -------------------------------------------------------------------------
+  // Successful update with --display-name
+  // -------------------------------------------------------------------------
+
+  test("successful update with --display-name returns updated provider row", async () => {
+    mockGetProvider = () => ({ ...sampleProviderRow });
+    mockUpdateProvider = (_key, _params) => ({
+      ...sampleProviderRow,
+      displayName: "New Name",
+      updatedAt: Date.now(),
+    });
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "custom-api",
+      "--display-name",
+      "New Name",
+      "--json",
+    ]);
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.providerKey).toBe("custom-api");
+    expect(parsed.displayName).toBe("New Name");
+  });
+
+  // -------------------------------------------------------------------------
+  // Successful update with multiple options
+  // -------------------------------------------------------------------------
+
+  test("successful update with multiple options passes all fields to updateProvider", async () => {
+    mockGetProvider = () => ({ ...sampleProviderRow });
+    mockUpdateProvider = (_key, _params) => ({
+      ...sampleProviderRow,
+      displayName: "My API",
+      defaultScopes: '["read","write"]',
+      authUrl: "https://new.example.com/auth",
+      updatedAt: Date.now(),
+    });
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "custom-api",
+      "--display-name",
+      "My API",
+      "--scopes",
+      "read,write",
+      "--auth-url",
+      "https://new.example.com/auth",
+      "--json",
+    ]);
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.providerKey).toBe("custom-api");
+
+    // Verify updateProvider was called with the correct params
+    expect(mockUpdateProviderCalls).toHaveLength(1);
+    expect(mockUpdateProviderCalls[0].key).toBe("custom-api");
+    expect(mockUpdateProviderCalls[0].params).toEqual({
+      displayName: "My API",
+      defaultScopes: ["read", "write"],
+      authUrl: "https://new.example.com/auth",
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Successful update with injection templates, identity config, and setup metadata
+  // -------------------------------------------------------------------------
+
+  test("successful update with injection templates and identity config passes new fields to updateProvider", async () => {
+    const injectionTemplates = [
+      {
+        hostPattern: "api.example.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ];
+    const identityHeaders = { "X-Custom": "value" };
+    const identityBody = { query: "{ viewer { email } }" };
+    const setupNotes = ["Enable the API", "Add test users"];
+
+    mockGetProvider = () => ({ ...sampleProviderRow });
+    mockUpdateProvider = (_key, _params) => ({
+      ...sampleProviderRow,
+      loopbackPort: 17400,
+      injectionTemplates: JSON.stringify(injectionTemplates),
+      appType: "OAuth App",
+      setupNotes: JSON.stringify(setupNotes),
+      identityUrl: "https://api.example.com/me",
+      identityMethod: "POST",
+      identityHeaders: JSON.stringify(identityHeaders),
+      identityBody: JSON.stringify(identityBody),
+      identityResponsePaths: JSON.stringify(["email", "name"]),
+      identityFormat: "@${email}",
+      identityOkField: "ok",
+      updatedAt: Date.now(),
+    });
+
+    const { exitCode, stdout } = await runCommand([
+      "providers",
+      "update",
+      "custom-api",
+      "--loopback-port",
+      "17400",
+      "--injection-templates",
+      JSON.stringify(injectionTemplates),
+      "--app-type",
+      "OAuth App",
+      "--setup-notes",
+      JSON.stringify(setupNotes),
+      "--identity-url",
+      "https://api.example.com/me",
+      "--identity-method",
+      "POST",
+      "--identity-headers",
+      JSON.stringify(identityHeaders),
+      "--identity-body",
+      JSON.stringify(identityBody),
+      "--identity-response-paths",
+      "email,name",
+      "--identity-format",
+      "@${email}",
+      "--identity-ok-field",
+      "ok",
+      "--json",
+    ]);
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.providerKey).toBe("custom-api");
+
+    // Verify the new fields are present in the output (parsed from JSON strings)
+    expect(parsed.loopbackPort).toBe(17400);
+    expect(parsed.injectionTemplates).toEqual(injectionTemplates);
+    expect(parsed.appType).toBe("OAuth App");
+    expect(parsed.setupNotes).toEqual(setupNotes);
+    expect(parsed.identityUrl).toBe("https://api.example.com/me");
+    expect(parsed.identityMethod).toBe("POST");
+    expect(parsed.identityHeaders).toEqual(identityHeaders);
+    expect(parsed.identityBody).toEqual(identityBody);
+    expect(parsed.identityResponsePaths).toEqual(["email", "name"]);
+    expect(parsed.identityFormat).toBe("@${email}");
+    expect(parsed.identityOkField).toBe("ok");
+
+    // Verify updateProvider was called with the correct params
+    expect(mockUpdateProviderCalls).toHaveLength(1);
+    expect(mockUpdateProviderCalls[0].key).toBe("custom-api");
+    expect(mockUpdateProviderCalls[0].params).toEqual({
+      loopbackPort: 17400,
+      injectionTemplates,
+      appType: "OAuth App",
+      setupNotes,
+      identityUrl: "https://api.example.com/me",
+      identityMethod: "POST",
+      identityHeaders,
+      identityBody,
+      identityResponsePaths: ["email", "name"],
+      identityFormat: "@${email}",
+      identityOkField: "ok",
+    });
+  });
+});

package/src/cli/commands/oauth/__tests__/status.test.ts

@@ -56,20 +56,6 @@ mock.module("../../../../oauth/oauth-store.js", () => ({
   deleteConnection: () => false,
 }));
 
-mock.module("../../../../oauth/provider-behaviors.js", () => ({
-  resolveService: (service: string) => {
-    const aliases: Record<string, string> = {
-      gmail: "integration:google",
-      google: "integration:google",
-      slack: "integration:slack",
-    };
-    if (aliases[service]) return aliases[service];
-    if (!service.includes(":")) return `integration:${service}`;
-    return service;
-  },
-  getProviderBehavior: () => undefined,
-}));
-
 mock.module("../../../../oauth/connect-orchestrator.js", () => ({
   orchestrateOAuthConnect: async () => ({
     success: true,
@@ -110,16 +96,6 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
 
 // Mock shared.js helpers to control managed vs BYO mode routing
 mock.module("../shared.js", () => ({
-  resolveService: (service: string) => {
-    const aliases: Record<string, string> = {
-      gmail: "integration:google",
-      google: "integration:google",
-      slack: "integration:slack",
-    };
-    if (aliases[service]) return aliases[service];
-    if (!service.includes(":")) return `integration:${service}`;
-    return service;
-  },
   isManagedMode: (key: string) => mockIsManagedMode(key),
   requirePlatformClient: async (_cmd: Command) => {
     if (
@@ -167,10 +143,6 @@ mock.module("../shared.js", () => ({
     if (!result.ok) return null;
     return result.body as Array<Record<string, unknown>>;
   },
-  toBareProvider: (provider: string): string =>
-    provider.startsWith("integration:")
-      ? provider.slice("integration:".length)
-      : provider,
 }));
 
 // ---------------------------------------------------------------------------
@@ -263,7 +235,7 @@ describe("assistant oauth status", () => {
   describe("managed mode", () => {
     beforeEach(() => {
       mockGetProvider = () => ({
-        providerKey: "integration:google",
+        providerKey: "google",
         managedServiceConfigKey: "google-oauth",
       });
       mockIsManagedMode = () => true;
@@ -300,7 +272,7 @@ describe("assistant oauth status", () => {
       expect(exitCode).toBe(0);
       const parsed = JSON.parse(stdout);
       expect(parsed.ok).toBe(true);
-      expect(parsed.provider).toBe("integration:google");
+      expect(parsed.provider).toBe("google");
       expect(parsed.mode).toBe("managed");
       expect(parsed.connections).toHaveLength(2);
 
@@ -327,7 +299,7 @@ describe("assistant oauth status", () => {
       expect(exitCode).toBe(0);
       const parsed = JSON.parse(stdout);
       expect(parsed.ok).toBe(true);
-      expect(parsed.provider).toBe("integration:google");
+      expect(parsed.provider).toBe("google");
       expect(parsed.mode).toBe("managed");
       expect(parsed.connections).toEqual([]);
     });
@@ -388,7 +360,7 @@ describe("assistant oauth status", () => {
   describe("BYO mode", () => {
     beforeEach(() => {
       mockGetProvider = () => ({
-        providerKey: "integration:google",
+        providerKey: "google",
         managedServiceConfigKey: null,
       });
       mockIsManagedMode = () => false;
@@ -399,7 +371,7 @@ describe("assistant oauth status", () => {
       mockListConnections = () => [
         {
           id: "conn-local-1",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: "localuser@gmail.com",
           grantedScopes: '["email","profile"]',
           expiresAt,
@@ -416,7 +388,7 @@ describe("assistant oauth status", () => {
       expect(exitCode).toBe(0);
       const parsed = JSON.parse(stdout);
       expect(parsed.ok).toBe(true);
-      expect(parsed.provider).toBe("integration:google");
+      expect(parsed.provider).toBe("google");
       expect(parsed.mode).toBe("byo");
       expect(parsed.connections).toHaveLength(1);
 
@@ -433,7 +405,7 @@ describe("assistant oauth status", () => {
       mockListConnections = () => [
         {
           id: "conn-local-2",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: null,
           grantedScopes: "[]",
           expiresAt: null,
@@ -460,7 +432,7 @@ describe("assistant oauth status", () => {
       mockListConnections = () => [
         {
           id: "conn-active",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: "user@gmail.com",
           grantedScopes: "[]",
           expiresAt: null,
@@ -469,7 +441,7 @@ describe("assistant oauth status", () => {
         },
         {
           id: "conn-revoked",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: "old@gmail.com",
           grantedScopes: "[]",
           expiresAt: null,
@@ -500,7 +472,7 @@ describe("assistant oauth status", () => {
       expect(exitCode).toBe(0);
       const parsed = JSON.parse(stdout);
       expect(parsed.ok).toBe(true);
-      expect(parsed.provider).toBe("integration:google");
+      expect(parsed.provider).toBe("google");
       expect(parsed.mode).toBe("byo");
       expect(parsed.connections).toEqual([]);
     });
@@ -517,7 +489,7 @@ describe("assistant oauth status", () => {
       mockListConnections = () => [
         {
           id: "conn-structure",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: "check@gmail.com",
           grantedScopes: '["scope1"]',
           expiresAt: Date.now() + 60_000,
@@ -555,7 +527,7 @@ describe("assistant oauth status", () => {
       mockListConnections = () => [
         {
           id: "conn-bad-scopes",
-          providerKey: "integration:google",
+          providerKey: "google",
           accountInfo: null,
           grantedScopes: "not-valid-json",
           expiresAt: null,

package/src/cli/commands/oauth/__tests__/token.test.ts

@@ -54,20 +54,6 @@ mock.module("../../../../oauth/oauth-store.js", () => ({
   deleteConnection: () => false,
 }));
 
-mock.module("../../../../oauth/provider-behaviors.js", () => ({
-  resolveService: (service: string) => {
-    const aliases: Record<string, string> = {
-      gmail: "integration:google",
-      google: "integration:google",
-      slack: "integration:slack",
-    };
-    if (aliases[service]) return aliases[service];
-    if (!service.includes(":")) return `integration:${service}`;
-    return service;
-  },
-  getProviderBehavior: () => undefined,
-}));
-
 mock.module("../../../../security/token-manager.js", () => ({
   withValidToken: async (
     service: string,
@@ -98,21 +84,7 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
 
 // Mock shared.js helpers to control managed vs BYO mode routing
 mock.module("../shared.js", () => ({
-  resolveService: (service: string) => {
-    const aliases: Record<string, string> = {
-      gmail: "integration:google",
-      google: "integration:google",
-      slack: "integration:slack",
-    };
-    if (aliases[service]) return aliases[service];
-    if (!service.includes(":")) return `integration:${service}`;
-    return service;
-  },
   isManagedMode: (key: string) => mockIsManagedMode(key),
-  toBareProvider: (provider: string): string =>
-    provider.startsWith("integration:")
-      ? provider.slice("integration:".length)
-      : provider,
 }));
 
 // ---------------------------------------------------------------------------
@@ -219,7 +191,7 @@ describe("assistant oauth token", () => {
     test("no active connection returns error", async () => {
       mockWithValidToken = async () => {
         throw new Error(
-          'No access token found for "integration:google". Authorization required.',
+          'No access token found for "google". Authorization required.',
         );
       };
 
@@ -235,25 +207,6 @@ describe("assistant oauth token", () => {
     });
   });
 
-  // =========================================================================
-  // Provider alias resolution
-  // =========================================================================
-
-  test("resolves provider alias (gmail -> integration:google)", async () => {
-    let calledWithService = "";
-    mockWithValidToken = async (service, callback) => {
-      calledWithService = service;
-      return callback("alias-token");
-    };
-
-    const { exitCode, stdout } = await runCommand(["token", "gmail", "--json"]);
-    expect(exitCode).toBe(0);
-    expect(calledWithService).toBe("integration:google");
-    const parsed = JSON.parse(stdout);
-    expect(parsed.ok).toBe(true);
-    expect(parsed.token).toBe("alias-token");
-  });
-
   // =========================================================================
   // Managed mode — user-friendly error
   // =========================================================================
@@ -316,7 +269,7 @@ describe("assistant oauth token", () => {
         if (options?.account === "user@gmail.com") {
           return {
             id: "conn-abc-123",
-            providerKey: "integration:google",
+            providerKey: "google",
             accountInfo: "user@gmail.com",
             status: "active",
           };
@@ -373,7 +326,7 @@ describe("assistant oauth token", () => {
         if (options?.clientId === "my-client-id") {
           return {
             id: "conn-client-456",
-            providerKey: "integration:google",
+            providerKey: "google",
             accountInfo: null,
             status: "active",
           };