Merge branch 'main' into sushichan044-202510302252-node-version-syntax

olaservo · web-flow · commit 64898303aa65 · 2025-11-10T21:12:13.000-07:00
diff --git a/.github/workflows/e2e_tests.yml b/.github/workflows/e2e_tests.yml
@@ -8,7 +8,7 @@ on:
 
 jobs:
   test:
-    # Installing Playright dependencies can take quite awhile, and also depends on GitHub CI load.
+    # Installing Playwright dependencies can take quite awhile, and also depends on GitHub CI load.
     timeout-minutes: 15
     runs-on: ubuntu-latest
 
diff --git a/client/src/components/DynamicJsonForm.tsx b/client/src/components/DynamicJsonForm.tsx
@@ -113,8 +113,8 @@ const DynamicJsonForm = forwardRef<DynamicJsonFormRef, DynamicJsonFormProps>(
             setJsonError(errorMessage);
 
             // Reset to default for clearly invalid JSON (not just incomplete typing)
-            const trimmed = jsonString.trim();
-            if (trimmed.length > 5 && !trimmed.match(/^[\s[{]/)) {
+            const trimmed = jsonString?.trim();
+            if (trimmed && trimmed.length > 5 && !trimmed.match(/^[\s[{]/)) {
               onChange(generateDefaultValue(schema));
             }
           }
@@ -155,7 +155,7 @@ const DynamicJsonForm = forwardRef<DynamicJsonFormRef, DynamicJsonFormProps>(
 
     const formatJson = () => {
       try {
-        const jsonStr = rawJsonValue.trim();
+        const jsonStr = rawJsonValue?.trim();
         if (!jsonStr) {
           return;
         }
@@ -171,7 +171,7 @@ const DynamicJsonForm = forwardRef<DynamicJsonFormRef, DynamicJsonFormProps>(
     const validateJson = () => {
       if (!isJsonMode) return { isValid: true, error: null };
       try {
-        const jsonStr = rawJsonValue.trim();
+        const jsonStr = rawJsonValue?.trim();
         if (!jsonStr) return { isValid: true, error: null };
         const parsed = JSON.parse(jsonStr);
         // Clear any pending debounced update and immediately update parent
diff --git a/client/src/components/ToolsTab.tsx b/client/src/components/ToolsTab.tsx
@@ -18,6 +18,7 @@ import {
   generateDefaultValue,
   isPropertyRequired,
   normalizeUnionType,
+  resolveRef,
 } from "@/utils/schemaUtils";
 import {
   CompatibilityCallToolResult,
@@ -90,14 +91,21 @@ const ToolsTab = ({
   useEffect(() => {
     const params = Object.entries(
       selectedTool?.inputSchema.properties ?? [],
-    ).map(([key, value]) => [
-      key,
-      generateDefaultValue(
+    ).map(([key, value]) => {
+      // First resolve any $ref references
+      const resolvedValue = resolveRef(
         value as JsonSchemaType,
-        key,
         selectedTool?.inputSchema as JsonSchemaType,
-      ),
-    ]);
+      );
+      return [
+        key,
+        generateDefaultValue(
+          resolvedValue,
+          key,
+          selectedTool?.inputSchema as JsonSchemaType,
+        ),
+      ];
+    });
     setParams(Object.fromEntries(params));
 
     // Reset validation errors when switching tools
@@ -154,7 +162,12 @@ const ToolsTab = ({
                 </p>
                 {Object.entries(selectedTool.inputSchema.properties ?? []).map(
                   ([key, value]) => {
-                    const prop = normalizeUnionType(value as JsonSchemaType);
+                    // First resolve any $ref references
+                    const resolvedValue = resolveRef(
+                      value as JsonSchemaType,
+                      selectedTool.inputSchema as JsonSchemaType,
+                    );
+                    const prop = normalizeUnionType(resolvedValue);
                     const inputSchema =
                       selectedTool.inputSchema as JsonSchemaType;
                     const required = isPropertyRequired(key, inputSchema);
@@ -181,16 +194,18 @@ const ToolsTab = ({
                                     ...params,
                                     [key]: checked
                                       ? null
-                                      : prop.default !== null
-                                        ? prop.default
-                                        : prop.type === "boolean"
-                                          ? false
-                                          : prop.type === "string"
-                                            ? ""
-                                            : prop.type === "number" ||
-                                                prop.type === "integer"
-                                              ? undefined
-                                              : undefined,
+                                      : prop.type === "array"
+                                        ? undefined
+                                        : prop.default !== null
+                                          ? prop.default
+                                          : prop.type === "boolean"
+                                            ? false
+                                            : prop.type === "string"
+                                              ? ""
+                                              : prop.type === "number" ||
+                                                  prop.type === "integer"
+                                                ? undefined
+                                                : undefined,
                                   })
                                 }
                               />
diff --git a/client/src/lib/auth.ts b/client/src/lib/auth.ts
@@ -102,16 +102,40 @@ export const clearClientInformationFromSessionStorage = ({
   sessionStorage.removeItem(key);
 };
 
+export const getScopeFromSessionStorage = (
+  serverUrl: string,
+): string | undefined => {
+  const key = getServerSpecificKey(SESSION_KEYS.SCOPE, serverUrl);
+  const value = sessionStorage.getItem(key);
+  return value || undefined;
+};
+
+export const saveScopeToSessionStorage = (
+  serverUrl: string,
+  scope: string | undefined,
+) => {
+  const key = getServerSpecificKey(SESSION_KEYS.SCOPE, serverUrl);
+  if (scope) {
+    sessionStorage.setItem(key, scope);
+  } else {
+    sessionStorage.removeItem(key);
+  }
+};
+
+export const clearScopeFromSessionStorage = (serverUrl: string) => {
+  const key = getServerSpecificKey(SESSION_KEYS.SCOPE, serverUrl);
+  sessionStorage.removeItem(key);
+};
+
 export class InspectorOAuthClientProvider implements OAuthClientProvider {
-  constructor(
-    protected serverUrl: string,
-    scope?: string,
-  ) {
-    this.scope = scope;
+  constructor(protected serverUrl: string) {
     // Save the server URL to session storage
     sessionStorage.setItem(SESSION_KEYS.SERVER_URL, serverUrl);
   }
-  scope: string | undefined;
+
+  get scope(): string | undefined {
+    return getScopeFromSessionStorage(this.serverUrl);
+  }
 
   get redirectUrl() {
     return window.location.origin + "/oauth/callback";
diff --git a/client/src/lib/constants.ts b/client/src/lib/constants.ts
@@ -17,6 +17,7 @@ export const SESSION_KEYS = {
   PREREGISTERED_CLIENT_INFORMATION: "mcp_preregistered_client_information",
   SERVER_METADATA: "mcp_server_metadata",
   AUTH_DEBUGGER_STATE: "mcp_auth_debugger_state",
+  SCOPE: "mcp_scope",
 } as const;
 
 // Generate server-specific session storage keys
diff --git a/client/src/lib/hooks/__tests__/useConnection.test.tsx b/client/src/lib/hooks/__tests__/useConnection.test.tsx
@@ -112,6 +112,8 @@ jest.mock("../../auth", () => ({
   })),
   clearClientInformationFromSessionStorage: jest.fn(),
   saveClientInformationToSessionStorage: jest.fn(),
+  saveScopeToSessionStorage: jest.fn(),
+  clearScopeFromSessionStorage: jest.fn(),
   discoverScopes: jest.fn(),
 }));
 
diff --git a/client/src/lib/hooks/useConnection.ts b/client/src/lib/hooks/useConnection.ts
@@ -45,6 +45,8 @@ import {
   clearClientInformationFromSessionStorage,
   InspectorOAuthClientProvider,
   saveClientInformationToSessionStorage,
+  saveScopeToSessionStorage,
+  clearScopeFromSessionStorage,
   discoverScopes,
 } from "../auth";
 import {
@@ -142,6 +144,15 @@ export function useConnection({
     });
   }, [oauthClientId, oauthClientSecret, sseUrl]);
 
+  useEffect(() => {
+    if (!oauthScope) {
+      clearScopeFromSessionStorage(sseUrl);
+      return;
+    }
+
+    saveScopeToSessionStorage(sseUrl, oauthScope);
+  }, [oauthScope, sseUrl]);
+
   const pushHistory = (request: object, response?: object) => {
     setRequestHistory((prev) => [
       ...prev,
@@ -346,10 +357,9 @@ export function useConnection({
         }
         scope = await discoverScopes(sseUrl, resourceMetadata);
       }
-      const serverAuthProvider = new InspectorOAuthClientProvider(
-        sseUrl,
-        scope,
-      );
+
+      saveScopeToSessionStorage(sseUrl, scope);
+      const serverAuthProvider = new InspectorOAuthClientProvider(sseUrl);
 
       const result = await auth(serverAuthProvider, {
         serverUrl: sseUrl,
diff --git a/client/src/lib/oauth-state-machine.ts b/client/src/lib/oauth-state-machine.ts
@@ -80,13 +80,16 @@ export const oauthTransitions: Record<OAuthStep, StateTransition> = {
       const metadata = context.state.oauthMetadata!;
       const clientMetadata = context.provider.clientMetadata;
 
-      // Prefer scopes from resource metadata if available
-      const scopesSupported =
-        context.state.resourceMetadata?.scopes_supported ||
-        metadata.scopes_supported;
-      // Add all supported scopes to client registration
-      if (scopesSupported) {
-        clientMetadata.scope = scopesSupported.join(" ");
+      // Priority: user-provided scope > discovered scopes
+      if (!context.provider.scope || context.provider.scope.trim() === "") {
+        // Prefer scopes from resource metadata if available
+        const scopesSupported =
+          context.state.resourceMetadata?.scopes_supported ||
+          metadata.scopes_supported;
+        // Add all supported scopes to client registration
+        if (scopesSupported) {
+          clientMetadata.scope = scopesSupported.join(" ");
+        }
       }
 
       // Try Static client first, with DCR as fallback
@@ -113,10 +116,14 @@ export const oauthTransitions: Record<OAuthStep, StateTransition> = {
       const metadata = context.state.oauthMetadata!;
       const clientInformation = context.state.oauthClientInfo!;
 
-      const scope = await discoverScopes(
-        context.serverUrl,
-        context.state.resourceMetadata ?? undefined,
-      );
+      // Priority: user-provided scope > discovered scopes
+      let scope = context.provider.scope;
+      if (!scope || scope.trim() === "") {
+        scope = await discoverScopes(
+          context.serverUrl,
+          context.state.resourceMetadata ?? undefined,
+        );
+      }
 
       const { authorizationUrl, codeVerifier } = await startAuthorization(
         context.serverUrl,
diff --git a/client/src/utils/jsonUtils.ts b/client/src/utils/jsonUtils.ts
@@ -48,6 +48,7 @@ export type JsonSchemaType = {
   const?: JsonValue;
   oneOf?: (JsonSchemaType | JsonSchemaConst)[];
   anyOf?: (JsonSchemaType | JsonSchemaConst)[];
+  $ref?: string;
 };
 
 export type JsonObject = { [key: string]: JsonValue };
@@ -84,8 +85,9 @@ export function tryParseJson(str: string): {
   success: boolean;
   data: JsonValue;
 } {
-  const trimmed = str.trim();
+  const trimmed = str?.trim();
   if (
+    trimmed &&
     !(trimmed.startsWith("{") && trimmed.endsWith("}")) &&
     !(trimmed.startsWith("[") && trimmed.endsWith("]"))
   ) {
diff --git a/client/src/utils/schemaUtils.ts b/client/src/utils/schemaUtils.ts
@@ -145,6 +145,50 @@ export function isPropertyRequired(
   return schema.required?.includes(propertyName) ?? false;
 }
 
+/**
+ * Resolves $ref references in JSON schema
+ * @param schema The schema that may contain $ref
+ * @param rootSchema The root schema to resolve references against
+ * @returns The resolved schema without $ref
+ */
+export function resolveRef(
+  schema: JsonSchemaType,
+  rootSchema: JsonSchemaType,
+): JsonSchemaType {
+  if (!("$ref" in schema) || !schema.$ref) {
+    return schema;
+  }
+
+  const ref = schema.$ref;
+
+  // Handle simple #/properties/name references
+  if (ref.startsWith("#/")) {
+    const path = ref.substring(2).split("/");
+    let current: unknown = rootSchema;
+
+    for (const segment of path) {
+      if (
+        current &&
+        typeof current === "object" &&
+        current !== null &&
+        segment in current
+      ) {
+        current = (current as Record<string, unknown>)[segment];
+      } else {
+        // If reference cannot be resolved, return the original schema
+        console.warn(`Could not resolve $ref: ${ref}`);
+        return schema;
+      }
+    }
+
+    return current as JsonSchemaType;
+  }
+
+  // For other types of references, return the original schema
+  console.warn(`Unsupported $ref format: ${ref}`);
+  return schema;
+}
+
 /**
  * Normalizes union types (like string|null from FastMCP) to simple types for form rendering
  * @param schema The JSON schema to normalize
@@ -191,6 +235,16 @@ export function normalizeUnionType(schema: JsonSchemaType): JsonSchemaType {
     return { ...schema, type: "integer", anyOf: undefined, nullable: true };
   }
 
+  // Handle anyOf with exactly array and null (FastMCP pattern)
+  if (
+    schema.anyOf &&
+    schema.anyOf.length === 2 &&
+    schema.anyOf.some((t) => (t as JsonSchemaType).type === "array") &&
+    schema.anyOf.some((t) => (t as JsonSchemaType).type === "null")
+  ) {
+    return { ...schema, type: "array", anyOf: undefined, nullable: true };
+  }
+
   // Handle array type with exactly string and null
   if (
     Array.isArray(schema.type) &&
