@mycadet/credential-executor 0.0.1 → 0.12.6-dev.202610080043.b727a33

package/node_modules/@mycadet/service-contracts/src/trust-rules.ts

@@ -0,0 +1,116 @@
+/**
+ * Trust rule types shared between the assistant daemon and the gateway.
+ *
+ * These are extracted from `assistant/src/permissions/types.ts` and
+ * `assistant/src/permissions/trust-store.ts` so that both packages can
+ * reference a single canonical definition.
+ *
+ * Tools are grouped into "families" based on how their permission candidates
+ * are constructed and matched:
+ *
+ * - **Scoped**: tools whose candidates include a filesystem path and obey
+ *   directory-boundary scope constraints (`file_read`, `file_write`,
+ *   `file_edit`, `host_file_read`, `host_file_write`, `host_file_edit`,
+ *   `host_file_transfer`, `bash`, `host_bash`).
+ * - **URL**: tools whose candidates include a URL (`web_fetch`,
+ *   `network_request`).
+ * - **Managed skill**: tools that manage first-party skill packages
+ *   (`scaffold_managed_skill`, `delete_managed_skill`).
+ * - **Skill load**: the `skill_load` tool, which uses a distinct candidate
+ *   namespace (`skill_load:selector` or `skill_load_dynamic:selector`).
+ * - **Generic**: everything else (computer-use tools, UI surface tools,
+ *   recall, skill_execute, etc.).
+ */
+
+// ---------------------------------------------------------------------------
+// Trust decision
+// ---------------------------------------------------------------------------
+
+/** The possible decisions a trust rule can make. */
+export type TrustDecision = "allow" | "deny" | "ask";
+
+// ---------------------------------------------------------------------------
+// Tool family constants
+// ---------------------------------------------------------------------------
+
+/**
+ * Tools whose permission candidates are scoped to a filesystem path and obey
+ * directory-boundary scope constraints.
+ */
+export const SCOPED_TOOLS = [
+  "file_read",
+  "file_write",
+  "file_edit",
+  "host_file_read",
+  "host_file_write",
+  "host_file_edit",
+  "host_file_transfer",
+  "bash",
+  "host_bash",
+] as const;
+
+/**
+ * Tools whose permission candidates include a URL.
+ */
+export const URL_TOOLS = ["web_fetch", "network_request"] as const;
+
+/**
+ * Tools that manage first-party skill packages (scaffold/delete).
+ */
+export const MANAGED_SKILL_TOOLS = [
+  "scaffold_managed_skill",
+  "delete_managed_skill",
+] as const;
+
+/**
+ * The skill_load tool name. Separated from the array constants because
+ * skill_load is a singleton, not a family with multiple members.
+ */
+export const SKILL_LOAD_TOOL = "skill_load" as const;
+
+/** Set for O(1) lookups when classifying tool names. */
+const SCOPED_TOOLS_SET: ReadonlySet<string> = new Set(SCOPED_TOOLS);
+const URL_TOOLS_SET: ReadonlySet<string> = new Set(URL_TOOLS);
+const MANAGED_SKILL_TOOLS_SET: ReadonlySet<string> = new Set(
+  MANAGED_SKILL_TOOLS,
+);
+
+// ---------------------------------------------------------------------------
+// Type guards
+// ---------------------------------------------------------------------------
+
+/** Returns true when the rule's tool belongs to the scoped-tool family. */
+export function isScopedRule(rule: { tool: string }): boolean {
+  return SCOPED_TOOLS_SET.has(rule.tool);
+}
+
+/** Returns true when the rule's tool belongs to the URL-tool family. */
+export function isUrlRule(rule: { tool: string }): boolean {
+  return URL_TOOLS_SET.has(rule.tool);
+}
+
+/** Returns true when the rule's tool belongs to the managed-skill-tool family. */
+export function isManagedSkillRule(rule: { tool: string }): boolean {
+  return MANAGED_SKILL_TOOLS_SET.has(rule.tool);
+}
+
+/** Returns true when the rule's tool is the skill_load tool. */
+export function isSkillLoadRule(rule: { tool: string }): boolean {
+  return rule.tool === SKILL_LOAD_TOOL;
+}
+
+// ---------------------------------------------------------------------------
+// Scope helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Return the effective scope for any trust rule. Only scoped rules carry a
+ * `scope` field; all other rule families return `"everywhere"`.
+ */
+export function ruleScope(rule: { tool: string; scope?: string }): string {
+  if (isScopedRule(rule)) {
+    return rule.scope ?? "everywhere";
+  }
+  return "everywhere";
+}
+

