fix(oauth): drop an inherited offline_access when the grant is declined

Copilot review round 4 on #2114 — a real gap, not a wording one.

Declining the grant stops the SDK *adding* `offline_access`, but the
Inspector's own storage puts it back. A successful default-on
authorization persists the scope the AS granted
(`resolvePersistedScopeAfterGrant`), `offline_access` included;
`prepareForAuth` reloads it and `authenticate` hands it to the SDK as
`scope`, which sees the token in scope and appends `prompt=consent`
again. So any server that had authorized once could uncheck the box and
still hit AADSTS90094 — the users most likely to reach for the setting
were the ones it did not help.

`scopeForDeclinedRefreshGrant` filters it out of the *request* only,
applied in the provider's `scope` getter — the one seam both
`clientMetadata.scope` and `authenticate`'s `scope:` argument read
through. An `offline_access` the user configured is honored; storage is
never rewritten, so re-checking the box restores the old behavior
instead of finding the value destroyed, and scope-satisfaction checks
still see the real grant. Verified by reverting the filter: the new e2e
regression fails.

Also from that round, both previously suppressed:

The checkbox looked effective under enterprise-managed authorization,
which never builds this provider at all — it authorizes against the
enterprise IdP with a fixed `openid offline_access`
(`ema/constants.ts:16`). It now annotates itself the way the endpoint
overrides do. The existing count assertion covered two such notices and
was named for the overrides alone; it is renamed and expects three, with
a dedicated case pinning the notice to this control so the count cannot
be met by three copies elsewhere.

And "obtains no new refresh token" was another overstatement — the AS
decides issuance, and a preconfigured client is reused with whatever its
registration already permits. Replaced with what the setting actually
controls.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hzwzS8UvBsr4yZm7o7sev
Signed-off-by: cliffhall <cliff@futurescale.com>
This commit is contained in:
cliffhall 2026-08-24 21:30:29 -04:00
commit 89dedd8dea
2 changed files with 323 additions and 4 deletions

View file

@ -506,6 +506,81 @@ describe("OAuthNavigation", () => {
makeProviderWithRefresh(false).clientMetadata.grant_types,
).toEqual(["authorization_code"]);
});
// The regression that makes the opt-out actually work for a server that
// already authorized once. A successful default-on grant persists the
// AS-granted scope — `offline_access` included — and the provider reloads
// it here. Handing that straight back to the SDK puts the token in scope
// again, and `startAuthorization` appends `prompt=consent` off the scope
// alone, so the box would be unchecked and AADSTS90094 would persist.
describe("scope inherited from an earlier default-on grant", () => {
function makeProviderWithScopes(
storedScope: string,
configuredScope: string | undefined,
requestRefreshToken: boolean,
): { provider: BaseOAuthClientProvider; storage: OAuthStorage } {
const storage = makeStorage();
vi.mocked(storage.getScope).mockResolvedValue(storedScope);
const provider = new BaseOAuthClientProvider(SERVER, {
storage,
redirectUrlProvider: new MutableRedirectUrlProvider(),
navigation: new CallbackNavigation(vi.fn()),
requestRefreshToken,
configuredScope,
});
return { provider, storage };
}
it("drops the inherited offline_access from the requested scope", async () => {
const { provider } = makeProviderWithScopes(
"mcp offline_access",
"mcp",
false,
);
await provider.prepareForAuth();
expect(provider.scope).toBe("mcp");
expect(provider.clientMetadata.scope).toBe("mcp");
});
it("honors an offline_access the user configured", async () => {
const { provider } = makeProviderWithScopes(
"mcp offline_access",
"mcp offline_access",
false,
);
await provider.prepareForAuth();
expect(provider.scope).toBe("mcp offline_access");
});
it("leaves the scope alone while the grant is declared", async () => {
const { provider } = makeProviderWithScopes(
"mcp offline_access",
"mcp",
true,
);
await provider.prepareForAuth();
expect(provider.scope).toBe("mcp offline_access");
});
// Filtered at the point of request, never in storage: re-checking the
// box must restore the previous behavior rather than find the value
// destroyed, and the persisted scope is also what scope-satisfaction
// checks read.
it("does not rewrite the persisted scope", async () => {
const { provider, storage } = makeProviderWithScopes(
"mcp offline_access",
"mcp",
false,
);
await provider.prepareForAuth();
void provider.scope;
expect(storage.saveScope).not.toHaveBeenCalled();
});
});
});
describe("SEP-2352 issuer threading", () => {

View file

@ -4,6 +4,7 @@ import {
isStrictScopeSuperset,
resolveEffectiveGrantedScope,
resolvePersistedScopeAfterGrant,
scopeForDeclinedRefreshGrant,
} from "@inspector/core/auth/scopes.js";
describe("scopes", () => {
@ -65,3 +66,54 @@ describe("scopes", () => {
});
});
});
describe("scopeForDeclinedRefreshGrant (#2068)", () => {
it("drops an inherited offline_access from the requested scope", () => {
expect(scopeForDeclinedRefreshGrant("mcp offline_access", "mcp")).toBe(
"mcp",
);
});
// The persisted scope is what a previous default-on grant left behind, and
// the configured scope may be unset entirely (DCR + resource-advertised
// scopes). An inherited token is still inherited.
it("drops it when no scope is configured at all", () => {
expect(scopeForDeclinedRefreshGrant("mcp offline_access", undefined)).toBe(
"mcp",
);
});
it("keeps an offline_access the user explicitly configured", () => {
expect(
scopeForDeclinedRefreshGrant("mcp offline_access", "mcp offline_access"),
).toBe("mcp offline_access");
});
it("leaves a scope without offline_access untouched", () => {
expect(scopeForDeclinedRefreshGrant("mcp tools:read", "mcp")).toBe(
"mcp tools:read",
);
});
// Requesting `scope=` empty is not the same as omitting it; collapse to
// undefined so the SDK falls back to its own resolution.
it("collapses to undefined when offline_access was the only scope", () => {
expect(scopeForDeclinedRefreshGrant("offline_access", "")).toBeUndefined();
});
it("passes an absent scope through", () => {
expect(scopeForDeclinedRefreshGrant(undefined, "mcp")).toBeUndefined();
});
it("matches whole tokens, not substrings", () => {
expect(
scopeForDeclinedRefreshGrant("mcp offline_access_extra", "mcp"),
).toBe("mcp offline_access_extra");
});
it("tolerates irregular whitespace", () => {
expect(
scopeForDeclinedRefreshGrant(" mcp offline_access ", "mcp"),
).toBe("mcp");
});
});