Some checks failed
Run install, format, lint, build, and test on every push / build (push) Has been cancelled
Run install, format, lint, build, and test on every push / publish (push) Has been cancelled
Run install, format, lint, build, and test on every push / publish-github-container-registry (push) Has been cancelled
Close #1527 acceptance gaps with automated tests (SEP-2468 iss, SEP-2207 offline_access, SEP-2351 discovery shapes, SEP-2352 AS-migration, EraNegotiationFailed→401 unwrap); lean EMA leg 2 and scope helpers on the v2 SDK; drop deprecated TS baseUrl. Reviewed LGTM.
735 lines
22 KiB
TypeScript
735 lines
22 KiB
TypeScript
/**
|
|
* Mid-session OAuth recovery over the web remote transport.
|
|
* Verifies inline auth_challenge on /api/mcp/send, silent refresh, auth-state push, and retry.
|
|
*/
|
|
|
|
import {
|
|
describe,
|
|
it,
|
|
expect,
|
|
beforeEach,
|
|
afterEach,
|
|
afterAll,
|
|
vi,
|
|
} from "vitest";
|
|
import { mkdtempSync, rmSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { serve } from "@hono/node-server";
|
|
import type { ServerType } from "@hono/node-server";
|
|
import { InspectorClient } from "@inspector/core/mcp/inspectorClient.js";
|
|
import { createRemoteTransport } from "@inspector/core/mcp/remote/createRemoteTransport.js";
|
|
import { createRemoteFetch } from "@inspector/core/mcp/remote/createRemoteFetch.js";
|
|
import { NodeOAuthStorage } from "@inspector/core/auth/node/storage-node.js";
|
|
import { createRemoteApp } from "@inspector/core/mcp/remote/node/server.js";
|
|
import {
|
|
TestServerHttp,
|
|
waitForOAuthWellKnown,
|
|
getDefaultServerConfig,
|
|
createOAuthTestServerConfig,
|
|
clearOAuthTestData,
|
|
invalidateAccessToken,
|
|
} from "@modelcontextprotocol/inspector-test-server";
|
|
import { AuthRecoveryRequiredError } from "@inspector/core/auth/challenge.js";
|
|
import {
|
|
createOAuthClientConfig,
|
|
completeOAuthAuthorization,
|
|
} from "../helpers/oauth-client-fixtures.js";
|
|
import { ConsoleNavigation } from "@inspector/core/auth/providers.js";
|
|
import type { InspectorClientOptions } from "@inspector/core/mcp/inspectorClient.js";
|
|
import type { MCPServerConfig } from "@inspector/core/mcp/types.js";
|
|
|
|
const oauthTestStatePath = join(
|
|
tmpdir(),
|
|
`mcp-oauth-${process.pid}-remote-mid-session-e2e.json`,
|
|
);
|
|
|
|
function createTestOAuthConfig(
|
|
options: Parameters<typeof createOAuthClientConfig>[0],
|
|
) {
|
|
return {
|
|
...createOAuthClientConfig(options),
|
|
storage: new NodeOAuthStorage(oauthTestStatePath),
|
|
};
|
|
}
|
|
|
|
async function startRemoteServer(port: number): Promise<{
|
|
baseUrl: string;
|
|
server: ServerType;
|
|
authToken: string;
|
|
}> {
|
|
const { app, authToken } = createRemoteApp({
|
|
initialConfig: { defaultEnvironment: {} },
|
|
});
|
|
return new Promise((resolve, reject) => {
|
|
const server = serve(
|
|
{ fetch: app.fetch, port, hostname: "127.0.0.1" },
|
|
(info) => {
|
|
const actualPort =
|
|
info && typeof info === "object" && "port" in info
|
|
? (info as { port: number }).port
|
|
: port;
|
|
resolve({
|
|
baseUrl: `http://127.0.0.1:${actualPort}`,
|
|
server,
|
|
authToken,
|
|
});
|
|
},
|
|
);
|
|
server.on("error", reject);
|
|
});
|
|
}
|
|
|
|
describe("InspectorClient remote mid-session OAuth", () => {
|
|
let remoteServer: ServerType | null = null;
|
|
let mcpServer: TestServerHttp | null = null;
|
|
let remoteBaseUrl: string | undefined;
|
|
let remoteAuthToken: string | undefined;
|
|
const testRedirectUrl = "http://localhost:3000/oauth/callback";
|
|
|
|
beforeEach(() => {
|
|
clearOAuthTestData();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
if (mcpServer) {
|
|
await mcpServer.stop();
|
|
mcpServer = null;
|
|
}
|
|
if (remoteServer) {
|
|
await new Promise<void>((resolve) => {
|
|
remoteServer!.close(() => resolve());
|
|
});
|
|
remoteServer = null;
|
|
}
|
|
remoteBaseUrl = undefined;
|
|
remoteAuthToken = undefined;
|
|
}, 30_000);
|
|
|
|
afterAll(() => {
|
|
try {
|
|
rmSync(oauthTestStatePath, { force: true });
|
|
} catch {
|
|
// ignore
|
|
}
|
|
});
|
|
|
|
async function setupRemoteServer(): Promise<void> {
|
|
const tmp = mkdtempSync(join(tmpdir(), "inspector-remote-mid-session-"));
|
|
const { baseUrl, server, authToken } = await startRemoteServer(0);
|
|
remoteBaseUrl = baseUrl;
|
|
remoteAuthToken = authToken;
|
|
remoteServer = server;
|
|
rmSync(tmp, { recursive: true, force: true });
|
|
}
|
|
|
|
it("recovers from invalidated access token after connect via silent refresh and auth-state push", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-mid-session";
|
|
const staticClientSecret = "test-secret-mid-session";
|
|
|
|
const serverConfig = {
|
|
...getDefaultServerConfig(),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
supportRefreshTokens: true,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
});
|
|
|
|
const clientConfig: InspectorClientOptions = {
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
};
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
{
|
|
const { code, iss } = await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(code, iss);
|
|
}
|
|
await client.connect();
|
|
|
|
const tokens = await client.getOAuthTokens();
|
|
expect(tokens?.refresh_token).toBeDefined();
|
|
invalidateAccessToken(tokens!.access_token);
|
|
|
|
const toolsResult = await client.listTools();
|
|
expect(toolsResult.tools.length).toBeGreaterThan(0);
|
|
expect(client.getStatus()).toBe("connected");
|
|
|
|
await client.disconnect();
|
|
}, 15_000);
|
|
|
|
it("recovers on reconnect when stored access token was invalidated before connect", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-reconnect-mid-session";
|
|
const staticClientSecret = "test-secret-reconnect-mid-session";
|
|
|
|
const serverConfig = {
|
|
...getDefaultServerConfig(),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
supportRefreshTokens: true,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
});
|
|
|
|
const clientConfig: InspectorClientOptions = {
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
};
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
{
|
|
const { code, iss } = await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(code, iss);
|
|
}
|
|
await client.connect();
|
|
|
|
const tokens = await client.getOAuthTokens();
|
|
invalidateAccessToken(tokens!.access_token);
|
|
|
|
await client.connect();
|
|
|
|
expect(client.getStatus()).toBe("connected");
|
|
await client.disconnect();
|
|
});
|
|
|
|
it("step-up re-auth after insufficient_scope lets scoped tool succeed", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-step-up";
|
|
const staticClientSecret = "test-secret-step-up";
|
|
|
|
const baseConfig = getDefaultServerConfig();
|
|
const serverConfig = {
|
|
...baseConfig,
|
|
tools: baseConfig.tools!.map((tool) =>
|
|
tool.name === "get_temp"
|
|
? { ...tool, requiredScopes: ["weather:read"] }
|
|
: tool,
|
|
),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
scopesSupported: ["mcp", "tools:read", "weather:read"],
|
|
supportRefreshTokens: true,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
scope: "mcp tools:read",
|
|
});
|
|
|
|
const clientConfig: InspectorClientOptions = {
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
};
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
{
|
|
const { code, iss } = await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(code, iss);
|
|
}
|
|
await client.connect();
|
|
|
|
const toolsResult = await client.listTools();
|
|
const echoTool = toolsResult.tools.find((t) => t.name === "echo");
|
|
const getTempTool = toolsResult.tools.find((t) => t.name === "get_temp");
|
|
expect(echoTool).toBeDefined();
|
|
expect(getTempTool).toBeDefined();
|
|
|
|
await client.callTool(echoTool!, { message: "hello" });
|
|
|
|
const remoteSessionId = client.getRemoteBackendSessionId();
|
|
expect(remoteSessionId).toBeDefined();
|
|
|
|
let recovery: AuthRecoveryRequiredError | undefined;
|
|
try {
|
|
await client.callTool(getTempTool!, { city: "NYC", units: "C" });
|
|
} catch (error) {
|
|
if (error instanceof AuthRecoveryRequiredError) {
|
|
recovery = error;
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
expect(recovery?.authChallenge.reason).toBe("insufficient_scope");
|
|
|
|
const mcpServerUrl = `${serverUrl}/mcp`;
|
|
const scopeBeforeStepUp = await oauthConfig.storage.getScope(mcpServerUrl);
|
|
expect(scopeBeforeStepUp).toContain("mcp");
|
|
expect(scopeBeforeStepUp).not.toContain("weather:read");
|
|
|
|
expect(recovery!.authorizationUrl.searchParams.get("scope")).toContain(
|
|
"weather:read",
|
|
);
|
|
|
|
const { code: stepUpCode, iss: stepUpCodeIss } =
|
|
await completeOAuthAuthorization(recovery!.authorizationUrl);
|
|
|
|
// Mirror `/oauth/callback`: new InspectorClient instance, same persisted OAuth
|
|
// storage, reattach to the live remote backend session.
|
|
const callbackClient = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
await callbackClient.resumeAfterOAuth(stepUpCode, {
|
|
iss: stepUpCodeIss,
|
|
remoteSessionId,
|
|
});
|
|
|
|
expect(callbackClient.getStatus()).toBe("connected");
|
|
|
|
const scopeAfterStepUp = await oauthConfig.storage.getScope(mcpServerUrl);
|
|
expect(scopeAfterStepUp).toContain("weather:read");
|
|
expect(scopeAfterStepUp).toContain("mcp");
|
|
|
|
const callbackTools = await callbackClient.listTools();
|
|
const callbackGetTemp = callbackTools.tools.find(
|
|
(t) => t.name === "get_temp",
|
|
);
|
|
expect(callbackGetTemp).toBeDefined();
|
|
|
|
const result = await callbackClient.callTool(callbackGetTemp!, {
|
|
city: "NYC",
|
|
units: "C",
|
|
});
|
|
expect(result.success).toBe(true);
|
|
const content = result.result?.content;
|
|
expect(Array.isArray(content)).toBe(true);
|
|
expect(content?.[0]).toHaveProperty("type", "text");
|
|
expect("text" in content![0] && content![0].text).toContain("25");
|
|
|
|
await callbackClient.disconnect();
|
|
await client.disconnect();
|
|
}, 30_000);
|
|
|
|
it("resumeAfterOAuth falls back to connect when remote session is dead", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-resume-fallback";
|
|
const staticClientSecret = "test-secret-resume-fallback";
|
|
|
|
const serverConfig = {
|
|
...getDefaultServerConfig(),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
supportRefreshTokens: false,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
});
|
|
|
|
const clientConfig: InspectorClientOptions = {
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
};
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
const { code: initialCode, iss: initialCodeIss } =
|
|
await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(initialCode, initialCodeIss);
|
|
await client.connect();
|
|
|
|
const mcpServerUrl = `${serverUrl}/mcp`;
|
|
await oauthConfig.storage.clearTokens(mcpServerUrl);
|
|
const reauthUrl = await client.authenticate();
|
|
if (!reauthUrl) throw new Error("Expected reauth URL");
|
|
const { code: code, iss: codeIss } =
|
|
await completeOAuthAuthorization(reauthUrl);
|
|
|
|
const callbackClient = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
const connectSpy = vi.spyOn(callbackClient, "connect");
|
|
await callbackClient.resumeAfterOAuth(code, {
|
|
iss: codeIss,
|
|
remoteSessionId: "dead-remote-session-id",
|
|
});
|
|
expect(connectSpy).toHaveBeenCalled();
|
|
connectSpy.mockRestore();
|
|
|
|
expect(callbackClient.getStatus()).toBe("connected");
|
|
const toolsResult = await callbackClient.listTools();
|
|
expect(toolsResult.tools.length).toBeGreaterThan(0);
|
|
|
|
await callbackClient.disconnect();
|
|
await client.disconnect();
|
|
}, 30_000);
|
|
|
|
it("dispatches authChallengeInteractive for ambient interactive recovery", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-ambient-interactive";
|
|
const staticClientSecret = "test-secret-ambient-interactive";
|
|
|
|
const serverConfig = {
|
|
...getDefaultServerConfig(),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
supportRefreshTokens: false,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
});
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
{
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
},
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
{
|
|
const { code, iss } = await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(code, iss);
|
|
}
|
|
await client.connect();
|
|
|
|
const tokens = await client.getOAuthTokens();
|
|
invalidateAccessToken(tokens!.access_token);
|
|
|
|
const interactive = vi.fn();
|
|
client.addEventListener("authChallengeInteractive", interactive);
|
|
|
|
await client.handleAmbientAuthChallenge({ reason: "token_expired" });
|
|
|
|
expect(interactive).toHaveBeenCalledOnce();
|
|
expect(interactive.mock.calls[0]![0].detail.challenge.reason).toBe(
|
|
"token_expired",
|
|
);
|
|
expect(
|
|
interactive.mock.calls[0]![0].detail.authorizationUrl,
|
|
).toBeInstanceOf(URL);
|
|
|
|
await client.disconnect();
|
|
}, 15_000);
|
|
|
|
it("recovers from ambient auth notification after idle token invalidation", async () => {
|
|
await setupRemoteServer();
|
|
|
|
const staticClientId = "test-remote-ambient-auth";
|
|
const staticClientSecret = "test-secret-ambient-auth";
|
|
|
|
const serverConfig = {
|
|
...getDefaultServerConfig(),
|
|
serverType: "streamable-http" as const,
|
|
...createOAuthTestServerConfig({
|
|
requireAuth: true,
|
|
supportRefreshTokens: true,
|
|
staticClients: [
|
|
{
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUris: [testRedirectUrl],
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
mcpServer = new TestServerHttp(serverConfig);
|
|
const port = await mcpServer.start();
|
|
const serverUrl = `http://localhost:${port}`;
|
|
await waitForOAuthWellKnown(serverUrl);
|
|
|
|
const oauthConfig = createTestOAuthConfig({
|
|
mode: "static",
|
|
clientId: staticClientId,
|
|
clientSecret: staticClientSecret,
|
|
redirectUrl: testRedirectUrl,
|
|
});
|
|
|
|
const clientConfig: InspectorClientOptions = {
|
|
environment: {
|
|
transport: createRemoteTransport({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
fetch: createRemoteFetch({
|
|
baseUrl: remoteBaseUrl!,
|
|
authToken: remoteAuthToken!,
|
|
}),
|
|
oauth: {
|
|
storage: oauthConfig.storage,
|
|
navigation: new ConsoleNavigation(),
|
|
redirectUrlProvider: oauthConfig.redirectUrlProvider,
|
|
},
|
|
},
|
|
oauth: {
|
|
clientId: oauthConfig.clientId,
|
|
clientSecret: oauthConfig.clientSecret,
|
|
clientMetadataUrl: oauthConfig.clientMetadataUrl,
|
|
scope: oauthConfig.scope,
|
|
},
|
|
};
|
|
|
|
const client = new InspectorClient(
|
|
{
|
|
type: "streamable-http",
|
|
url: `${serverUrl}/mcp`,
|
|
} as MCPServerConfig,
|
|
clientConfig,
|
|
);
|
|
|
|
const authUrl = await client.authenticate();
|
|
if (!authUrl) throw new Error("Expected authorization URL");
|
|
{
|
|
const { code, iss } = await completeOAuthAuthorization(authUrl);
|
|
await client.completeOAuthFlow(code, iss);
|
|
}
|
|
await client.connect();
|
|
|
|
const tokens = await client.getOAuthTokens();
|
|
invalidateAccessToken(tokens!.access_token);
|
|
|
|
const recovered = vi.fn();
|
|
client.addEventListener("authChallengeRecovered", recovered);
|
|
|
|
await client.handleAmbientAuthChallenge({ reason: "token_expired" });
|
|
|
|
expect(recovered).toHaveBeenCalled();
|
|
|
|
const toolsResult = await client.listTools();
|
|
expect(toolsResult.tools.length).toBeGreaterThan(0);
|
|
expect(client.getStatus()).toBe("connected");
|
|
|
|
await client.disconnect();
|
|
}, 15_000);
|
|
});
|