@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/credential-vault-unit.test.ts

@@ -48,8 +48,13 @@ mock.module("../tools/registry.js", () => ({
 // Mock oauth-store to avoid SQLite dependency in unit tests
 // ---------------------------------------------------------------------------
 
+let disconnectOAuthProviderCalls: string[] = [];
+
 mock.module("../oauth/oauth-store.js", () => ({
-  disconnectOAuthProvider: mock(async () => "not-found" as const),
+  disconnectOAuthProvider: mock(async (provider: string) => {
+    disconnectOAuthProviderCalls.push(provider);
+    return "not-found" as const;
+  }),
   getActiveConnection: mock(() => undefined),
 }));
 
@@ -57,7 +62,9 @@ let manualConnectionStore: Record<string, string> = {};
 let slackChannelConfigCalls: Array<{
   botToken?: string;
   appToken?: string;
+  userToken?: string;
 }> = [];
+let clearSlackUserTokenCalls = 0;
 
 mock.module("../oauth/manual-token-connection.js", () => ({
   syncManualTokenConnection: async (provider: string) => {
@@ -81,8 +88,12 @@ mock.module("../oauth/manual-token-connection.js", () => ({
 }));
 
 mock.module("../daemon/handlers/config-slack-channel.js", () => ({
-  setSlackChannelConfig: async (botToken?: string, appToken?: string) => {
-    slackChannelConfigCalls.push({ botToken, appToken });
+  setSlackChannelConfig: async (
+    botToken?: string,
+    appToken?: string,
+    userToken?: string,
+  ) => {
+    slackChannelConfigCalls.push({ botToken, appToken, userToken });
 
     const { credentialKey } = await import("../security/credential-key.js");
     const { getSecureKeyAsync, setSecureKeyAsync } =
@@ -96,22 +107,38 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
     const hasExistingAppToken = !!(await getSecureKeyAsync(
       credentialKey("slack_channel", "app_token"),
     ));
+    const hasExistingUserToken = !!(await getSecureKeyAsync(
+      credentialKey("slack_channel", "user_token"),
+    ));
 
     if (appToken && !appToken.startsWith("xapp-")) {
       return {
         success: false,
         hasBotToken: hasExistingBotToken,
         hasAppToken: hasExistingAppToken,
+        hasUserToken: hasExistingUserToken,
         connected: hasExistingBotToken && hasExistingAppToken,
         error: 'Invalid app token: must start with "xapp-"',
       };
     }
 
+    if (userToken && !userToken.startsWith("xoxp-")) {
+      return {
+        success: false,
+        hasBotToken: hasExistingBotToken,
+        hasAppToken: hasExistingAppToken,
+        hasUserToken: hasExistingUserToken,
+        connected: hasExistingBotToken && hasExistingAppToken,
+        error: 'Invalid user token: must start with "xoxp-"',
+      };
+    }
+
     if (botToken === "xoxb-invalid-token") {
       return {
         success: false,
         hasBotToken: hasExistingBotToken,
         hasAppToken: hasExistingAppToken,
+        hasUserToken: hasExistingUserToken,
         connected: hasExistingBotToken && hasExistingAppToken,
         error: "Slack API validation failed: invalid_auth",
       };
@@ -131,6 +158,13 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
       );
       upsertCredentialMetadata("slack_channel", "app_token", {});
     }
+    if (userToken) {
+      await setSecureKeyAsync(
+        credentialKey("slack_channel", "user_token"),
+        userToken,
+      );
+      upsertCredentialMetadata("slack_channel", "user_token", {});
+    }
 
     const hasBotToken = !!(await getSecureKeyAsync(
       credentialKey("slack_channel", "bot_token"),
@@ -138,6 +172,9 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
     const hasAppToken = !!(await getSecureKeyAsync(
       credentialKey("slack_channel", "app_token"),
     ));
+    const hasUserToken = !!(await getSecureKeyAsync(
+      credentialKey("slack_channel", "user_token"),
+    ));
 
     if (hasBotToken && hasAppToken) {
       manualConnectionStore["slack_channel"] = "active";
@@ -156,12 +193,43 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
       success: true,
       hasBotToken,
       hasAppToken,
+      hasUserToken,
       connected: hasBotToken && hasAppToken,
       teamName: hasBotToken ? "Test Team" : undefined,
       botUsername: hasBotToken ? "testbot" : undefined,
       warning,
     };
   },
+  clearSlackUserToken: async () => {
+    clearSlackUserTokenCalls++;
+
+    const { credentialKey } = await import("../security/credential-key.js");
+    const { deleteSecureKeyAsync, getSecureKeyAsync } =
+      await import("../security/secure-keys.js");
+    const { deleteCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
+
+    await deleteSecureKeyAsync(credentialKey("slack_channel", "user_token"));
+    deleteCredentialMetadata("slack_channel", "user_token");
+
+    const hasBotToken = !!(await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    ));
+    const hasAppToken = !!(await getSecureKeyAsync(
+      credentialKey("slack_channel", "app_token"),
+    ));
+
+    return {
+      success: true,
+      hasBotToken,
+      hasAppToken,
+      hasUserToken: false,
+      connected:
+        manualConnectionStore["slack_channel"] === "active" &&
+        hasBotToken &&
+        hasAppToken,
+    };
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -178,6 +246,7 @@ import {
   _setMetadataPath,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import { BROWSER_FILL_CAPABILITY } from "../tools/credentials/tool-policy.js";
 import { credentialStoreTool } from "../tools/credentials/vault.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -190,6 +259,8 @@ const _ctx: ToolContext = {
 beforeEach(() => {
   manualConnectionStore = {};
   slackChannelConfigCalls = [];
+  clearSlackUserTokenCalls = 0;
+  disconnectOAuthProviderCalls = [];
 });
 
 afterAll(() => {
@@ -681,6 +752,71 @@ describe("credential_store tool — prompt action", () => {
     ).toBeUndefined();
   });
 
+  test("slack_channel user_token prompt routes through the settings handler", async () => {
+    const ctxWithPrompt: ToolContext = {
+      ..._ctx,
+      requestSecret: async () => ({
+        value: "xoxp-valid-user-token",
+        delivery: "store" as const,
+      }),
+    };
+
+    const result = await credentialStoreTool.execute(
+      {
+        action: "prompt",
+        service: "slack_channel",
+        field: "user_token",
+        label: "User OAuth Token",
+      },
+      ctxWithPrompt,
+    );
+
+    expect(result.isError).toBe(false);
+    // Routed to handler as third positional argument.
+    expect(slackChannelConfigCalls).toEqual([
+      {
+        botToken: undefined,
+        appToken: undefined,
+        userToken: "xoxp-valid-user-token",
+      },
+    ]);
+    // Stored via the handler's mock, NOT via the generic setSecureKeyAsync path.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
+    ).toBe("xoxp-valid-user-token");
+  });
+
+  test("slack_channel user_token prompt surfaces handler rejection for malformed token", async () => {
+    const ctxWithPrompt: ToolContext = {
+      ..._ctx,
+      requestSecret: async () => ({
+        value: "abc-123",
+        delivery: "store" as const,
+      }),
+    };
+
+    const result = await credentialStoreTool.execute(
+      {
+        action: "prompt",
+        service: "slack_channel",
+        field: "user_token",
+        label: "User OAuth Token",
+      },
+      ctxWithPrompt,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('must start with "xoxp-"');
+    // Handler was called with malformed token.
+    expect(slackChannelConfigCalls).toEqual([
+      { botToken: undefined, appToken: undefined, userToken: "abc-123" },
+    ]);
+    // Value was NOT persisted.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
+    ).toBeUndefined();
+  });
+
   test("prompt rejects invalid policy input", async () => {
     const ctxWithPrompt: ToolContext = {
       ..._ctx,
@@ -701,6 +837,117 @@ describe("credential_store tool — prompt action", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// 3b. Vault — slack_channel store routing
+// ---------------------------------------------------------------------------
+
+describe("credential_store tool — slack_channel store routing", () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    _setStorePath(STORE_PATH);
+    _resetBackend();
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
+  });
+
+  afterEach(() => {
+    _setMetadataPath(null);
+    _setStorePath(null);
+    _resetBackend();
+  });
+
+  test("store with user_token routes to setSlackChannelConfig as third positional arg", async () => {
+    const result = await credentialStoreTool.execute(
+      {
+        action: "store",
+        service: "slack_channel",
+        field: "user_token",
+        value: "xoxp-valid-user-token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    // Exactly one handler call with (undefined, undefined, token).
+    expect(slackChannelConfigCalls).toEqual([
+      {
+        botToken: undefined,
+        appToken: undefined,
+        userToken: "xoxp-valid-user-token",
+      },
+    ]);
+    // Stored through the handler's mock path, not the generic setSecureKeyAsync path.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
+    ).toBe("xoxp-valid-user-token");
+  });
+
+  test("store with user_token surfaces handler rejection for malformed token", async () => {
+    const result = await credentialStoreTool.execute(
+      {
+        action: "store",
+        service: "slack_channel",
+        field: "user_token",
+        value: "abc-123",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('must start with "xoxp-"');
+    // Handler was called with the malformed value.
+    expect(slackChannelConfigCalls).toEqual([
+      { botToken: undefined, appToken: undefined, userToken: "abc-123" },
+    ]);
+    // Nothing was persisted.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
+    ).toBeUndefined();
+  });
+
+  test("store with bot_token still routes via first positional arg", async () => {
+    const result = await credentialStoreTool.execute(
+      {
+        action: "store",
+        service: "slack_channel",
+        field: "bot_token",
+        value: "xoxb-valid-bot-token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(slackChannelConfigCalls).toEqual([
+      {
+        botToken: "xoxb-valid-bot-token",
+        appToken: undefined,
+        userToken: undefined,
+      },
+    ]);
+  });
+
+  test("store with app_token still routes via second positional arg", async () => {
+    const result = await credentialStoreTool.execute(
+      {
+        action: "store",
+        service: "slack_channel",
+        field: "app_token",
+        value: "xapp-valid-app-token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(slackChannelConfigCalls).toEqual([
+      {
+        botToken: undefined,
+        appToken: "xapp-valid-app-token",
+        userToken: undefined,
+      },
+    ]);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // 4. Vault — store action validation edge cases
 // ---------------------------------------------------------------------------
@@ -869,6 +1116,146 @@ describe("credential_store tool — store validation edge cases", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// 4b. Vault — slack_channel delete routing
+// ---------------------------------------------------------------------------
+
+describe("credential_store tool — slack_channel delete routing", () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    _setStorePath(STORE_PATH);
+    _resetBackend();
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
+  });
+
+  afterEach(() => {
+    _setMetadataPath(null);
+    _setStorePath(null);
+    _resetBackend();
+  });
+
+  test("delete with user_token leaves bot+app tokens and oauth_connection intact", async () => {
+    // Seed all three Slack tokens + metadata, with the manual connection active.
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+      "xoxb-bot",
+    );
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "app_token"),
+      "xapp-app",
+    );
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "user_token"),
+      "xoxp-user",
+    );
+    upsertCredentialMetadata("slack_channel", "bot_token", {});
+    upsertCredentialMetadata("slack_channel", "app_token", {});
+    upsertCredentialMetadata("slack_channel", "user_token", {});
+    manualConnectionStore["slack_channel"] = "active";
+
+    const result = await credentialStoreTool.execute(
+      {
+        action: "delete",
+        service: "slack_channel",
+        field: "user_token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    // Routed through the surgical helper.
+    expect(clearSlackUserTokenCalls).toBe(1);
+    // oauth_connection row was never disconnected.
+    expect(disconnectOAuthProviderCalls).toEqual([]);
+    // user_token key + metadata removed.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
+    ).toBeUndefined();
+    const { getCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
+    expect(
+      getCredentialMetadata("slack_channel", "user_token"),
+    ).toBeUndefined();
+    // bot + app tokens + their metadata + manual connection still present.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "bot_token")),
+    ).toBe("xoxb-bot");
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "app_token")),
+    ).toBe("xapp-app");
+    expect(getCredentialMetadata("slack_channel", "bot_token")).toBeDefined();
+    expect(getCredentialMetadata("slack_channel", "app_token")).toBeDefined();
+    expect(manualConnectionStore["slack_channel"]).toBe("active");
+  });
+
+  test("delete with bot_token still tears down the oauth connection (regression guard)", async () => {
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+      "xoxb-bot",
+    );
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "app_token"),
+      "xapp-app",
+    );
+    upsertCredentialMetadata("slack_channel", "bot_token", {});
+    upsertCredentialMetadata("slack_channel", "app_token", {});
+    manualConnectionStore["slack_channel"] = "active";
+
+    const result = await credentialStoreTool.execute(
+      {
+        action: "delete",
+        service: "slack_channel",
+        field: "bot_token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    // Surgical helper was not used.
+    expect(clearSlackUserTokenCalls).toBe(0);
+    // Full teardown path called disconnectOAuthProvider for the slack_channel.
+    expect(disconnectOAuthProviderCalls).toContain("slack_channel");
+    // bot_token key + metadata removed.
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "bot_token")),
+    ).toBeUndefined();
+    const { getCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
+    expect(getCredentialMetadata("slack_channel", "bot_token")).toBeUndefined();
+  });
+
+  test("delete with app_token still tears down the oauth connection (regression guard)", async () => {
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+      "xoxb-bot",
+    );
+    await setSecureKeyAsync(
+      credentialKey("slack_channel", "app_token"),
+      "xapp-app",
+    );
+    upsertCredentialMetadata("slack_channel", "bot_token", {});
+    upsertCredentialMetadata("slack_channel", "app_token", {});
+    manualConnectionStore["slack_channel"] = "active";
+
+    const result = await credentialStoreTool.execute(
+      {
+        action: "delete",
+        service: "slack_channel",
+        field: "app_token",
+      },
+      _ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(clearSlackUserTokenCalls).toBe(0);
+    expect(disconnectOAuthProviderCalls).toContain("slack_channel");
+    expect(
+      await getSecureKeyAsync(credentialKey("slack_channel", "app_token")),
+    ).toBeUndefined();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // 5. Vault — tool definition schema
 // ---------------------------------------------------------------------------
@@ -1034,3 +1421,108 @@ describe("CredentialBroker — revokeAll", () => {
     expect(broker.activeTokenCount).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// 8. Broker — canonical capability key and legacy alias
+// ---------------------------------------------------------------------------
+
+describe("CredentialBroker — canonical capability key", () => {
+  let broker: CredentialBroker;
+
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    _setStorePath(STORE_PATH);
+    _resetBackend();
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
+    broker = new CredentialBroker();
+  });
+
+  afterEach(() => {
+    _setMetadataPath(null);
+    _setStorePath(null);
+    _resetBackend();
+  });
+
+  test("authorize succeeds with canonical key when metadata has canonical key", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: BROWSER_FILL_CAPABILITY,
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("authorize succeeds with canonical key when metadata has legacy alias", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: BROWSER_FILL_CAPABILITY,
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("authorize succeeds with legacy alias when metadata has canonical key", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("serverUse with canonical key works when metadata has legacy alias", async () => {
+    upsertCredentialMetadata("vercel", "api_token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    await setSecureKeyAsync(credentialKey("vercel", "api_token"), "vercel-tok");
+
+    const result = await broker.serverUse({
+      service: "vercel",
+      field: "api_token",
+      toolName: BROWSER_FILL_CAPABILITY,
+      execute: async (v) => v,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe("vercel-tok");
+  });
+
+  test("non-aliased tool names are unaffected by alias resolution", () => {
+    upsertCredentialMetadata("svc", "key", {
+      allowedTools: ["custom_tool"],
+    });
+
+    const result = broker.authorize({
+      service: "svc",
+      field: "key",
+      toolName: "custom_tool",
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("non-aliased tool denied when only canonical key is allowed", () => {
+    upsertCredentialMetadata("svc", "key", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "svc",
+      field: "key",
+      toolName: "unrelated_tool",
+    });
+    expect(result.authorized).toBe(false);
+  });
+});

package/src/__tests__/credentials-cli.test.ts

@@ -20,40 +20,56 @@ function nextUUID(): string {
 }
 
 // ---------------------------------------------------------------------------
-// Mock secure-keys
+// Mock daemon-credential-client
+//
+// The credentials CLI routes secret read/write through the daemon HTTP API
+// (see src/cli/lib/daemon-credential-client.ts). Mocking the daemon client
+// directly is the cleanest way to isolate the CLI from the real daemon or a
+// running daemon on localhost (which would otherwise be reached via the HTTP
+// healthz fallback in daemon-credential-client).
 // ---------------------------------------------------------------------------
 
-mock.module("../security/secure-keys.js", () => ({
-  setSecureKeyAsync: async (
-    account: string,
+function normalizeCredentialAccount(type: string, name: string): string {
+  if (type !== "credential") return name;
+  if (name.startsWith("credential/")) return name;
+  const colonIdx = name.lastIndexOf(":");
+  if (colonIdx > 0 && colonIdx < name.length - 1) {
+    return `credential/${name.slice(0, colonIdx)}/${name.slice(colonIdx + 1)}`;
+  }
+  return name;
+}
+
+mock.module("../cli/lib/daemon-credential-client.js", () => ({
+  setSecureKeyViaDaemon: async (
+    type: string,
+    name: string,
     value: string,
   ): Promise<boolean> => {
-    secureKeyStore.set(account, value);
+    secureKeyStore.set(normalizeCredentialAccount(type, name), value);
     return true;
   },
-  deleteSecureKeyAsync: async (
-    account: string,
+  deleteSecureKeyViaDaemon: async (
+    type: string,
+    name: string,
   ): Promise<"deleted" | "not-found" | "error"> => {
-    if (secureKeyStore.has(account)) {
-      secureKeyStore.delete(account);
+    const key = normalizeCredentialAccount(type, name);
+    if (secureKeyStore.has(key)) {
+      secureKeyStore.delete(key);
       return "deleted";
     }
     return "not-found";
   },
-  listSecureKeysAsync: async () => ({
-    accounts: [...secureKeyStore.keys()],
-    unreachable: false,
-  }),
-  getSecureKeyAsync: async (account: string): Promise<string | undefined> => {
+  getSecureKeyViaDaemon: async (
+    account: string,
+  ): Promise<string | undefined> => {
     return secureKeyStore.get(account);
   },
-  getSecureKeyResultAsync: async (
+  getSecureKeyResultViaDaemon: async (
     account: string,
   ): Promise<{ value: string | undefined; unreachable: boolean }> => ({
     value: secureKeyStore.get(account),
     unreachable: mockBrokerUnreachable,
   }),
-  _resetBackend: (): void => {},
 }));
 
 // ---------------------------------------------------------------------------