@assistant-ui/react-mcp 0.1.16 → 0.1.18

package/src/resources/storage/types.ts

@@ -5,14 +5,16 @@ import type { MCPPersistedAuthState } from "../../auth/types";
 export type MCPStorage = {
   /**
    * Stable identity of the backing store. Two storages with the same scopeId
-   * must read and write the same persisted data. When present, server
-   * connections and the OAuth write fence key on it, so swapping to a
-   * differently-scoped storage reconnects instead of leaving a live OAuth flow
-   * on the replaced store, and clearing through a same-scoped replacement still
-   * waits for writes queued against the storage it replaced. When absent, the
-   * fence falls back to object identity while connections never re-key at all,
-   * so a storage rebuilt on every render has to declare a scopeId; without one
-   * a clear runs unfenced against the writes queued by the object it replaced.
+   * must read and write the same persisted data. When present, custom servers,
+   * server connections, and the OAuth write fence key on it. Swapping to a
+   * differently-scoped storage rehydrates its custom servers and reconnects
+   * authenticated servers instead of retaining data or a live OAuth flow from
+   * the replaced store. Clearing through a same-scoped replacement still waits
+   * for writes queued against the storage it replaced. When absent, the fence
+   * falls back to object identity while custom servers and connections never
+   * re-key. Replacing an unscoped storage can therefore persist the previous
+   * store's custom servers into the replacement, and a clear runs unfenced
+   * against writes queued by the object it replaced.
    */
   scopeId?: string;
   loadCustomServers: () => Promise<MCPCustomServerRecord[]>;

package/src/utils/serverUrl.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import {
+  hasPersistedCredentials,
+  isAuthStateForServerUrl,
+  normalizeMcpServerUrl,
+} from "./serverUrl";
+
+describe("normalizeMcpServerUrl", () => {
+  it("normalizes host case and the default port", () => {
+    expect(normalizeMcpServerUrl("https://MCP.Example.com:443/mcp")).toBe(
+      "https://mcp.example.com/mcp",
+    );
+  });
+});
+
+describe("isAuthStateForServerUrl", () => {
+  it("matches equivalent spellings of the same endpoint", () => {
+    expect(
+      isAuthStateForServerUrl(
+        { serverUrl: "https://MCP.Example.com/mcp" },
+        "https://mcp.example.com:443/mcp",
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects a different endpoint, an unbound record, and no record", () => {
+    expect(
+      isAuthStateForServerUrl(
+        { serverUrl: "https://a.example.com/mcp" },
+        "https://b.example.com/mcp",
+      ),
+    ).toBe(false);
+    expect(
+      isAuthStateForServerUrl({ token: "t" }, "https://a.example.com/mcp"),
+    ).toBe(false);
+    expect(isAuthStateForServerUrl(null, "https://a.example.com/mcp")).toBe(
+      false,
+    );
+  });
+
+  it("rejects an unparsable URL on either side", () => {
+    expect(
+      isAuthStateForServerUrl({ serverUrl: "not a url" }, "https://a.test/mcp"),
+    ).toBe(false);
+    expect(
+      isAuthStateForServerUrl({ serverUrl: "https://a.test/mcp" }, "not a url"),
+    ).toBe(false);
+  });
+});
+
+describe("hasPersistedCredentials", () => {
+  it("counts bearer and OAuth tokens, not flow state", () => {
+    expect(hasPersistedCredentials({ token: "t" })).toBe(true);
+    expect(hasPersistedCredentials({ token: "" })).toBe(false);
+    expect(
+      hasPersistedCredentials({
+        tokens: { access_token: "a", token_type: "bearer" },
+      }),
+    ).toBe(true);
+    expect(hasPersistedCredentials({ codeVerifier: "v", state: "s" })).toBe(
+      false,
+    );
+    expect(hasPersistedCredentials({})).toBe(false);
+    expect(hasPersistedCredentials(null)).toBe(false);
+  });
+});

package/src/utils/serverUrl.ts

@@ -0,0 +1,23 @@
+import type { MCPPersistedAuthState } from "../auth/types";
+
+export const normalizeMcpServerUrl = (serverUrl: string): string =>
+  new URL(serverUrl).toString();
+
+export const isAuthStateForServerUrl = (
+  state: MCPPersistedAuthState | null,
+  serverUrl: string,
+): boolean => {
+  if (state?.serverUrl === undefined) return false;
+  try {
+    return (
+      normalizeMcpServerUrl(state.serverUrl) ===
+      normalizeMcpServerUrl(serverUrl)
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const hasPersistedCredentials = (
+  state: MCPPersistedAuthState | null,
+): boolean => Boolean(state?.tokens) || Boolean(state?.token);