@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/credential-broker-browser-fill.test.ts

@@ -1,43 +1,55 @@
-import { randomBytes } from 'node:crypto';
-import { mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterAll, afterEach, beforeEach, describe, expect, mock,test } from 'bun:test';
+import { randomBytes } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mock logger
 // ---------------------------------------------------------------------------
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 // ---------------------------------------------------------------------------
 // Use encrypted backend (no keychain) with a temp store path
 // ---------------------------------------------------------------------------
 
-import { _overrideDeps, _resetDeps } from '../security/keychain.js';
+import { _overrideDeps, _resetDeps } from "../security/keychain.js";
 
 _overrideDeps({
   isMacOS: () => false,
   isLinux: () => false,
-  execFileSync: (() => '') as unknown as typeof import('node:child_process').execFileSync,
+  execFileSync: (() =>
+    "") as unknown as typeof import("node:child_process").execFileSync,
 });
 
-import { _setStorePath } from '../security/encrypted-store.js';
-import { _resetBackend } from '../security/secure-keys.js';
+import { _setStorePath } from "../security/encrypted-store.js";
+import { _resetBackend } from "../security/secure-keys.js";
 
-const TEST_DIR = join(tmpdir(), `vellum-broker-fill-test-${randomBytes(4).toString('hex')}`);
-const STORE_PATH = join(TEST_DIR, 'keys.enc');
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-broker-fill-test-${randomBytes(4).toString("hex")}`,
+);
+const STORE_PATH = join(TEST_DIR, "keys.enc");
 
 // ---------------------------------------------------------------------------
 // Mock registry to avoid double-registration
 // ---------------------------------------------------------------------------
 
-mock.module('../tools/registry.js', () => ({
+mock.module("../tools/registry.js", () => ({
   registerTool: () => {},
 }));
 
@@ -45,20 +57,25 @@ mock.module('../tools/registry.js', () => ({
 // Imports under test
 // ---------------------------------------------------------------------------
 
-import { setSecureKey } from '../security/secure-keys.js';
-import { CredentialBroker } from '../tools/credentials/broker.js';
-import { _setMetadataPath,upsertCredentialMetadata } from '../tools/credentials/metadata-store.js';
+import { setSecureKey } from "../security/secure-keys.js";
+import { CredentialBroker } from "../tools/credentials/broker.js";
+import {
+  _setMetadataPath,
+  upsertCredentialMetadata,
+} from "../tools/credentials/metadata-store.js";
 
-afterAll(() => { mock.restore(); });
+afterAll(() => {
+  mock.restore();
+});
 
-describe('CredentialBroker.browserFill', () => {
+describe("CredentialBroker.browserFill", () => {
   let broker: CredentialBroker;
 
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
     _setStorePath(STORE_PATH);
     _resetBackend();
-    _setMetadataPath(join(TEST_DIR, 'metadata.json'));
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
     broker = new CredentialBroker();
   });
 
@@ -69,344 +86,392 @@ describe('CredentialBroker.browserFill', () => {
     rmSync(TEST_DIR, { recursive: true, force: true });
   });
 
-  test('fills successfully when credential exists', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("fills successfully when credential exists", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     let filledValue: string | undefined;
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async (value) => { filledValue = value; },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async (value) => {
+        filledValue = value;
+      },
     });
 
     expect(result.success).toBe(true);
     expect(result.reason).toBeUndefined();
     // The fill callback received the plaintext
-    expect(filledValue).toBe('ghp_secret123');
+    expect(filledValue).toBe("ghp_secret123");
   });
 
-  test('returns metadata-only result (no plaintext in return value)', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("returns metadata-only result (no plaintext in return value)", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
       fill: async () => {},
     });
 
     // Result has no plaintext value — only success/failure metadata
     expect(result).toEqual({ success: true });
-    expect('value' in result).toBe(false);
-    expect('storageKey' in result).toBe(false);
+    expect("value" in result).toBe(false);
+    expect("storageKey" in result).toBe(false);
   });
 
-  test('fails when no credential metadata exists', async () => {
+  test("fails when no credential metadata exists", async () => {
     const result = await broker.browserFill({
-      service: 'nonexistent',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('should not be called'); },
+      service: "nonexistent",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("should not be called");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('No credential found');
-    expect(result.reason).toContain('nonexistent/token');
+    expect(result.reason).toContain("No credential found");
+    expect(result.reason).toContain("nonexistent/token");
   });
 
-  test('fails when metadata exists but no stored secret value', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
+  test("fails when metadata exists but no stored secret value", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
     // No setSecureKey call — metadata exists but value doesn't
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('should not be called'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("should not be called");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('no stored value');
+    expect(result.reason).toContain("no stored value");
   });
 
-  test('returns failure when fill callback throws', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("returns failure when fill callback throws", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('Element not found'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("Element not found");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('Fill operation failed');
+    expect(result.reason).toContain("Fill operation failed");
     // The broker intentionally returns a generic error — the original error
     // message is NOT included because it could embed the credential value,
     // leaking plaintext outside the broker's trust boundary.
-    expect(result.reason).not.toContain('Element not found');
+    expect(result.reason).not.toContain("Element not found");
   });
 
-  test('handles multiple fills with different credentials', async () => {
-    upsertCredentialMetadata('github', 'username', { allowedTools: ['browser_fill_credential'] });
-    upsertCredentialMetadata('github', 'password', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:username', 'octocat');
-    setSecureKey('credential:github:password', 'hunter2');
+  test("handles multiple fills with different credentials", async () => {
+    upsertCredentialMetadata("github", "username", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    upsertCredentialMetadata("github", "password", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:username", "octocat");
+    setSecureKey("credential:github:password", "hunter2");
 
     const filled: Record<string, string> = {};
 
     const r1 = await broker.browserFill({
-      service: 'github',
-      field: 'username',
-      toolName: 'browser_fill_credential',
-      fill: async (v) => { filled.username = v; },
+      service: "github",
+      field: "username",
+      toolName: "browser_fill_credential",
+      fill: async (v) => {
+        filled.username = v;
+      },
     });
 
     const r2 = await broker.browserFill({
-      service: 'github',
-      field: 'password',
-      toolName: 'browser_fill_credential',
-      fill: async (v) => { filled.password = v; },
+      service: "github",
+      field: "password",
+      toolName: "browser_fill_credential",
+      fill: async (v) => {
+        filled.password = v;
+      },
     });
 
     expect(r1.success).toBe(true);
     expect(r2.success).toBe(true);
-    expect(filled.username).toBe('octocat');
-    expect(filled.password).toBe('hunter2');
+    expect(filled.username).toBe("octocat");
+    expect(filled.password).toBe("hunter2");
   });
 
-  test('allows fill when domain matches allowedDomains', async () => {
-    upsertCredentialMetadata('github', 'token', {
-      allowedTools: ['browser_fill_credential'],
-      allowedDomains: ['github.com'],
+  test("allows fill when domain matches allowedDomains", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+      allowedDomains: ["github.com"],
     });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      domain: 'github.com',
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      domain: "github.com",
       fill: async () => {},
     });
 
     expect(result.success).toBe(true);
   });
 
-  test('allows fill on subdomain when registrable domain matches', async () => {
-    upsertCredentialMetadata('github', 'token', {
-      allowedTools: ['browser_fill_credential'],
-      allowedDomains: ['github.com'],
+  test("allows fill on subdomain when registrable domain matches", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+      allowedDomains: ["github.com"],
     });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      domain: 'login.github.com',
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      domain: "login.github.com",
       fill: async () => {},
     });
 
     expect(result.success).toBe(true);
   });
 
-  test('denies fill when domain does not match allowedDomains', async () => {
-    upsertCredentialMetadata('github', 'token', {
-      allowedTools: ['browser_fill_credential'],
-      allowedDomains: ['github.com'],
+  test("denies fill when domain does not match allowedDomains", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+      allowedDomains: ["github.com"],
     });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      domain: 'evil.com',
-      fill: async () => { throw new Error('should not be called'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      domain: "evil.com",
+      fill: async () => {
+        throw new Error("should not be called");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('not allowed');
-    expect(result.reason).toContain('evil.com');
-    expect(result.reason).toContain('github.com');
+    expect(result.reason).toContain("not allowed");
+    expect(result.reason).toContain("evil.com");
+    expect(result.reason).toContain("github.com");
   });
 
-  test('denies fill when domain policy exists but no domain provided', async () => {
-    upsertCredentialMetadata('github', 'token', {
-      allowedTools: ['browser_fill_credential'],
-      allowedDomains: ['github.com'],
+  test("denies fill when domain policy exists but no domain provided", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+      allowedDomains: ["github.com"],
     });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('should not be called'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("should not be called");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('no page domain was provided');
+    expect(result.reason).toContain("no page domain was provided");
   });
 
-  test('skips domain check when allowedDomains is empty', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("skips domain check when allowedDomains is empty", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     // No domain provided and no allowedDomains policy — should succeed
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
       fill: async () => {},
     });
 
     expect(result.success).toBe(true);
   });
 
-  test('denies fill when tool is not in allowedTools', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['other_tool'] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("denies fill when tool is not in allowedTools", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["other_tool"],
+    });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     let fillCalled = false;
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { fillCalled = true; },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        fillCalled = true;
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('not allowed');
-    expect(result.reason).toContain('browser_fill_credential');
+    expect(result.reason).toContain("not allowed");
+    expect(result.reason).toContain("browser_fill_credential");
     // Fill callback must not be invoked when policy denies
     expect(fillCalled).toBe(false);
   });
 
-  test('denies fill when allowedTools is empty (fail-closed)', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: [] });
-    setSecureKey('credential:github:token', 'ghp_secret123');
+  test("denies fill when allowedTools is empty (fail-closed)", async () => {
+    upsertCredentialMetadata("github", "token", { allowedTools: [] });
+    setSecureKey("credential:github:token", "ghp_secret123");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('should not be called'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("should not be called");
+      },
     });
 
     expect(result.success).toBe(false);
-    expect(result.reason).toContain('No tools are currently allowed');
+    expect(result.reason).toContain("No tools are currently allowed");
   });
 
-  test('fill callback error does not leak plaintext in result', async () => {
-    upsertCredentialMetadata('github', 'token', { allowedTools: ['browser_fill_credential'] });
-    setSecureKey('credential:github:token', 'ghp_supersecret');
+  test("fill callback error does not leak plaintext in result", async () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    setSecureKey("credential:github:token", "ghp_supersecret");
 
     const result = await broker.browserFill({
-      service: 'github',
-      field: 'token',
-      toolName: 'browser_fill_credential',
-      fill: async () => { throw new Error('timeout'); },
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+      fill: async () => {
+        throw new Error("timeout");
+      },
     });
 
     expect(result.success).toBe(false);
     // Ensure the secret value doesn't appear in the error result
-    expect(JSON.stringify(result)).not.toContain('ghp_supersecret');
+    expect(JSON.stringify(result)).not.toContain("ghp_supersecret");
   });
 
   // ---------------------------------------------------------------------------
   // Baseline: tool/domain policy mismatch deny behavior
   // ---------------------------------------------------------------------------
 
-  describe('baseline — tool/domain policy mismatch deny', () => {
-    test('denies tool not in multi-tool allowlist and enumerates allowed tools', async () => {
-      upsertCredentialMetadata('aws', 'access_key', {
-        allowedTools: ['s3_upload', 'cloudfront_invalidate'],
+  describe("baseline — tool/domain policy mismatch deny", () => {
+    test("denies tool not in multi-tool allowlist and enumerates allowed tools", async () => {
+      upsertCredentialMetadata("aws", "access_key", {
+        allowedTools: ["s3_upload", "cloudfront_invalidate"],
         allowedDomains: [],
       });
-      setSecureKey('credential:aws:access_key', 'AKIA_test');
+      setSecureKey("credential:aws:access_key", "AKIA_test");
 
       let fillCalled = false;
       const result = await broker.browserFill({
-        service: 'aws',
-        field: 'access_key',
-        toolName: 'browser_fill_credential',
-        fill: async () => { fillCalled = true; },
+        service: "aws",
+        field: "access_key",
+        toolName: "browser_fill_credential",
+        fill: async () => {
+          fillCalled = true;
+        },
       });
 
       expect(result.success).toBe(false);
-      expect(result.reason).toContain('browser_fill_credential');
-      expect(result.reason).toContain('not allowed');
-      expect(result.reason).toContain('s3_upload');
-      expect(result.reason).toContain('cloudfront_invalidate');
+      expect(result.reason).toContain("browser_fill_credential");
+      expect(result.reason).toContain("not allowed");
+      expect(result.reason).toContain("s3_upload");
+      expect(result.reason).toContain("cloudfront_invalidate");
       expect(fillCalled).toBe(false);
     });
 
-    test('denies when tool matches but domain does not', async () => {
-      upsertCredentialMetadata('github', 'pat', {
-        allowedTools: ['browser_fill_credential'],
-        allowedDomains: ['github.com'],
+    test("denies when tool matches but domain does not", async () => {
+      upsertCredentialMetadata("github", "pat", {
+        allowedTools: ["browser_fill_credential"],
+        allowedDomains: ["github.com"],
       });
-      setSecureKey('credential:github:pat', 'ghp_fill_test');
+      setSecureKey("credential:github:pat", "ghp_fill_test");
 
       let fillCalled = false;
       const result = await broker.browserFill({
-        service: 'github',
-        field: 'pat',
-        toolName: 'browser_fill_credential',
-        domain: 'phishing-github.com',
-        fill: async () => { fillCalled = true; },
+        service: "github",
+        field: "pat",
+        toolName: "browser_fill_credential",
+        domain: "phishing-github.com",
+        fill: async () => {
+          fillCalled = true;
+        },
       });
 
       expect(result.success).toBe(false);
-      expect(result.reason).toContain('phishing-github.com');
-      expect(result.reason).toContain('not allowed');
+      expect(result.reason).toContain("phishing-github.com");
+      expect(result.reason).toContain("not allowed");
       expect(fillCalled).toBe(false);
     });
 
-    test('denies when both tool and domain mismatch — tool check runs first', async () => {
-      upsertCredentialMetadata('slack', 'bot_token', {
-        allowedTools: ['slack_post'],
-        allowedDomains: ['slack.com'],
+    test("denies when both tool and domain mismatch — tool check runs first", async () => {
+      upsertCredentialMetadata("slack", "bot_token", {
+        allowedTools: ["slack_post"],
+        allowedDomains: ["slack.com"],
       });
-      setSecureKey('credential:slack:bot_token', 'xoxb-test');
+      setSecureKey("credential:slack:bot_token", "xoxb-test");
 
       const result = await broker.browserFill({
-        service: 'slack',
-        field: 'bot_token',
-        toolName: 'browser_fill_credential',
-        domain: 'evil.com',
-        fill: async () => { throw new Error('should not be called'); },
+        service: "slack",
+        field: "bot_token",
+        toolName: "browser_fill_credential",
+        domain: "evil.com",
+        fill: async () => {
+          throw new Error("should not be called");
+        },
       });
 
       expect(result.success).toBe(false);
       // Tool policy is evaluated before domain policy, so the denial
       // mentions the tool name, not the domain
-      expect(result.reason).toContain('browser_fill_credential');
-      expect(result.reason).toContain('not allowed');
+      expect(result.reason).toContain("browser_fill_credential");
+      expect(result.reason).toContain("not allowed");
     });
 
-    test('denies with empty allowedTools and suggests credential_store', async () => {
-      upsertCredentialMetadata('custom', 'key', {
+    test("denies with empty allowedTools and suggests credential_store", async () => {
+      upsertCredentialMetadata("custom", "key", {
         allowedTools: [],
       });
-      setSecureKey('credential:custom:key', 'secret');
+      setSecureKey("credential:custom:key", "secret");
 
       const result = await broker.browserFill({
-        service: 'custom',
-        field: 'key',
-        toolName: 'browser_fill_credential',
-        fill: async () => { throw new Error('should not be called'); },
+        service: "custom",
+        field: "key",
+        toolName: "browser_fill_credential",
+        fill: async () => {
+          throw new Error("should not be called");
+        },
       });
 
       expect(result.success).toBe(false);
-      expect(result.reason).toContain('No tools are currently allowed');
-      expect(result.reason).toContain('credential_store');
+      expect(result.reason).toContain("No tools are currently allowed");
+      expect(result.reason).toContain("credential_store");
     });
   });
 
@@ -414,105 +479,115 @@ describe('CredentialBroker.browserFill', () => {
   // Baseline: service/field uniqueness assumptions
   // ---------------------------------------------------------------------------
 
-  describe('baseline — service/field uniqueness', () => {
-    test('upsert overwrites metadata for same service+field pair', async () => {
-      upsertCredentialMetadata('github', 'token', {
-        allowedTools: ['other_tool'],
+  describe("baseline — service/field uniqueness", () => {
+    test("upsert overwrites metadata for same service+field pair", async () => {
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["other_tool"],
       });
       // Second upsert updates the same record
-      upsertCredentialMetadata('github', 'token', {
-        allowedTools: ['browser_fill_credential'],
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
       });
-      setSecureKey('credential:github:token', 'ghp_updated');
+      setSecureKey("credential:github:token", "ghp_updated");
 
       let filledValue: string | undefined;
       const result = await broker.browserFill({
-        service: 'github',
-        field: 'token',
-        toolName: 'browser_fill_credential',
-        fill: async (v) => { filledValue = v; },
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        fill: async (v) => {
+          filledValue = v;
+        },
       });
 
       // The second upsert's policy should be in effect
       expect(result.success).toBe(true);
-      expect(filledValue).toBe('ghp_updated');
+      expect(filledValue).toBe("ghp_updated");
     });
 
-    test('same service with different fields are independent credentials', async () => {
-      upsertCredentialMetadata('github', 'username', {
-        allowedTools: ['browser_fill_credential'],
+    test("same service with different fields are independent credentials", async () => {
+      upsertCredentialMetadata("github", "username", {
+        allowedTools: ["browser_fill_credential"],
       });
-      upsertCredentialMetadata('github', 'password', {
-        allowedTools: ['other_tool'],
+      upsertCredentialMetadata("github", "password", {
+        allowedTools: ["other_tool"],
       });
-      setSecureKey('credential:github:username', 'octocat');
-      setSecureKey('credential:github:password', 'hunter2');
+      setSecureKey("credential:github:username", "octocat");
+      setSecureKey("credential:github:password", "hunter2");
 
       // username allows browser_fill_credential
       const r1 = await broker.browserFill({
-        service: 'github',
-        field: 'username',
-        toolName: 'browser_fill_credential',
+        service: "github",
+        field: "username",
+        toolName: "browser_fill_credential",
         fill: async () => {},
       });
       expect(r1.success).toBe(true);
 
       // password does NOT allow browser_fill_credential
       const r2 = await broker.browserFill({
-        service: 'github',
-        field: 'password',
-        toolName: 'browser_fill_credential',
-        fill: async () => { throw new Error('should not be called'); },
+        service: "github",
+        field: "password",
+        toolName: "browser_fill_credential",
+        fill: async () => {
+          throw new Error("should not be called");
+        },
       });
       expect(r2.success).toBe(false);
-      expect(r2.reason).toContain('not allowed');
+      expect(r2.reason).toContain("not allowed");
     });
 
-    test('different services with same field name are independent', async () => {
-      upsertCredentialMetadata('github', 'token', {
-        allowedTools: ['browser_fill_credential'],
-        allowedDomains: ['github.com'],
+    test("different services with same field name are independent", async () => {
+      upsertCredentialMetadata("github", "token", {
+        allowedTools: ["browser_fill_credential"],
+        allowedDomains: ["github.com"],
       });
-      upsertCredentialMetadata('gitlab', 'token', {
-        allowedTools: ['browser_fill_credential'],
-        allowedDomains: ['gitlab.com'],
+      upsertCredentialMetadata("gitlab", "token", {
+        allowedTools: ["browser_fill_credential"],
+        allowedDomains: ["gitlab.com"],
       });
-      setSecureKey('credential:github:token', 'gh_tok');
-      setSecureKey('credential:gitlab:token', 'gl_tok');
+      setSecureKey("credential:github:token", "gh_tok");
+      setSecureKey("credential:gitlab:token", "gl_tok");
 
       // github credential on github.com succeeds
-      let filled1 = '';
+      let filled1 = "";
       const r1 = await broker.browserFill({
-        service: 'github',
-        field: 'token',
-        toolName: 'browser_fill_credential',
-        domain: 'github.com',
-        fill: async (v) => { filled1 = v; },
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        domain: "github.com",
+        fill: async (v) => {
+          filled1 = v;
+        },
       });
       expect(r1.success).toBe(true);
-      expect(filled1).toBe('gh_tok');
+      expect(filled1).toBe("gh_tok");
 
       // github credential on gitlab.com fails (domain mismatch)
       const r2 = await broker.browserFill({
-        service: 'github',
-        field: 'token',
-        toolName: 'browser_fill_credential',
-        domain: 'gitlab.com',
-        fill: async () => { throw new Error('should not be called'); },
+        service: "github",
+        field: "token",
+        toolName: "browser_fill_credential",
+        domain: "gitlab.com",
+        fill: async () => {
+          throw new Error("should not be called");
+        },
       });
       expect(r2.success).toBe(false);
 
       // gitlab credential on gitlab.com succeeds with its own value
-      let filled3 = '';
+      let filled3 = "";
       const r3 = await broker.browserFill({
-        service: 'gitlab',
-        field: 'token',
-        toolName: 'browser_fill_credential',
-        domain: 'gitlab.com',
-        fill: async (v) => { filled3 = v; },
+        service: "gitlab",
+        field: "token",
+        toolName: "browser_fill_credential",
+        domain: "gitlab.com",
+        fill: async (v) => {
+          filled3 = v;
+        },
       });
       expect(r3.success).toBe(true);
-      expect(filled3).toBe('gl_tok');
+      expect(filled3).toBe("gl_tok");
     });
   });
 });