fix(auth): explicit re-authorize when the OAuth callback state was lost (#1808) (#1810)

* fix(auth): offer explicit re-authorize when callback state is lost (#1808)

A `/oauth/callback` that arrives with no recorded SEP-2352 discovery state
made the SDK throw `AuthorizationServerMismatchError` and the Inspector
dead-ended, surfacing the raw SDK text with no path forward.

The SDK folds two very different failures into that one error class, so
`core/auth/issuerBinding.ts` classifies them structurally: a recoverable
"lost authorization state" (the SDK puts prose, not an issuer URL, in the
`recordedIssuer` slot) versus a genuine cross-AS `issuer_mismatch`. Only
the first gets a recovery affordance.

Web: the callback failure now raises a dedicated banner ("Authorization
state was lost" / "Authorize again") whose action clears the stale OAuth
state for that server and starts a fresh authorization. A genuine
mismatch stays a red, non-dismissible security notification with both
issuers named and no one-click retry.

Node runners (CLI/TUI): the same classification rewrites the callback
rejection into the shared actionable copy instead of the SDK text.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016S7h83UKNQ7kvSiFDNksCt

* fix(auth): detect the SDK mismatch error via isInstance (#1808)

The callback-leg classifier gated on `err.mcpBrand`, but the SDK declares
that brand in a `static {}` block, so it lives on the constructor and is
never reachable from an instance. The predicate always returned false, so
`findIssuerBindingFailure()` never matched and the #1808 recovery banner
was inert in production — the callback dead-ended exactly as before.

Use the SDK's own `AuthorizationServerMismatchError.isInstance()`, which is
cross-copy safe by construction (it consults a `Symbol.for()`-keyed brand
set), with a `name` fallback for a serialization boundary. Correct the
module doc, which cited cross-bundle safety as the reason to avoid
`instanceof` — the very thing the SDK's branded `hasInstance` provides.

Every fixture now constructs a real `AuthorizationServerMismatchError`
instead of a hand-rolled object with an own `mcpBrand`, which is why a
green `npm run ci` hid this. Adds a test pinning the brand's placement so
the feature cannot silently go inert again.

Review follow-ups: drop the unused `isLostAuthorizationStateError`, remove
the duplicated banner title default, resolve the banner title/action label
where the banner is raised, keep the clear-failure notification open, and
bound remote-supplied issuers in user-facing copy.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016S7h83UKNQ7kvSiFDNksCt

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Cliff Hall 2026-07-27 18:08:31 -04:00 • committed by GitHub
commit 7784553674
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -1,4 +1,5 @@
import type { AuthChallenge } from "./challenge.js";
import type { IssuerBindingFailure } from "./issuerBinding.js";
export type OAuthInteractiveAuthKind = "step_up" | "reauth";
@ -224,6 +225,101 @@ export function isReAuthBannerReason(
);
}
/** Banner/alert heading when the recorded authorization state was lost. */
export function lostAuthorizationStateTitle(): string {
return "Authorization state was lost";
}
/**
* Plain-language explanation for a callback that arrived with no recorded
* discovery state (SEP-2352). Deliberately does not surface the SDK's
* `AuthorizationServerMismatchError` text — that wording reads like a security
* failure, and this case is ordinary bookkeeping loss.
*/
export function lostAuthorizationStateMessage(options?: {
serverName?: string;
}): string {
const target = options?.serverName
? `"${options.serverName}"`
: "this server";
return (
`The stored authorization state for ${target} was lost before the ` +
"authorization server sent you back, so the sign-in could not be " +
"completed. This usually means a new browser session, a different tab, or " +
"authorization state that was cleared while the flow was in progress. " +
"Authorize again to reconnect."
);
}
/** Action label for the lost-authorization-state recovery affordance. */
export function lostAuthorizationStateActionLabel(): string {
return "Authorize again";
}
/** Heading for a genuine cross-authorization-server mismatch (a security signal). */
export function issuerMismatchTitle(): string {
return "Authorization server mismatch";
}
/**
* Longest issuer we will echo back into user-facing copy.
*
* `currentIssuer` is remote-supplied (it comes from the configured server's AS
* metadata), so an overlong value could be used to abuse the notification
* layout. Rendering is escaped, so this is a presentation bound, not an
* injection defence.
*/
const MAX_DISPLAYED_ISSUER_LENGTH = 120;
/** Bound an issuer for display, marking any truncation. */
export function truncateIssuerForDisplay(issuer: string): string {
return issuer.length > MAX_DISPLAYED_ISSUER_LENGTH
? `${issuer.slice(0, MAX_DISPLAYED_ISSUER_LENGTH)}…`
: issuer;
}
/**
* Copy for a genuine SEP-2352 issuer mismatch. This is *not* offered a
* one-click recovery: the authorization code and PKCE verifier are bound to the
* server that minted them, and a different server answering the callback is a
* credential-exfiltration signal the user must investigate.
*/
export function issuerMismatchMessage(options: {
recordedIssuer: string;
currentIssuer: string;
serverName?: string;
}): string {
const target = options.serverName ? `"${options.serverName}"` : "this server";
return (
`Authorization for ${target} was stopped: the flow started at ` +
`${truncateIssuerForDisplay(options.recordedIssuer)} but the callback ` +
`resolved ${truncateIssuerForDisplay(options.currentIssuer)}. ` +
"The authorization code was not exchanged. " +
"Verify the server's authorization configuration before trying again."
);
}
/** Title + message for a callback-leg issuer-binding failure. */
export function issuerBindingFailureCopy(
failure: IssuerBindingFailure,
options?: { serverName?: string },
): { title: string; message: string } {
if (failure.kind === "lost_authorization_state") {
return {
title: lostAuthorizationStateTitle(),
message: lostAuthorizationStateMessage(options),
};
}
return {
title: issuerMismatchTitle(),
message: issuerMismatchMessage({
recordedIssuer: failure.recordedIssuer,
currentIssuer: failure.currentIssuer,
serverName: options?.serverName,
}),
};
}
export function reAuthBannerMessage(options: {
serverName?: string;
detail?: string;