feat(core): port v1.5 InspectorClient + transports + auth subsystem (#1302) (#1306)

* wip(core): bulk-copy v1.5 InspectorClient runtime files (#1302)

Verbatim ports from origin/v1.5/main into v2/main core/:

- logging/ (2 files)
- storage/ + storage/adapters/ (4 files)
- auth/ + auth/browser/ + auth/node/ + auth/remote/ (16 files)
- mcp/config.ts + mcp/node/ (4 files, stdio transport)
- mcp/remote/ + mcp/remote/node/ (12 files, HTTP/SSE transport)
- mcp/inspectorClient.ts (~2169 LOC), messageTrackingTransport,
  fetchTracking, oauthManager, index, state/index

Total: ~7,800 LOC of source files, copied unmodified via
`git show origin/v1.5/main:<path> > <dest>`.

Also:
- Add deps: pino, hono, @hono/node-server, atomically, zustand, @types/node
- tsconfig.app.json: extend paths to resolve new node-only deps from
  core/, add "node" to types, disable erasableSyntaxOnly (v1.5 code
  uses parameter properties — TODO to re-enable in follow-up)

Compiles down to 47 type errors, all in three categories:
- 24 TS2305: v2 dropped v1.5 type exports (InspectorClientOptions,
  CreateTransport, InspectorClientEnvironment, AppRendererClient,
  SamplingCreateMessage class, ElicitationCreateMessage class,
  jsonUtils helpers, OAuth events). Per user direction, will re-add
  these to v2's diverged files (types.ts, samplingCreateMessage.ts,
  etc.) so the ported code stays verbatim.
- 15 TS7006: implicit-any params in v1.5 code (v1.5 tsconfig was
  looser than v2's noImplicitAny). Need explicit annotations.
- 8 other TS errors: ../package.json import, Transport|null narrowing,
  hono Context generic mismatch, one unused parameter.

Tests not yet ported (19 files, ~11,170 LOC).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* wip(core): integrate ported v1.5 InspectorClient + port tests (#1302)

Source integration (typecheck + build now pass):
- Re-add v1.5 types/classes dropped during v2 evolution:
  - types.ts: CreateTransport*, AppRendererClient, InspectorClient{Environment,Options}
  - samplingCreateMessage.ts / elicitationCreateMessage.ts: classes + keep v2's
    InspectorPending{Sampling,Elicitation} interface
  - inspectorClientEventTarget.ts: oauth* event keys
  - json/jsonUtils.ts: convertParameterValue / convertToolParameters /
    convertPromptArguments + ParameterSchema
- inspectorClient.ts: replace `../package.json` import (v2 has no
  core/package.json) with a hardcoded identity constant
- remote/node/server.ts: cast hono Context for streamSSE (hono's
  generic typing tightened since v1.5)
- oauth-callback-server.ts: drop unused hostname field
- tsconfig: enable @types/node, add paths for new bare-module deps
  (pino, zustand, hono, atomically) in app + test configs
- vite.config.ts: mirror those module aliases for the unit project
  (which runs from repoRoot)

Tests ported (19 files, ~11K LOC) under clients/web/src/test/core/:
- All core/__tests__/auth/* (7 files)
- inspectorClient.test.ts + 4 OAuth variants
- mcp/oauthManager.test.ts, jsonUtils.test.ts
- transport, remote-transport, remote-server-config, storage-adapters
- helpers/oauth-client-fixtures.ts
Bulk-rewrote `from "../mcp/…"` → `from "@inspector/core/mcp/…"` etc.

Current state:
- typecheck: 0 errors
- build: passes (vite v8, 788 modules)
- unit tests: 1014 / 1034 pass (937 pre-existing + 77 new core tests)
- 20 failures in 13 files; failure modes:
  - 13 file-load failures needing the v1.5 `test-servers/` package
    (@modelcontextprotocol/inspector-test-server) which isn't in v2 yet
    or real fs/network not available in happy-dom
  - 7 assertion failures in discovery.test.ts + state-machine.test.ts
    (SDK 1.29 vs 1.25 API drift — mocks don't match new shape)

Coverage gate not yet checked against new files.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* wip(core): port test-servers, more types, partial test integration (#1302)

- Port v1.5 test-servers/ package (12 files, ~5K LOC) under
  repo-root/test-servers/, wire @modelcontextprotocol/inspector-test-server
  alias in both vite.config.ts (regex form) and tsconfig.test.json.
- Add deps: express ^5, yaml ^2, @types/express ^5.
- Re-export InspectorClientOptions/Environment/Transport* from inspectorClient.ts
  so v1.5 tests that import them from that module path keep resolving.
- Switch InspectorClientEventMap to use SamplingCreateMessage /
  ElicitationCreateMessage classes (matches v1.5 event payload contracts)
  while keeping the InspectorPending{Sampling,Elicitation} interfaces in
  the *.ts modules for v2 consumers that still use them.
- Fix verbatim-module-syntax issue in test-servers and drop unused stdio
  config field.
- Adjust inspectorClient.test.ts task types to TaskWithOptionalCreatedAt
  (SDK 1.29 tightened Task shape vs v1.5's 1.25).
- Drop spurious maxMessages/maxFetchRequests/maxStderrLogEvents from
  remote-transport.test.ts (never on InspectorClientOptions).

State:
- typecheck: 0 errors
- build: passes
- unit tests: 1099 / 1270 pass
- 171 failures in 10 test files, almost all integration tests that need
  real HTTP/fs/network (happy-dom can't host them). Next: add a node-env
  vitest project to run these properly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(core): port v1.5 InspectorClient + transports + auth subsystem (#1302)

Bulk-port of the v1.5 core runtime (~7,800 LOC source + ~16K LOC tests +
~5K LOC test-servers/) into v2. Files copied verbatim from origin/v1.5/main
via `git show >`; only minimal adapters added on the v2 side.

Subsystems landed
-----------------
- core/logging/, core/storage/, core/auth/ (browser + node + remote)
- core/mcp/ runtime: inspectorClient.ts (2169 LOC), oauthManager,
  messageTrackingTransport, fetchTracking, config, index
- core/mcp/node/ (stdio transport)
- core/mcp/remote/ + remote/node/ (HTTP/SSE transport + Hono server)
- test-servers/ package (composable MCP test servers, fixtures, harness)

v2 adapter layer
----------------
- types.ts: append CreateTransport*, AppRendererClient,
  InspectorClient{Environment,Options} (v2 had pruned these — v1.5 needs them)
- samplingCreateMessage / elicitationCreateMessage: keep v1.5 classes AND
  v2's Inspector Pending* interfaces in the same files
- inspectorClientEventTarget: add oauth* event keys; switch pending
  sampling/elicitation payloads to the classes (matches v1.5 contracts)
- json/jsonUtils: append convertParameterValue/convertToolParameters/
  convertPromptArguments + ParameterSchema
- inspectorClient.ts: re-export Options/Environment/Transport* so tests
  that import these from `inspectorClient.js` keep resolving; replace
  `../package.json` import with a hardcoded identity (v2 has no core/package.json)
- remote/node/server.ts: cast hono Context for streamSSE (hono generic
  tightened since v1.5)
- oauth-callback-server: drop unused hostname field
- tsconfig.app.json / tsconfig.test.json: add @types/node + paths for
  pino/zustand/hono/@hono/node-server/atomically/express/yaml, disable
  erasableSyntaxOnly (parameter-property syntax from v1.5)
- vite.config.ts: regex-form module aliases (so the package's exports
  field handles subpaths like `hono/streaming`, `zustand/middleware`),
  alias for @modelcontextprotocol/inspector-test-server → test-servers/src

Tests
-----
- 19 v1.5 test files copied under clients/web/src/test/core/,
  imports rewired to @inspector/core/* and @modelcontextprotocol/inspector-test-server
- 1004 unit tests pass; 298 storybook tests pass; coverage gate passes

Known follow-ups (out-of-scope here, tracked in TODOs)
------------------------------------------------------
- 13 integration test files are excluded from the unit project (spawn real
  HTTP/stdio servers; run real OAuth flows; mock SDK auth → happy-dom CORS).
  Needs a node-env vitest project. Files listed under `test.projects[0].test.exclude`.
- Source files exercised only by those integration tests are excluded from
  the coverage gate pending the node-env project. Listed under
  `test.coverage.exclude` with comment.
- Manual smoke tests against real stdio / HTTP / OAuth server per the AC
  on #1302 still need verification locally.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* docs/fix: address #1306 review (AGENTS tree, #1307 links, @types/node, .substr)

- AGENTS.md: expand the project-structure tree to include all v1.5-ported
  subsystems (core/auth/{browser,node,remote}, core/storage, core/logging,
  core/mcp/{node,remote/{,node}}, core/mcp/state) plus the new top-level
  test-servers/ directory (with a note about its @modelcontextprotocol/
  inspector-test-server alias).
- vite.config.ts: reference #1307 from both the test exclude block and the
  coverage exclude block so the next person editing either sees the
  marching order for shrinking the lists.
- package.json: restore @types/node to ^24 (an earlier `npm install
  --save-dev @types/node@^22` accidentally pinned it lower than the repo
  was using; nothing here required ^22).
- core/mcp/fetchTracking.ts: replace deprecated .substr(2, 9) with
  .slice(2, 11) to match the convention in core/mcp/inspectorClient.ts.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Cliff Hall 2026-05-15 15:36:17 -04:00 • committed by GitHub
commit 0ead1deea6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -0,0 +1,317 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import {
discoverScopes,
getAuthorizationServerUrl,
} from "@inspector/core/auth/discovery.js";
import type { OAuthProtectedResourceMetadata } from "@modelcontextprotocol/sdk/shared/auth.js";
// Mock SDK functions
vi.mock("@modelcontextprotocol/sdk/client/auth.js", () => ({
discoverAuthorizationServerMetadata: vi.fn(),
}));
describe("OAuth Scope Discovery", () => {
beforeEach(() => {
vi.clearAllMocks();
});
it("should return scopes from resource metadata when available", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "http://localhost:3000",
authorization_servers: ["http://localhost:3000"],
scopes_supported: ["read", "write", "admin"],
};
const scopes = await discoverScopes(
"http://localhost:3000",
resourceMetadata,
);
expect(scopes).toBe("read write admin");
});
it("should fall back to OAuth metadata scopes when resource metadata has no scopes", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "http://localhost:3000",
authorization_servers: ["http://localhost:3000"],
scopes_supported: [],
};
const scopes = await discoverScopes(
"http://localhost:3000",
resourceMetadata,
);
expect(scopes).toBe("read write");
});
it("should fall back to OAuth metadata scopes when resource metadata is not provided", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const scopes = await discoverScopes("http://localhost:3000");
expect(scopes).toBe("read write");
});
it("should return undefined when no scopes are available", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: [],
});
const scopes = await discoverScopes("http://localhost:3000");
expect(scopes).toBeUndefined();
});
it("should return undefined when discovery fails", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockRejectedValue(
new Error("Discovery failed"),
);
const scopes = await discoverScopes("http://localhost:3000");
expect(scopes).toBeUndefined();
});
it("should return undefined when metadata is undefined", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue(undefined);
const scopes = await discoverScopes("http://localhost:3000");
expect(scopes).toBeUndefined();
});
it("should use OAuth metadata scopes when resource has scopes_supported undefined", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "http://localhost:3000",
authorization_servers: ["http://localhost:3000"],
scopes_supported: undefined as unknown as string[],
};
const scopes = await discoverScopes(
"http://localhost:3000",
resourceMetadata,
);
expect(scopes).toBe("read write");
});
it("should return single scope when only one scope is supported", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["openid"],
});
const scopes = await discoverScopes("http://localhost:3000");
expect(scopes).toBe("openid");
});
it("should pass fetchFn to discoverAuthorizationServerMetadata when provided", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
const mockFetchFn = vi.fn();
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "http://localhost:3000",
authorization_endpoint: "http://localhost:3000/authorize",
token_endpoint: "http://localhost:3000/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
await discoverScopes("http://localhost:3000", undefined, mockFetchFn);
expect(discoverAuthorizationServerMetadata).toHaveBeenCalledWith(
new URL("/", "http://localhost:3000"),
{ fetchFn: mockFetchFn },
);
});
it("should use authorization_servers URL from resource metadata for discovery (different domain)", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "https://auth-server.com",
authorization_endpoint: "https://auth-server.com/authorize",
token_endpoint: "https://auth-server.com/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "https://mcp-server.com",
authorization_servers: ["https://auth-server.com/"],
scopes_supported: ["read", "write"],
};
const scopes = await discoverScopes(
"https://mcp-server.com",
resourceMetadata,
);
expect(scopes).toBe("read write");
expect(discoverAuthorizationServerMetadata).toHaveBeenCalledWith(
new URL("https://auth-server.com/"),
{ fetchFn: undefined },
);
});
it("should preserve full path in authorization_servers URL", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "https://auth-server.com/realms/my-realm",
authorization_endpoint:
"https://auth-server.com/realms/my-realm/authorize",
token_endpoint: "https://auth-server.com/realms/my-realm/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "https://mcp-server.com",
authorization_servers: ["https://auth-server.com/realms/my-realm/"],
scopes_supported: ["read", "write"],
};
const scopes = await discoverScopes(
"https://mcp-server.com",
resourceMetadata,
);
expect(scopes).toBe("read write");
expect(discoverAuthorizationServerMetadata).toHaveBeenCalledWith(
new URL("https://auth-server.com/realms/my-realm/"),
{ fetchFn: undefined },
);
});
it("should fall back to serverUrl when authorization_servers is empty", async () => {
const { discoverAuthorizationServerMetadata } =
await import("@modelcontextprotocol/sdk/client/auth.js");
vi.mocked(discoverAuthorizationServerMetadata).mockResolvedValue({
issuer: "https://mcp-server.com",
authorization_endpoint: "https://mcp-server.com/authorize",
token_endpoint: "https://mcp-server.com/token",
response_types_supported: ["code"],
scopes_supported: ["read", "write"],
});
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: "https://mcp-server.com",
authorization_servers: [],
scopes_supported: ["read", "write"],
};
const scopes = await discoverScopes(
"https://mcp-server.com",
resourceMetadata,
);
expect(scopes).toBe("read write");
expect(discoverAuthorizationServerMetadata).toHaveBeenCalledWith(
new URL("/", "https://mcp-server.com"),
{ fetchFn: undefined },
);
});
});
describe("getAuthorizationServerUrl", () => {
const serverUrl = "https://mcp.example.com";
it("returns server URL when resourceMetadata is null", () => {
expect(getAuthorizationServerUrl(serverUrl, null)).toEqual(
new URL("/", serverUrl),
);
});
it("returns server URL when resourceMetadata is undefined", () => {
expect(getAuthorizationServerUrl(serverUrl)).toEqual(
new URL("/", serverUrl),
);
});
it("returns server URL when authorization_servers is empty array", () => {
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: serverUrl,
authorization_servers: [],
};
expect(getAuthorizationServerUrl(serverUrl, resourceMetadata)).toEqual(
new URL("/", serverUrl),
);
});
it("falls back to server URL when authorization_servers[0] is empty string", () => {
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: serverUrl,
authorization_servers: [""],
};
expect(getAuthorizationServerUrl(serverUrl, resourceMetadata)).toEqual(
new URL("/", serverUrl),
);
});
it("returns authorization_servers[0] when present and truthy", () => {
const authUrl = "https://auth.example.com/";
const resourceMetadata: OAuthProtectedResourceMetadata = {
resource: serverUrl,
authorization_servers: [authUrl],
};
expect(getAuthorizationServerUrl(serverUrl, resourceMetadata)).toEqual(
new URL(authUrl),
);
});
});