Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

mcpOAuthHttp.ts

194 lines7.9 KB

1import {
2 AuthMcpApprovalError,
3 AuthMcpAuthorizationRequest,
4 AuthMcpClientAccess,
5 EnvironmentHttpApi,
6 mcpClientScopes,
7} from "@t3tools/contracts";
8import * as Effect from "effect/Effect";
9import * as Option from "effect/Option";
10import * as Result from "effect/Result";
11import * as Schema from "effect/Schema";
12import { HttpServerRequest, HttpServerResponse } from "effect/http";
13import * as HttpEffect from "effect/http/HttpEffect";
14import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
15​
16import { DEFAULT_HOSTED_APP_URL } from "@t3tools/shared/connectAuth";
17​
18import * as CloudLink from "../cloud/CloudLink.ts";
19import { agentApprovalAppUrlConfig } from "../cloud/publicConfig.ts";
20import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
21import * as McpOAuth from "./McpOAuth.ts";
22import { renderErrorPage } from "./mcpOAuthHtml.ts";
23​
24const APPROVAL_PAGE_PATH = "/connect-agent";
25const HOSTED_APPROVAL_PATH = "/approve-agent";
26​
27const PAGE_HEADERS = {
28 "content-security-policy":
29 "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'",
30 "x-frame-options": "DENY",
31 "cache-control": "no-store",
32 "referrer-policy": "no-referrer",
33 "x-content-type-options": "nosniff",
34};
35​
36// OAuth responses contain credentials and must not be cached.
37const noStore = HttpEffect.appendPreResponseHandler((_request, response) =>
38 Effect.succeed(
39 HttpServerResponse.setHeaders(response, { "cache-control": "no-store", pragma: "no-cache" }),
40 ),
41);
42​
43const requestUrls = Effect.map(HttpServerRequest.HttpServerRequest, McpOAuth.requestUrls);
44const decodeAuthorizationRequest = Schema.decodeEffect(AuthMcpAuthorizationRequest);
45​
46/**
47 * An unverified client or redirect is reported, never redirected; any other problem goes back to
48 * the agent through its (verified) redirect URI.
49 */
50const forwardedAuthorization =
51 /* Request instrumentation already owns the span; keep this helper in that context. */
52 Effect.fnUntraced(function* (
53 oauth: McpOAuth.McpOAuth["Service"],
54 request: AuthMcpAuthorizationRequest,
55 ) {
56 const urls = yield* requestUrls;
57 return yield* oauth.validateAuthorization({ urls, request }).pipe(
58 Effect.catchTags({
59 McpOAuthPageError: (error) =>
60 Effect.fail(new AuthMcpApprovalError({ message: error.description })),
61 McpOAuthRedirectError: (error) =>
62 Effect.succeed({ redirectTo: McpOAuth.redirectForError(error, urls.issuer) }),
63 }),
64 );
65 });
66​
67export const layer = HttpApiBuilder.group(
68 EnvironmentHttpApi,
69 "mcpOAuth",
70 Effect.fnUntraced(function* (handlers) {
71 const oauth = yield* McpOAuth.McpOAuth;
72 const cloudLink = yield* CloudLink.CloudLink;
73 const serverEnvironment = yield* ServerEnvironment.ServerEnvironmentIdentity;
74 const hostedAppUrl = yield* agentApprovalAppUrlConfig.pipe(
75 Effect.orElseSucceed(() => DEFAULT_HOSTED_APP_URL),
76 );
77 // T3 Connect serves this host, so the owner can approve on the hosted app by signing in there.
78 const hostedApprovalUrl = (issuer: string, search: string) =>
79 cloudLink.linkState().pipe(
80 Effect.flatMap((state) =>
81 state.linked && !state.linkRevoked && state.tunnelHostname === new URL(issuer).hostname
82 ? serverEnvironment.getEnvironmentId.pipe(
83 Effect.map((environmentId) => {
84 const url = new URL(HOSTED_APPROVAL_PATH, hostedAppUrl);
85 url.search = search;
86 url.searchParams.set("environment", environmentId);
87 return Option.some(url.toString());
88 }),
89 )
90 : Effect.succeedNone,
91 ),
92 Effect.orElseSucceed(Option.none),
93 );
94 const protectedResource = () =>
95 requestUrls.pipe(Effect.map(McpOAuth.protectedResourceMetadata));
96​
97 return handlers
98 .handle("protectedResource", protectedResource)
99 .handle("mcpProtectedResource", protectedResource)
100 .handle("authorizationServer", () =>
101 requestUrls.pipe(Effect.map(McpOAuth.authorizationServerMetadata)),
102 )
103 .handle("register", ({ payload }) =>
104 oauth.register(payload).pipe(
105 Effect.map((client) => ({
106 client_id: client.clientId,
107 client_name: client.name,
108 redirect_uris: client.redirectUris,
109 grant_types: ["authorization_code" as const],
110 response_types: ["code" as const],
111 token_endpoint_auth_method: "none" as const,
112 })),
113 Effect.tap(() => noStore),
114 ),
115 )
116 .handleRaw("authorize", ({ request }) =>
117 Effect.gen(function* () {
118 const urls = yield* requestUrls;
119 const url = new URL(request.url, urls.issuer);
120 const authorizationRequest = yield* decodeAuthorizationRequest(
121 Object.fromEntries(url.searchParams),
122 ).pipe(Effect.orDie);
123 const authorization = yield* oauth
124 .validateAuthorization({ urls, request: authorizationRequest })
125 .pipe(Effect.result);
126 const headers = { "cache-control": "no-store", "referrer-policy": "no-referrer" };
127 if (Result.isSuccess(authorization)) {
128 // A link needs a plain pairing code, so it stays on this environment's own page.
129 const hosted = authorization.success.client.peerLink
130 ? Option.none()
131 : yield* hostedApprovalUrl(urls.issuer, url.search);
132 return HttpServerResponse.redirect(
133 Option.getOrElse(hosted, () => `${APPROVAL_PAGE_PATH}${url.search}`),
134 { headers },
135 );
136 }
137 const error = authorization.failure;
138 return error._tag === "McpOAuthPageError"
139 ? HttpServerResponse.text(renderErrorPage(error.description), {
140 status: 400,
141 contentType: "text/html; charset=utf-8",
142 headers: PAGE_HEADERS,
143 })
144 : HttpServerResponse.redirect(McpOAuth.redirectForError(error, urls.issuer), {
145 headers,
146 });
147 }),
148 )
149 .handle("approval", ({ payload, request }) =>
150 Effect.gen(function* () {
151 const resolved = yield* forwardedAuthorization(oauth, payload);
152 if ("redirectTo" in resolved) return resolved;
153 const urls = yield* requestUrls;
154 const session = yield* oauth.approvingSession(request, resolved);
155 yield* noStore;
156 return {
157 clientName: resolved.client.name,
158 redirectHost: new URL(resolved.redirectUri).host,
159 environmentHost: new URL(urls.issuer).host,
160 ...(oauth.runtimeModeCeiling === undefined
161 ? {}
162 : { runtimeModeCeiling: oauth.runtimeModeCeiling }),
163 ...(session === undefined
164 ? {}
165 : {
166 csrfToken: session.csrfToken,
167 oneClickAccess: AuthMcpClientAccess.literals.filter((access) =>
168 mcpClientScopes(access).every((scope) => session.scopes.includes(scope)),
169 ),
170 }),
171 };
172 }),
173 )
174 .handle("decision", ({ payload, request }) =>
175 Effect.gen(function* () {
176 const resolved = yield* forwardedAuthorization(oauth, payload.authorization);
177 if ("redirectTo" in resolved) return resolved;
178 yield* noStore;
179 const { decision } = payload;
180 if (decision._tag === "deny") return { redirectTo: oauth.deny(resolved) };
181 return yield* oauth.approve({ request, authorization: resolved, decision }).pipe(
182 Effect.map((redirectTo) => ({ redirectTo })),
183 Effect.mapError((error) => new AuthMcpApprovalError({ message: error.message })),
184 );
185 }),
186 )
187 .handle("token", ({ payload, request }) =>
188 Effect.gen(function* () {
189 yield* noStore;
190 return yield* oauth.exchangeCode({ request, urls: yield* requestUrls, token: payload });
191 }),
192 );
193 }),
194);