package/node_modules/@mycadet/service-contracts/src/twilio-ingress.ts

@@ -0,0 +1,73 @@
+import { normalizePublicBaseUrl } from "./ingress.js";
+
+export const TWILIO_VOICE_WEBHOOK_PATH = "/webhooks/twilio/voice";
+export const TWILIO_STATUS_WEBHOOK_PATH = "/webhooks/twilio/status";
+export const TWILIO_MEDIA_STREAM_WEBHOOK_PATH = "/webhooks/twilio/media-stream";
+
+/**
+ * Sentinel placeholder embedded in TwiML by the assistant where the real
+ * public base URL should go. The gateway replaces `wss://__CADET_PUBLIC_BASE_URL__/…`
+ * with the actual public URL (from Tunnel registration, config, or the
+ * `X-Cadet-Ingress-URL` header) before returning TwiML to Twilio.
+ *
+ * The placeholder uses `https://` so that `buildTwilioMediaStreamUrl` can
+ * apply the standard `http→ws` scheme conversion, producing
+ * `wss://__CADET_PUBLIC_BASE_URL__/…` in the output.
+ */
+export const TWILIO_PUBLIC_BASE_URL_PLACEHOLDER =
+  "https://__CADET_PUBLIC_BASE_URL__";
+
+/**
+ * The WebSocket-scheme form of the placeholder that appears in TwiML after
+ * the `http→ws` scheme conversion applied by the URL builders.
+ */
+export const TWILIO_PUBLIC_BASE_WSS_PLACEHOLDER =
+  "wss://__CADET_PUBLIC_BASE_URL__";
+
+export { normalizePublicBaseUrl } from "./ingress.js";
+
+export type TwilioPhoneNumberWebhookUrls = {
+  statusCallbackUrl: string;
+  voiceUrl: string;
+};
+
+export function resolveTwilioPublicBaseUrl(
+  ingress: { publicBaseUrl?: unknown } | undefined,
+  fallbackPublicBaseUrl?: unknown,
+): string | undefined {
+  const publicBaseUrl = normalizePublicBaseUrl(ingress?.publicBaseUrl);
+  if (publicBaseUrl) return publicBaseUrl;
+
+  return normalizePublicBaseUrl(fallbackPublicBaseUrl);
+}
+
+export function buildTwilioVoiceWebhookUrl(
+  baseUrl: string,
+  callSessionId?: string,
+): string {
+  if (callSessionId) {
+    return `${baseUrl}${TWILIO_VOICE_WEBHOOK_PATH}?callSessionId=${callSessionId}`;
+  }
+  return `${baseUrl}${TWILIO_VOICE_WEBHOOK_PATH}`;
+}
+
+export function buildTwilioStatusWebhookUrl(baseUrl: string): string {
+  return `${baseUrl}${TWILIO_STATUS_WEBHOOK_PATH}`;
+}
+
+export function buildTwilioMediaStreamUrl(baseUrl: string): string {
+  return `${toTwilioWebSocketBaseUrl(baseUrl)}${TWILIO_MEDIA_STREAM_WEBHOOK_PATH}`;
+}
+
+export function buildTwilioPhoneNumberWebhookUrls(
+  baseUrl: string,
+): TwilioPhoneNumberWebhookUrls {
+  return {
+    statusCallbackUrl: buildTwilioStatusWebhookUrl(baseUrl),
+    voiceUrl: buildTwilioVoiceWebhookUrl(baseUrl),
+  };
+}
+
+function toTwilioWebSocketBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/^http(s?)/, "ws$1");
+}

