@modelcontextprotocol/inspector 0.4.0 → 0.4.1

package/client/dist/assets/{OAuthCallback-HUNd2OJn.js → OAuthCallback-DCSQTqKf.js}

@@ -1,4 +1,4 @@
-import { r as reactExports, j as jsxRuntimeExports, S as SESSION_KEYS, h as handleOAuthCallback } from "./index-DjoEM10P.js";
+import { r as reactExports, j as jsxRuntimeExports, S as SESSION_KEYS, h as handleOAuthCallback } from "./index-DVugRvpa.js";
 const OAuthCallback = () => {
   const hasProcessedRef = reactExports.useRef(false);
   reactExports.useEffect(() => {
@@ -16,8 +16,14 @@ const OAuthCallback = () => {
         return;
       }
       try {
-        const accessToken = await handleOAuthCallback(serverUrl, code);
-        sessionStorage.setItem(SESSION_KEYS.ACCESS_TOKEN, accessToken);
+        const tokens = await handleOAuthCallback(serverUrl, code);
+        sessionStorage.setItem(SESSION_KEYS.ACCESS_TOKEN, tokens.access_token);
+        if (tokens.refresh_token) {
+          sessionStorage.setItem(
+            SESSION_KEYS.REFRESH_TOKEN,
+            tokens.refresh_token
+          );
+        }
         window.location.href = `/?serverUrl=${encodeURIComponent(serverUrl)}`;
       } catch (error) {
         console.error("OAuth callback error:", error);

package/client/dist/assets/{index-DjoEM10P.js → index-DVugRvpa.js}

@@ -11230,16 +11230,32 @@ ZodReadonly.create = (type, params2) => {
     ...processCreateParams(params2)
   });
 };
-function custom(check, params2 = {}, fatal) {
+function cleanParams(params2, data) {
+  const p2 = typeof params2 === "function" ? params2(data) : typeof params2 === "string" ? { message: params2 } : params2;
+  const p22 = typeof p2 === "string" ? { message: p2 } : p2;
+  return p22;
+}
+function custom(check, _params = {}, fatal) {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
       var _a, _b;
-      if (!check(data)) {
-        const p2 = typeof params2 === "function" ? params2(data) : typeof params2 === "string" ? { message: params2 } : params2;
-        const _fatal = (_b = (_a = p2.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-        const p22 = typeof p2 === "string" ? { message: p2 } : p2;
-        ctx.addIssue({ code: "custom", ...p22, fatal: _fatal });
+      const r2 = check(data);
+      if (r2 instanceof Promise) {
+        return r2.then((r3) => {
+          var _a2, _b2;
+          if (!r3) {
+            const params2 = cleanParams(_params, data);
+            const _fatal = (_b2 = (_a2 = params2.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b2 !== void 0 ? _b2 : true;
+            ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
+          }
+        });
       }
+      if (!r2) {
+        const params2 = cleanParams(_params, data);
+        const _fatal = (_b = (_a = params2.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
+        ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
+      }
+      return;
     });
   return ZodAny.create();
 }
@@ -13118,27 +13134,39 @@ async function pkceChallenge(length) {
 const SESSION_KEYS = {
   CODE_VERIFIER: "mcp_code_verifier",
   SERVER_URL: "mcp_server_url",
-  ACCESS_TOKEN: "mcp_access_token"
+  ACCESS_TOKEN: "mcp_access_token",
+  REFRESH_TOKEN: "mcp_refresh_token"
 };
+const OAuthMetadataSchema = z.object({
+  authorization_endpoint: z.string(),
+  token_endpoint: z.string()
+});
+const OAuthTokensSchema = z.object({
+  access_token: z.string(),
+  refresh_token: z.string().optional(),
+  expires_in: z.number().optional()
+});
 async function discoverOAuthMetadata(serverUrl) {
   try {
     const url = new URL("/.well-known/oauth-authorization-server", serverUrl);
     const response = await fetch(url.toString());
     if (response.ok) {
       const metadata = await response.json();
-      return {
+      const validatedMetadata = OAuthMetadataSchema.parse({
         authorization_endpoint: metadata.authorization_endpoint,
         token_endpoint: metadata.token_endpoint
-      };
+      });
+      return validatedMetadata;
     }
   } catch (error) {
     console.warn("OAuth metadata discovery failed:", error);
   }
   const baseUrl = new URL(serverUrl);
-  return {
+  const defaultMetadata = {
     authorization_endpoint: new URL("/authorize", baseUrl).toString(),
     token_endpoint: new URL("/token", baseUrl).toString()
   };
+  return OAuthMetadataSchema.parse(defaultMetadata);
 }
 async function startOAuthFlow(serverUrl) {
   const challenge = await pkceChallenge();
@@ -13177,8 +13205,30 @@ async function handleOAuthCallback(serverUrl, code) {
   if (!response.ok) {
     throw new Error("Token exchange failed");
   }
-  const data = await response.json();
-  return data.access_token;
+  const tokens = await response.json();
+  return OAuthTokensSchema.parse(tokens);
+}
+async function refreshAccessToken(serverUrl) {
+  const refreshToken = sessionStorage.getItem(SESSION_KEYS.REFRESH_TOKEN);
+  if (!refreshToken) {
+    throw new Error("No refresh token available");
+  }
+  const metadata = await discoverOAuthMetadata(serverUrl);
+  const response = await fetch(metadata.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    throw new Error("Token refresh failed");
+  }
+  const tokens = await response.json();
+  return OAuthTokensSchema.parse(tokens);
 }
 const StdErrNotificationSchema = NotificationSchema.extend({
   method: z.literal("notifications/stderr"),
@@ -13257,7 +13307,46 @@ function useConnection({
       throw e;
     }
   };
-  const connect = async () => {
+  const initiateOAuthFlow = async () => {
+    sessionStorage.removeItem(SESSION_KEYS.ACCESS_TOKEN);
+    sessionStorage.removeItem(SESSION_KEYS.REFRESH_TOKEN);
+    sessionStorage.setItem(SESSION_KEYS.SERVER_URL, sseUrl);
+    const redirectUrl = await startOAuthFlow(sseUrl);
+    window.location.href = redirectUrl;
+  };
+  const handleTokenRefresh = async () => {
+    try {
+      const tokens = await refreshAccessToken(sseUrl);
+      sessionStorage.setItem(SESSION_KEYS.ACCESS_TOKEN, tokens.access_token);
+      if (tokens.refresh_token) {
+        sessionStorage.setItem(
+          SESSION_KEYS.REFRESH_TOKEN,
+          tokens.refresh_token
+        );
+      }
+      return tokens.access_token;
+    } catch (error) {
+      console.error("Token refresh failed:", error);
+      await initiateOAuthFlow();
+      throw error;
+    }
+  };
+  const handleAuthError = async (error) => {
+    if (error instanceof SseError && error.code === 401) {
+      if (sessionStorage.getItem(SESSION_KEYS.REFRESH_TOKEN)) {
+        try {
+          await handleTokenRefresh();
+          return true;
+        } catch (error2) {
+          console.error("Token refresh failed:", error2);
+        }
+      } else {
+        await initiateOAuthFlow();
+      }
+    }
+    return false;
+  };
+  const connect = async (_e, retryCount = 0) => {
     try {
       const client = new Client(
         {
@@ -13311,10 +13400,11 @@ function useConnection({
         await client.connect(clientTransport);
       } catch (error) {
         console.error("Failed to connect to MCP server:", error);
+        const shouldRetry = await handleAuthError(error);
+        if (shouldRetry) {
+          return connect(void 0, retryCount + 1);
+        }
         if (error instanceof SseError && error.code === 401) {
-          sessionStorage.setItem(SESSION_KEYS.SERVER_URL, sseUrl);
-          const redirectUrl = await startOAuthFlow(sseUrl);
-          window.location.href = redirectUrl;
           return;
         }
         throw error;
@@ -13520,11 +13610,11 @@ var SlotClone = reactExports.forwardRef((props, forwardedRef) => {
   const { children, ...slotProps } = props;
   if (reactExports.isValidElement(children)) {
     const childrenRef = getElementRef$1(children);
-    return reactExports.cloneElement(children, {
-      ...mergeProps(slotProps, children.props),
-      // @ts-ignore
-      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
-    });
+    const props2 = mergeProps(slotProps, children.props);
+    if (children.type !== reactExports.Fragment) {
+      props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
+    }
+    return reactExports.cloneElement(children, props2);
   }
   return reactExports.Children.count(children) > 1 ? reactExports.Children.only(null) : null;
 });
@@ -22560,7 +22650,7 @@ const useTheme = () => {
     }, [])
   ];
 };
-const version = "0.4.0";
+const version = "0.4.1";
 const Sidebar = ({
   connectionStatus,
   transportType,
@@ -23012,7 +23102,7 @@ const PROXY_SERVER_URL = `http://localhost:${PROXY_PORT}`;
 const App = () => {
   if (window.location.pathname === "/oauth/callback") {
     const OAuthCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthCallback-HUNd2OJn.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthCallback-DCSQTqKf.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthCallback, {}) });
   }

package/client/dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/mcp.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCP Inspector</title>
-    <script type="module" crossorigin src="/assets/index-DjoEM10P.js"></script>
+    <script type="module" crossorigin src="/assets/index-DVugRvpa.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-eOhPEcGC.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/inspector",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Model Context Protocol inspector",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -33,8 +33,8 @@
     "publish-all": "npm publish --workspaces --access public && npm publish --access public"
   },
   "dependencies": {
-    "@modelcontextprotocol/inspector-client": "0.3.0",
-    "@modelcontextprotocol/inspector-server": "0.3.0",
+    "@modelcontextprotocol/inspector-client": "0.4.1",
+    "@modelcontextprotocol/inspector-server": "0.4.1",
     "concurrently": "^9.0.1",
     "shell-quote": "^1.8.2",
     "spawn-rx": "^5.1.0",

package/server/build/index.js

@@ -145,4 +145,15 @@ app.get("/config", (req, res) => {
     }
 });
 const PORT = process.env.PORT || 3000;
-app.listen(PORT, () => { });
+try {
+    const server = app.listen(PORT);
+    server.on("listening", () => {
+        const addr = server.address();
+        const port = typeof addr === "string" ? addr : addr?.port;
+        console.log(`Proxy server listening on port ${port}`);
+    });
+}
+catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+}