@assistant-ui/react-mcp 0.1.15 → 0.1.17

package/src/resources/storage/McpMemoryStorage.ts

@@ -1,24 +1,30 @@
 import { resource } from "@assistant-ui/tap";
+import { useMemo } from "react";
+import { generateId } from "@assistant-ui/core";
 import type { MCPCustomServerRecord } from "../../mcp-scope";
 import type { MCPPersistedAuthState } from "../../auth/types";
 import type { MCPStorage } from "./types";
 
-const useMcpMemoryStorage = (): MCPStorage => {
-  let servers: MCPCustomServerRecord[] = [];
-  const auth = new Map<string, MCPPersistedAuthState>();
-  return {
-    loadCustomServers: async () => [...servers],
-    saveCustomServers: async (records) => {
-      servers = [...records];
-    },
-    loadAuthState: async (id) => auth.get(id) ?? null,
-    saveAuthState: async (id, state) => {
-      auth.set(id, state);
-    },
-    clearAuthState: async (id) => {
-      auth.delete(id);
-    },
-  };
-};
+const useMcpMemoryStorage = (): MCPStorage =>
+  useMemo(() => {
+    let servers: MCPCustomServerRecord[] = [];
+    const auth = new Map<string, MCPPersistedAuthState>();
+    return {
+      // Each memory store is its own private data: a distinct instance is a
+      // distinct scope, so replacing one keys a reconnect.
+      scopeId: `memory:${generateId()}`,
+      loadCustomServers: async () => [...servers],
+      saveCustomServers: async (records) => {
+        servers = [...records];
+      },
+      loadAuthState: async (id) => auth.get(id) ?? null,
+      saveAuthState: async (id, state) => {
+        auth.set(id, state);
+      },
+      clearAuthState: async (id) => {
+        auth.delete(id);
+      },
+    };
+  }, []);
 
 export const McpMemoryStorage = resource(useMcpMemoryStorage);

package/src/resources/storage/types.ts

@@ -3,6 +3,18 @@ import type { MCPCustomServerRecord } from "../../mcp-scope";
 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.
+   */
+  scopeId?: string;
   loadCustomServers: () => Promise<MCPCustomServerRecord[]>;
   saveCustomServers: (records: MCPCustomServerRecord[]) => Promise<void>;
   loadAuthState: (serverId: string) => Promise<MCPPersistedAuthState | null>;

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);