package/node_modules/@mycadet/service-contracts/src/url-normalization.ts

@@ -0,0 +1,107 @@
+/**
+ * Canonical URL normalization for web tool inputs, shared by the gateway's
+ * risk classifiers and the daemon's URL safety checks.
+ *
+ * A URL a model passes to `web_fetch` / `network_request` reaches more than
+ * one consumer, and they must agree on what counts as the same target: the
+ * gateway builds the trust-rule ladder from it, and anything that later
+ * compares a URL to a saved rule has to fold the same spellings together. Two
+ * normalizations would mean two answers, so it lives here rather than in
+ * either process.
+ *
+ * Data-only in spirit: no imports, no config, no I/O.
+ */
+
+/** Whether a bare `host:port` (or `[v6]:port`) shorthand was written. */
+export function looksLikeHostPortShorthand(value: string): boolean {
+  if (/^\[[0-9a-fA-F:.%]+\]:\d+(?:[/?#]|$)/.test(value)) {
+    return true;
+  }
+  return /^[^/?#@\s:]+:\d+(?:[/?#]|$)/.test(value);
+}
+
+/** Whether the input is a path, query, or fragment rather than a URL. */
+export function looksLikePathOnlyInput(value: string): boolean {
+  return (
+    value.startsWith("/") ||
+    value.startsWith("./") ||
+    value.startsWith("../") ||
+    value.startsWith("?") ||
+    value.startsWith("#")
+  );
+}
+
+/**
+ * Strip the parts of a URL that must not affect a trust decision, and fold
+ * the encodings that would otherwise let one URL wear two spellings.
+ *
+ * Percent-escaped path segments are decoded (`/%70rivate` and `/private` are
+ * one path, so a path-scoped rule cannot be bypassed by escaping), a trailing
+ * root dot is dropped from the hostname, and fragment and userinfo are
+ * removed: the fragment never reaches the server, and credentials in the
+ * authority must never end up in a saved rule.
+ */
+export function canonicalizeWebUrl(parsed: URL): URL {
+  parsed.hash = "";
+  parsed.username = "";
+  parsed.password = "";
+
+  try {
+    parsed.pathname = decodeURI(parsed.pathname);
+  } catch {
+    // Keep the URL parser's canonical form when decoding fails.
+  }
+
+  if (parsed.hostname.endsWith(".")) {
+    parsed.hostname = parsed.hostname.replace(/\.+$/, "");
+  }
+
+  return parsed;
+}
+
+/**
+ * Parse and canonicalize a web tool's `url` input, or `null` when it is not a
+ * URL this system will fetch.
+ *
+ * Accepts `https://host/path`, `http://…`, bare `host/path`, and `host:port`
+ * shorthand. Rejects path-only input and any other scheme (`file:`, `data:`,
+ * `javascript:`), so a non-http target can never acquire a web trust rule.
+ */
+export function normalizeWebUrl(rawUrl: string): URL | null {
+  const trimmed = rawUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  if (looksLikeHostPortShorthand(trimmed)) {
+    try {
+      return canonicalizeWebUrl(new URL(`https://${trimmed}`));
+    } catch {
+      return null;
+    }
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+      return canonicalizeWebUrl(parsed);
+    }
+    return null;
+  } catch {
+    // Not an absolute URL; fall through to the shorthand forms.
+  }
+
+  if (looksLikePathOnlyInput(trimmed)) {
+    return null;
+  }
+
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) {
+    return null;
+  }
+
+  try {
+    return canonicalizeWebUrl(new URL(`https://${trimmed}`));
+  } catch {
+    return null;
+  }
+}

package/node_modules/@mycadet/service-contracts/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -1,10 +1,42 @@
 {
   "name": "@mycadet/credential-executor",
-  "version": "0.0.1",
-  "description": "MyCadet: personal intelligence for all.",
-  "homepage": "https://mycadet.ai",
-  "repository": { "type": "git", "url": "github:vargasjr-dev/mycadet" },
-  "author": "Vargas JR LLC",
-  "license": "MIT"
+  "version": "0.12.6-dev.202610080043.b727a33",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "bin": {
+    "credential-executor": "./src/main.ts",
+    "ces": "./src/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/main.ts",
+    "dev:managed": "CES_MODE=managed bun run src/main.ts",
+    "lint": "eslint",
+    "lint:unused": "knip --include files,dependencies,unlisted",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test src/"
+  },
+  "dependencies": {
+    "@mycadet/credential-storage": "file:../packages/credential-storage",
+    "@mycadet/egress-proxy": "file:../packages/egress-proxy",
+    "@mycadet/ipc-server-utils": "file:../packages/ipc-server-utils",
+    "@mycadet/service-contracts": "file:../packages/service-contracts",
+    "pino": "9.14.0",
+    "pino-pretty": "13.1.3"
+  },
+  "bundledDependencies": [
+    "@mycadet/service-contracts",
+    "@mycadet/credential-storage",
+    "@mycadet/egress-proxy",
+    "@mycadet/ipc-server-utils"
+  ],
+  "devDependencies": {
+    "@types/bun": "1.3.10",
+    "eslint": "10.1.0",
+    "knip": "5.88.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.58.0"
+  }
 }
-

package/src/__tests__/bulk-set-credentials.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Tests for the BulkSetCredentials RPC handler.
+ *
+ * Validates that the handler stores each credential independently and
+ * returns per-credential success/failure status.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { CesRpcMethod } from "@mycadet/service-contracts/credential-rpc";
+import type { SecureKeyBackend } from "@mycadet/credential-storage";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal BulkSetCredentials handler using the same logic as
+ * main.ts, backed by the given SecureKeyBackend.
+ */
+function buildBulkSetHandler(secureKeyBackend: SecureKeyBackend) {
+  return async (req: {
+    credentials: Array<{ account: string; value: string }>;
+  }) => {
+    const results = [];
+    for (const { account, value } of req.credentials) {
+      const ok = await secureKeyBackend.set(account, value);
+      results.push({ account, ok });
+    }
+    return { results };
+  };
+}
+
+/**
+ * Create an in-memory SecureKeyBackend for testing.
+ * Optionally accepts a set of accounts that should fail on set().
+ */
+function createMockBackend(
+  failingAccounts: Set<string> = new Set(),
+): SecureKeyBackend & { store: Map<string, string> } {
+  const store = new Map<string, string>();
+  return {
+    store,
+    async get(key: string) {
+      return store.get(key);
+    },
+    async set(key: string, value: string) {
+      if (failingAccounts.has(key)) {
+        return false;
+      }
+      store.set(key, value);
+      return true;
+    },
+    async delete(key: string) {
+      if (store.has(key)) {
+        store.delete(key);
+        return "deleted";
+      }
+      return "not-found";
+    },
+    async list() {
+      return Array.from(store.keys());
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("BulkSetCredentials handler", () => {
+  test("stores multiple credentials and returns ok: true for each", async () => {
+    const backend = createMockBackend();
+    const handler = buildBulkSetHandler(backend);
+
+    const result = await handler({
+      credentials: [
+        { account: "acct-1", value: "secret-1" },
+        { account: "acct-2", value: "secret-2" },
+        { account: "acct-3", value: "secret-3" },
+      ],
+    });
+
+    expect(result.results).toEqual([
+      { account: "acct-1", ok: true },
+      { account: "acct-2", ok: true },
+      { account: "acct-3", ok: true },
+    ]);
+
+    // Verify all credentials were actually stored
+    expect(await backend.get("acct-1")).toBe("secret-1");
+    expect(await backend.get("acct-2")).toBe("secret-2");
+    expect(await backend.get("acct-3")).toBe("secret-3");
+  });
+
+  test("partial failure returns mixed results without aborting the rest", async () => {
+    const failingAccounts = new Set(["acct-2"]);
+    const backend = createMockBackend(failingAccounts);
+    const handler = buildBulkSetHandler(backend);
+
+    const result = await handler({
+      credentials: [
+        { account: "acct-1", value: "secret-1" },
+        { account: "acct-2", value: "secret-2" },
+        { account: "acct-3", value: "secret-3" },
+      ],
+    });
+
+    expect(result.results).toEqual([
+      { account: "acct-1", ok: true },
+      { account: "acct-2", ok: false },
+      { account: "acct-3", ok: true },
+    ]);
+
+    // acct-1 and acct-3 should be stored; acct-2 should not
+    expect(await backend.get("acct-1")).toBe("secret-1");
+    expect(await backend.get("acct-2")).toBeUndefined();
+    expect(await backend.get("acct-3")).toBe("secret-3");
+  });
+
+  test("empty credentials array returns empty results array", async () => {
+    const backend = createMockBackend();
+    const handler = buildBulkSetHandler(backend);
+
+    const result = await handler({ credentials: [] });
+
+    expect(result.results).toEqual([]);
+  });
+
+  test("handler is registered under the correct RPC method key", () => {
+    // Verify the enum value matches what we register against
+    expect(CesRpcMethod.BulkSetCredentials).toBe("bulk_set_credentials");
+  });
+});

package/src/__tests__/ces-migrations-002-api-keys.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, test } from "bun:test";
+
+import { apiKeyToCredentialsMigration } from "../migrations/002-api-keys-to-credentials.js";
+import type { SecureKeyBackend } from "@mycadet/credential-storage";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates an in-memory SecureKeyBackend backed by a Map<string, string>.
+ * Allows us to assert state before/after migration without relying on mocked
+ * function call tracking.
+ */
+function makeMapBackend(
+  initial: Record<string, string> = {},
+): SecureKeyBackend & { store: Map<string, string> } {
+  const store = new Map<string, string>(Object.entries(initial));
+  return {
+    store,
+    get: (_key: string) => Promise.resolve(store.get(_key)),
+    set: (_key: string, value: string) => {
+      store.set(_key, value);
+      return Promise.resolve(true);
+    },
+    delete: (_key: string) => {
+      const existed = store.has(_key);
+      store.delete(_key);
+      return Promise.resolve({ deleted: existed });
+    },
+    list: () => Promise.resolve([...store.keys()]),
+  } as unknown as SecureKeyBackend & { store: Map<string, string> };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("apiKeyToCredentialsMigration (002)", () => {
+  // -------------------------------------------------------------------------
+  // run()
+  // -------------------------------------------------------------------------
+
+  describe("run()", () => {
+    test("bare key present — writes credential key and deletes bare key", async () => {
+      const backend = makeMapBackend({ anthropic: "sk-ant-123" });
+
+      await apiKeyToCredentialsMigration.run(backend);
+
+      expect(backend.store.get("credential/anthropic/api_key")).toBe(
+        "sk-ant-123",
+      );
+      expect(backend.store.has("anthropic")).toBe(false);
+    });
+
+    test("idempotent — credential key already exists: bare key deleted, credential value unchanged", async () => {
+      const backend = makeMapBackend({
+        anthropic: "sk-ant-new",
+        "credential/anthropic/api_key": "sk-ant-existing",
+      });
+
+      await apiKeyToCredentialsMigration.run(backend);
+
+      // Credential key must NOT be overwritten
+      expect(backend.store.get("credential/anthropic/api_key")).toBe(
+        "sk-ant-existing",
+      );
+      // Bare key must be removed
+      expect(backend.store.has("anthropic")).toBe(false);
+    });
+
+    test("no bare key for provider — no write and no delete for that provider", async () => {
+      // Store only has a key for openai; anthropic has nothing
+      const backend = makeMapBackend({ openai: "sk-openai-abc" });
+
+      await apiKeyToCredentialsMigration.run(backend);
+
+      // openai should be migrated
+      expect(backend.store.get("credential/openai/api_key")).toBe(
+        "sk-openai-abc",
+      );
+      expect(backend.store.has("openai")).toBe(false);
+
+      // anthropic: credential key should NOT exist (no accidental write)
+      expect(backend.store.has("credential/anthropic/api_key")).toBe(false);
+    });
+
+    test("multiple providers — each handled independently", async () => {
+      const backend = makeMapBackend({
+        anthropic: "sk-ant-multi",
+        openai: "sk-openai-multi",
+        gemini: "gemini-key",
+        brave: "brave-key",
+      });
+
+      await apiKeyToCredentialsMigration.run(backend);
+
+      // All bare keys gone
+      for (const provider of ["anthropic", "openai", "gemini", "brave"]) {
+        expect(backend.store.has(provider)).toBe(false);
+      }
+
+      // All credential keys present
+      expect(backend.store.get("credential/anthropic/api_key")).toBe(
+        "sk-ant-multi",
+      );
+      expect(backend.store.get("credential/openai/api_key")).toBe(
+        "sk-openai-multi",
+      );
+      expect(backend.store.get("credential/gemini/api_key")).toBe("gemini-key");
+      expect(backend.store.get("credential/brave/api_key")).toBe("brave-key");
+
+      // Providers that had no bare key should have no credential key
+      for (const provider of [
+        "ollama",
+        "fireworks",
+        "openrouter",
+        "perplexity",
+        "deepgram",
+        "xai",
+      ]) {
+        expect(backend.store.has(`credential/${provider}/api_key`)).toBe(false);
+      }
+    });
+
+    test("set() failure — bare key preserved, credential key absent", async () => {
+      const backend = makeMapBackend({ anthropic: "sk-ant-123" });
+      // Simulate a write failure
+      backend.set = (_key: string, _value: string) => Promise.resolve(false);
+
+      await apiKeyToCredentialsMigration.run(backend);
+
+      // Bare key must survive — it was not deleted because set() failed
+      expect(backend.store.get("anthropic")).toBe("sk-ant-123");
+      // Credential key must not exist
+      expect(backend.store.has("credential/anthropic/api_key")).toBe(false);
+    });
+
+    test("run() is idempotent — running twice leaves store in same state as once", async () => {
+      const backend = makeMapBackend({
+        anthropic: "sk-ant-idem",
+        openai: "sk-openai-idem",
+      });
+
+      await apiKeyToCredentialsMigration.run(backend);
+      // Capture state after first run
+      const afterFirst = new Map(backend.store);
+
+      await apiKeyToCredentialsMigration.run(backend);
+      // State after second run must match first run
+      expect(backend.store).toEqual(afterFirst);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // down()
+  // -------------------------------------------------------------------------
+
+  describe("down()", () => {
+    test("reverses a migrated key back to bare name", async () => {
+      const backend = makeMapBackend({
+        "credential/anthropic/api_key": "sk-ant-rev",
+      });
+
+      await apiKeyToCredentialsMigration.down(backend);
+
+      expect(backend.store.get("anthropic")).toBe("sk-ant-rev");
+      expect(backend.store.has("credential/anthropic/api_key")).toBe(false);
+    });
+
+    test("idempotent — bare key already exists: credential key deleted, bare key value unchanged", async () => {
+      const backend = makeMapBackend({
+        "credential/anthropic/api_key": "sk-ant-cred",
+        anthropic: "sk-ant-original",
+      });
+
+      await apiKeyToCredentialsMigration.down(backend);
+
+      // Bare key value must NOT be overwritten
+      expect(backend.store.get("anthropic")).toBe("sk-ant-original");
+      // Credential key must be removed
+      expect(backend.store.has("credential/anthropic/api_key")).toBe(false);
+    });
+  });
+});