Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

fix(mcp): accept refresh_token grant on register

Andrej59314c15aded
diff --git a/apps/api/src/mcp/controllers/oauth-consent.ts b/apps/api/src/mcp/controllers/oauth-consent.ts
index 310746428..c5f75fd72 100644
--- a/apps/api/src/mcp/controllers/oauth-consent.ts
+++ b/apps/api/src/mcp/controllers/oauth-consent.ts
@@ -65,10 +65,10 @@ export async function registerMcpClient(input: ClientRegistrationInput) {
client_id_issued_at: client.issuedAt,
redirect_uris: client.redirectUris,
client_name: client.clientName,
- token_endpoint_auth_method: input.token_endpoint_auth_method ?? "none",
- grant_types: input.grant_types ?? ["authorization_code"],
- response_types: input.response_types ?? ["code"],
- } as const;
+ token_endpoint_auth_method: "none" as const,
+ grant_types: ["authorization_code" as const],
+ response_types: ["code" as const],
+ };
}
export async function beginMcpAuthorization(
diff --git a/apps/api/src/mcp/index.ts b/apps/api/src/mcp/index.ts
index d8728624a..359384051 100644
--- a/apps/api/src/mcp/index.ts
+++ b/apps/api/src/mcp/index.ts
@@ -6,6 +6,7 @@ import {
isLegacyRequest,
} from "@modelcontextprotocol/server";
import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
import { auth } from "../auth";
import { apiRouter, createRoute, jsonResponse } from "../openapi";
import {
@@ -75,6 +76,33 @@ const mcp = apiRouter();
const jsonError = (description: string) =>
jsonResponse(description, oauthErrorSchema);
+// OAuth clients parse validation failures, so these routes answer with the
+// RFC 6749 / RFC 7591 JSON error shape instead of the router's text default.
+type ValidationResult = { success: boolean; error?: { issues: unknown[] } };
+
+const oauthValidationHook =
+ (error: "invalid_request" | "invalid_client_metadata") =>
+ (result: ValidationResult): undefined => {
+ if (result.success) return;
+ const issue = result.error?.issues[0] as
+ | { path?: PropertyKey[]; message?: string }
+ | undefined;
+ const field = issue?.path?.map(String).join(".");
+ throw new HTTPException(400, {
+ res: Response.json(
+ {
+ error: field?.startsWith("redirect_uri")
+ ? "invalid_redirect_uri"
+ : error,
+ error_description: issue
+ ? `${field || "request"}: ${issue.message}`
+ : "Invalid request",
+ },
+ { status: 400 },
+ ),
+ });
+ };
+
const registerRoute = createRoute({
method: "post",
operationId: "registerMcpOAuthClient",
@@ -163,27 +191,38 @@ const decideAuthorizationRequestRoute = createRoute({
});
mcp
- .openapi(registerRoute, async (c) =>
- c.json(await registerMcpClient(c.req.valid("json")), 200),
+ .openapi(
+ registerRoute,
+ async (c) => c.json(await registerMcpClient(c.req.valid("json")), 200),
+ oauthValidationHook("invalid_client_metadata"),
)
- .openapi(authorizeRoute, async (c) =>
- c.redirect(await beginMcpAuthorization(c.req.valid("query"))),
+ .openapi(
+ authorizeRoute,
+ async (c) => c.redirect(await beginMcpAuthorization(c.req.valid("query"))),
+ oauthValidationHook("invalid_request"),
)
- .openapi(getAuthorizationRequestRoute, async (c) =>
- c.json(
- await getMcpAuthorizationRequest(c.req.valid("param").requestId),
- 200,
- ),
+ .openapi(
+ getAuthorizationRequestRoute,
+ async (c) =>
+ c.json(
+ await getMcpAuthorizationRequest(c.req.valid("param").requestId),
+ 200,
+ ),
+ oauthValidationHook("invalid_request"),
)
- .openapi(decideAuthorizationRequestRoute, async (c) => {
- const redirect = await decideMcpAuthorizationRequest({
- requestId: c.req.valid("param").requestId,
- decision: c.req.valid("json"),
- headers: c.req.raw.headers,
- origin: c.req.header("origin"),
- });
- return c.json({ redirect }, 200);
- });
+ .openapi(
+ decideAuthorizationRequestRoute,
+ async (c) => {
+ const redirect = await decideMcpAuthorizationRequest({
+ requestId: c.req.valid("param").requestId,
+ decision: c.req.valid("json"),
+ headers: c.req.raw.headers,
+ origin: c.req.header("origin"),
+ });
+ return c.json({ redirect }, 200);
+ },
+ oauthValidationHook("invalid_request"),
+ );
mcp.all("/mcp", async (c) => {
const authResult = await validateBearerToken(c.req.raw);
diff --git a/apps/api/src/mcp/schemas.ts b/apps/api/src/mcp/schemas.ts
index f5e7ae538..8257c9d9f 100644
--- a/apps/api/src/mcp/schemas.ts
+++ b/apps/api/src/mcp/schemas.ts
@@ -27,12 +27,20 @@ const redirectUriSchema = z
.max(2048)
.refine(isValidRedirectUri, "Invalid redirect URI");
+// Clients such as Claude also ask for refresh_token. The server never issues
+// one, so the grant is accepted here and omitted from the registration response.
export const clientRegistrationSchema = z.object({
redirect_uris: z.array(redirectUriSchema).min(1),
client_name: z.string().max(100).optional(),
token_endpoint_auth_method: z.literal("none").optional(),
- grant_types: z.tuple([z.literal("authorization_code")]).optional(),
- response_types: z.tuple([z.literal("code")]).optional(),
+ grant_types: z
+ .array(z.enum(["authorization_code", "refresh_token"]))
+ .refine(
+ (types) => types.includes("authorization_code"),
+ "grant_types must include authorization_code",
+ )
+ .optional(),
+ response_types: z.array(z.literal("code")).min(1).optional(),
});
export const authorizationQuerySchema = z.object({
@@ -55,7 +63,7 @@ export const authorizationDecisionSchema = z.object({
});
export const oauthErrorSchema = z
- .object({ error: z.string() })
+ .object({ error: z.string(), error_description: z.string().optional() })
.openapi("OAuthError");
export const clientRegistrationResponseSchema = z
diff --git a/apps/docs/openapi.json b/apps/docs/openapi.json
index 1fd3af557..b3bbacde6 100644
--- a/apps/docs/openapi.json
+++ b/apps/docs/openapi.json
@@ -167,6 +167,9 @@
"properties": {
"error": {
"type": "string"
+ },
+ "error_description": {
+ "type": "string"
}
},
"required": [
@@ -5269,25 +5272,23 @@
},
"grant_types": {
"type": "array",
- "prefixItems": [
- {
- "type": "string",
- "enum": [
- "authorization_code"
- ]
- }
- ]
+ "items": {
+ "type": "string",
+ "enum": [
+ "authorization_code",
+ "refresh_token"
+ ]
+ }
},
"response_types": {
"type": "array",
- "prefixItems": [
- {
- "type": "string",
- "enum": [
- "code"
- ]
- }
- ]
+ "items": {
+ "type": "string",
+ "enum": [
+ "code"
+ ]
+ },
+ "minItems": 1
}
},
"required": [
diff --git a/tests/api/mcp-oauth-security.test.ts b/tests/api/mcp-oauth-security.test.ts
index 2a7210ade..5b53419d4 100644
--- a/tests/api/mcp-oauth-security.test.ts
+++ b/tests/api/mcp-oauth-security.test.ts
@@ -168,6 +168,66 @@ describe("MCP OAuth security", () => {
expect(remoteHttp.status).toBe(400);
});
+ it("accepts Claude-style registration metadata and never grants refresh tokens", async () => {
+ const response = await mcpRoutes.request("/mcp/register", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ client_name: "Claude",
+ redirect_uris: ["https://claude.ai/api/mcp/auth_callback"],
+ token_endpoint_auth_method: "none",
+ grant_types: ["authorization_code", "refresh_token"],
+ response_types: ["code"],
+ client_uri: "https://claude.ai",
+ }),
+ });
+ expect(response.status).toBe(200);
+ await expect(response.json()).resolves.toMatchObject({
+ grant_types: ["authorization_code"],
+ response_types: ["code"],
+ token_endpoint_auth_method: "none",
+ });
+ });
+
+ it("returns RFC 7591 JSON errors for invalid registration metadata", async () => {
+ const missingGrant = await mcpRoutes.request("/mcp/register", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ redirect_uris: ["https://client.example/callback"],
+ grant_types: ["refresh_token"],
+ }),
+ });
+ expect(missingGrant.status).toBe(400);
+ await expect(missingGrant.json()).resolves.toMatchObject({
+ error: "invalid_client_metadata",
+ });
+
+ const badRedirect = await mcpRoutes.request("/mcp/register", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ redirect_uris: ["http://attacker.example/callback"],
+ }),
+ });
+ expect(badRedirect.status).toBe(400);
+ await expect(badRedirect.json()).resolves.toMatchObject({
+ error: "invalid_redirect_uri",
+ });
+ });
+
+ it("returns RFC 6749 JSON errors for malformed authorization requests", async () => {
+ const response = await mcpRoutes.request(
+ "/mcp/authorize?response_type=code&client_id=x&redirect_uri=https%3A%2F%2Fclient.example%2Fcb&code_challenge=abc&code_challenge_method=plain",
+ { redirect: "manual" },
+ );
+ expect(response.status).toBe(400);
+ expect(response.headers.get("content-type")).toContain("application/json");
+ await expect(response.json()).resolves.toMatchObject({
+ error: "invalid_request",
+ });
+ });
+
it("requires an exact registered redirect URI", async () => {
const registeredRedirect = "https://client.example/callback";
const client = await registerClient(registeredRedirect);