@devries-cameron20 / t3code-1 / commits / 6d46336476
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(observability): redact credential URL params in spans and type them as Redacted (#27986)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 30, 2026 at 22:13 UTC 6d46336476941257d774be7c7733e9caf201fec2
11 files changed +120 -45
apps/server/src/auth/EnvironmentAuth.test.ts
+16 -12
@@ -703,40 +703,44 @@ it.layer(NodeServices.layer)("EnvironmentAuth.layer", (it) => {
703 );
704
705 const rpc = yield* serverAuth.issueWebSocketTicket(session, { use: "rpc" });
706 - const bare = yield* Effect.flip(upgrade(rpc.ticket, "rpc"));
706 + const bare = yield* Effect.flip(upgrade(Redacted.value(rpc.ticket), "rpc"));
707 expect(bare._tag).toBe("ServerAuthInvalidCredentialError");
708 const signed = yield* upgrade(
709 - rpc.ticket,
709 + Redacted.value(rpc.ticket),
710 "rpc",
711 - key.sign({ method: "GET", url: socketUrl, token: rpc.ticket, iat }),
711 + key.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
712 );
713 expect(signed.sessionId).toBe(session.sessionId);
714
715 const wrongKey = yield* Effect.flip(
716 upgrade(
717 - rpc.ticket,
717 + Redacted.value(rpc.ticket),
718 "rpc",
719 - other.sign({ method: "GET", url: socketUrl, token: rpc.ticket, iat }),
719 + other.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
720 ),
721 );
722 expect(wrongKey._tag).toBe("ServerAuthInvalidCredentialError");
723 const onMedia = yield* Effect.flip(
724 upgrade(
725 - rpc.ticket,
725 + Redacted.value(rpc.ticket),
726 "media",
727 - key.sign({ method: "GET", url: socketUrl, token: rpc.ticket, iat }),
727 + key.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
728 ),
729 );
730 expect(onMedia._tag).toBe("ServerAuthInvalidCredentialError");
731
732 const media = yield* serverAuth.issueWebSocketTicket(session, { use: "media" });
733 - expect((yield* upgrade(media.ticket, "media")).sessionId).toBe(session.sessionId);
734 - const mediaOnRpc = yield* Effect.flip(upgrade(media.ticket, "rpc"));
733 + expect((yield* upgrade(Redacted.value(media.ticket), "media")).sessionId).toBe(
734 + session.sessionId,
735 + );
736 + const mediaOnRpc = yield* Effect.flip(upgrade(Redacted.value(media.ticket), "rpc"));
737 expect(mediaOnRpc._tag).toBe("ServerAuthInvalidCredentialError");
738
739 // Clients that predate ticket binding still connect with the unbound ticket they mint.
740 const legacy = yield* serverAuth.issueWebSocketTicket(session);
739 - expect((yield* upgrade(legacy.ticket, "rpc")).sessionId).toBe(session.sessionId);
741 + expect((yield* upgrade(Redacted.value(legacy.ticket), "rpc")).sessionId).toBe(
742 + session.sessionId,
743 + );
744 }).pipe(
745 Effect.provide(layerEnvironmentAuth({ desktopBootstrapToken: "desktop-bootstrap-token" })),
746 ),
@@ -757,10 +761,10 @@ it.layer(NodeServices.layer)("EnvironmentAuth.layer", (it) => {
761 const rpc = yield* serverAuth.issueWebSocketTicket(session, { use: "rpc" });
762 const request = {
763 method: "GET",
760 - url: `/ws?wsTicket=${rpc.ticket}&dpop=${key.sign({
764 + url: `/ws?wsTicket=${Redacted.value(rpc.ticket)}&dpop=${key.sign({
765 method: "GET",
766 url: "http://192.168.1.50:3773/ws",
763 - token: rpc.ticket,
767 + token: Redacted.value(rpc.ticket),
768 iat: Math.floor((yield* DateTime.now).epochMilliseconds / 1_000),
769 })}`,
770 cookies: {},
apps/server/src/auth/EnvironmentAuth.ts
+12 -8
@@ -31,6 +31,7 @@ import * as Duration from "effect/Duration";
31 import * as Effect from "effect/Effect";
32 import * as Layer from "effect/Layer";
33 import * as Option from "effect/Option";
34 +import * as Redacted from "effect/Redacted";
35 import * as Schema from "effect/Schema";
36 import * as HttpServerRequest from "effect/http/HttpServerRequest";
37
@@ -568,8 +569,11 @@ type BootstrapExchangeResult = {
569
570 const AUTHORIZATION_PREFIX = "Bearer ";
571 const DPOP_AUTHORIZATION_PREFIX = "DPoP ";
571 -const WEBSOCKET_TICKET_QUERY_PARAM = "wsTicket";
572 -const WEBSOCKET_PROOF_QUERY_PARAM = "dpop";
572 +const WebSocketUpgradeQuery = Schema.Struct({
573 + wsTicket: Schema.optionalKey(Schema.RedactedFromValue(Schema.String)),
574 + dpop: Schema.optionalKey(Schema.RedactedFromValue(Schema.String)),
575 +});
576 +const decodeWebSocketUpgradeQuery = Schema.decodeEffect(WebSocketUpgradeQuery);
577
578 const bySessionPriority = (left: AuthClientSession, right: AuthClientSession) => {
579 const leftCanManage = left.scopes.includes(AuthAccessWriteScope);
@@ -1215,7 +1219,7 @@ export const make = Effect.gen(function* () {
1219 Effect.map(
1220 (issued) =>
1221 ({
1218 - ticket: issued.token,
1222 + ticket: Redacted.make(issued.token),
1223 expiresAt: DateTime.toUtc(issued.expiresAt),
1224 }) satisfies AuthWebSocketTicketResult,
1225 ),
@@ -1231,7 +1235,10 @@ export const make = Effect.gen(function* () {
1235 Effect.fn("EnvironmentAuth.authenticateWebSocketUpgrade")(function* (request, use) {
1236 const requestUrl = HttpServerRequest.toURL(request);
1237 if (Option.isSome(requestUrl)) {
1234 - const websocketTicket = requestUrl.value.searchParams.get(WEBSOCKET_TICKET_QUERY_PARAM);
1238 + const query = yield* decodeWebSocketUpgradeQuery(
1239 + Object.fromEntries(requestUrl.value.searchParams),
1240 + ).pipe(Effect.orDie);
1241 + const websocketTicket = query.wsTicket && Redacted.value(query.wsTicket);
1242 if (websocketTicket && websocketTicket.trim().length > 0) {
1243 const session = yield* sessions
1244 .verifyWebSocketToken(websocketTicket)
@@ -1245,10 +1252,7 @@ export const make = Effect.gen(function* () {
1252 // WebSocket clients cannot set headers, so the proof travels in the query.
1253 // The proof hashes the ticket; consuming its jti prevents replay after first use.
1254 // Only encrypted transport prevents an active interceptor from racing that use.
1248 - const proof =
1249 - request.headers.dpop ??
1250 - requestUrl.value.searchParams.get(WEBSOCKET_PROOF_QUERY_PARAM) ??
1251 - undefined;
1255 + const proof = request.headers.dpop ?? (query.dpop && Redacted.value(query.dpop));
1256 if (!proof) {
1257 return yield* new ServerAuthInvalidCredentialError({
1258 diagnostic: "DPoP-bound WebSocket ticket requires a DPoP proof.",
apps/server/src/auth/McpOAuth.ts
+13 -6
@@ -23,6 +23,7 @@ import * as Crypto from "effect/Crypto";
23 import * as Effect from "effect/Effect";
24 import * as Layer from "effect/Layer";
25 import * as Option from "effect/Option";
26 +import * as Redacted from "effect/Redacted";
27 import * as Ref from "effect/Ref";
28 import * as Schema from "effect/Schema";
29 import { HttpServerRequest } from "effect/http";
@@ -162,7 +163,7 @@ export class McpOAuthRedirectError extends Schema.TaggedError<McpOAuthRedirectEr
163 error: Schema.Literals(["invalid_request", "unsupported_response_type", "invalid_target"]),
164 description: Schema.String,
165 redirectUri: Schema.String,
165 - state: Schema.optional(Schema.String),
166 + state: Schema.optional(Schema.RedactedFromValue(Schema.String)),
167 },
168 ) {}
169
@@ -170,7 +171,7 @@ export interface AuthorizationRequest {
171 readonly client: McpOAuthClient;
172 readonly redirectUri: string;
173 readonly codeChallenge: string;
173 - readonly state: string | undefined;
174 + readonly state: Redacted.Redacted<string> | undefined;
175 readonly resource: string;
176 readonly issuer: string;
177 }
@@ -220,10 +221,15 @@ export class McpOAuth extends Context.Service<
221 }
222 >()("t3/auth/McpOAuth") {}
223
223 -const redirectWith = (redirectUri: string, params: Record<string, string | undefined>) => {
224 +const redirectWith = (
225 + redirectUri: string,
226 + params: Record<string, string | Redacted.Redacted<string> | undefined>,
227 +) => {
228 const url = new URL(redirectUri);
229 for (const [name, value] of Object.entries(params)) {
226 - if (value !== undefined) url.searchParams.set(name, value);
230 + if (value !== undefined) {
231 + url.searchParams.set(name, Redacted.isRedacted(value) ? Redacted.value(value) : value);
232 + }
233 }
234 return url.toString();
235 };
@@ -484,8 +490,9 @@ const make = Effect.gen(function* () {
490 if (token.grant_type !== "authorization_code") {
491 return yield* fail("unsupported_grant_type", "Only authorization_code is supported.");
492 }
487 - const { code, redirect_uri: redirectUri, client_id: clientId } = token;
488 - const verifier = token.code_verifier;
493 + const { redirect_uri: redirectUri, client_id: clientId } = token;
494 + const code = token.code && Redacted.value(token.code);
495 + const verifier = token.code_verifier && Redacted.value(token.code_verifier);
496 if (!code || !redirectUri || !clientId || !verifier) {
497 return yield* fail(
498 "invalid_request",
apps/server/src/auth/mcpOAuthHttp.ts
+7 -2
@@ -1,12 +1,13 @@
1 import {
2 AuthMcpApprovalError,
3 - type AuthMcpAuthorizationRequest,
3 + AuthMcpAuthorizationRequest,
4 AuthMcpClientAccess,
5 EnvironmentHttpApi,
6 mcpClientScopes,
7 } from "@t3tools/contracts";
8 import * as Effect from "effect/Effect";
9 import * as Result from "effect/Result";
10 +import * as Schema from "effect/Schema";
11 import { HttpServerRequest, HttpServerResponse } from "effect/http";
12 import * as HttpEffect from "effect/http/HttpEffect";
13 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
@@ -33,6 +34,7 @@ const noStore = HttpEffect.appendPreResponseHandler((_request, response) =>
34 );
35
36 const requestUrls = Effect.map(HttpServerRequest.HttpServerRequest, McpOAuth.requestUrls);
37 +const decodeAuthorizationRequest = Schema.decodeEffect(AuthMcpAuthorizationRequest);
38
39 /**
40 * An unverified client or redirect is reported, never redirected; any other problem goes back to
@@ -86,8 +88,11 @@ export const layer = HttpApiBuilder.group(
88 Effect.gen(function* () {
89 const urls = yield* requestUrls;
90 const url = new URL(request.url, urls.issuer);
91 + const authorizationRequest = yield* decodeAuthorizationRequest(
92 + Object.fromEntries(url.searchParams),
93 + ).pipe(Effect.orDie);
94 const authorization = yield* oauth
90 - .validateAuthorization({ urls, request: Object.fromEntries(url.searchParams) })
95 + .validateAuthorization({ urls, request: authorizationRequest })
96 .pipe(Effect.result);
97 const headers = { "cache-control": "no-store", "referrer-policy": "no-referrer" };
98 if (Result.isSuccess(authorization)) {
apps/server/src/peer/PeerLinks.ts
+4 -3
@@ -21,6 +21,7 @@ import * as Base64Url from "effect/encoding/Base64Url";
21 import * as Hex from "effect/encoding/Hex";
22 import * as Layer from "effect/Layer";
23 import * as Option from "effect/Option";
24 +import * as Redacted from "effect/Redacted";
25 import * as Result from "effect/Result";
26 import * as Schema from "effect/Schema";
27 import * as SqlClient from "effect/sql/SqlClient";
@@ -263,7 +264,7 @@ const make = Effect.gen(function* () {
264 redirect_uri: LINK_REDIRECT_URI,
265 code_challenge: challenge,
266 code_challenge_method: "S256",
266 - state,
267 + state: Redacted.make(state),
268 resource,
269 },
270 decision: { _tag: "pairing-code", access: input.access, code: input.pairingCode },
@@ -297,10 +298,10 @@ const make = Effect.gen(function* () {
298 .token({
299 payload: {
300 grant_type: "authorization_code",
300 - code,
301 + code: Redacted.make(code),
302 redirect_uri: LINK_REDIRECT_URI,
303 client_id: registered.client_id,
303 - code_verifier: verifier,
304 + code_verifier: Redacted.make(verifier),
305 resource,
306 },
307 })
apps/web/src/components/auth/ConnectAgentSurface.tsx
+4 -2
@@ -3,7 +3,7 @@ import {
3 type AuthMcpApprovalDetails,
4 AuthMcpApprovalError,
5 AuthMcpClientAccess,
6 - type AuthMcpAuthorizationRequest,
6 + AuthMcpAuthorizationRequest,
7 } from "@t3tools/contracts";
8 import { Radio as RadioPrimitive } from "@base-ui/react/radio";
9 import { isLoopbackHost } from "@t3tools/shared/preview";
@@ -76,8 +76,10 @@ function runApproval<A>(
76 ).catch((): Answer<A> => ({ kind: "error", message: UNREACHABLE }));
77 }
78
79 +const decodeAuthorizationRequest = Schema.decodeSync(AuthMcpAuthorizationRequest);
80 +
81 function readAuthorizationRequest(): AuthMcpAuthorizationRequest {
80 - return Object.fromEntries(new URL(window.location.href).searchParams);
82 + return decodeAuthorizationRequest(Object.fromEntries(new URL(window.location.href).searchParams));
83 }
84
85 /** Sessions can grant only scopes they hold. */
packages/client-runtime/src/authorization/remote.ts
+4 -3
@@ -12,6 +12,7 @@ import { encodeOAuthScope } from "@t3tools/shared/oauthScope";
12 import { hashTelemetryId } from "@t3tools/shared/telemetryId";
13 import * as Effect from "effect/Effect";
14 import * as Option from "effect/Option";
15 +import * as Redacted from "effect/Redacted";
16 import { environmentEndpointUrl } from "../environment/endpoint.ts";
17 import * as ClientCapabilities from "../platform/capabilities.ts";
18 import {
@@ -290,7 +291,7 @@ export const resolveRemoteWebSocketConnectionUrl = Effect.fn(
291 });
292
293 const url = rpcSocketUrl(input.wsBaseUrl);
293 - url.searchParams.set("wsTicket", issued.ticket);
294 + url.searchParams.set("wsTicket", Redacted.value(issued.ticket));
295 appendClientConnectionParams(
296 url,
297 input.clientMetadata,
@@ -343,9 +344,9 @@ export const resolveRemoteDpopWebSocketConnectionUrl = Effect.fn(
344 const upgradeProof = yield* input.createProof({
345 method: "GET",
346 url: `${url.protocol === "wss:" ? "https:" : "http:"}//${url.host}${url.pathname}`,
346 - accessToken: issued.ticket,
347 + accessToken: Redacted.value(issued.ticket),
348 });
348 - url.searchParams.set("wsTicket", issued.ticket);
349 + url.searchParams.set("wsTicket", Redacted.value(issued.ticket));
350 url.searchParams.set("dpop", upgradeProof);
351 appendClientConnectionParams(
352 url,
packages/client-runtime/src/state/deviceHubAccess.ts
+2 -1
@@ -5,6 +5,7 @@
5 * stream.
6 */
7 import * as Effect from "effect/Effect";
8 +import * as Redacted from "effect/Redacted";
9 import type { HttpClient } from "effect/http";
10
11 import * as RemoteEnvironmentAuthorization from "../authorization/service.ts";
@@ -47,7 +48,7 @@ export const resolveDeviceHubAccess = Effect.fn("clientRuntime.state.resolveDevi
48 return {
49 httpBase,
50 wsBase,
50 - query: { wsTicket: ticket.ticket },
51 + query: { wsTicket: Redacted.value(ticket.ticket) },
52 credentials: false,
53 };
54 },
packages/contracts/src/auth.ts
+4 -4
@@ -238,7 +238,7 @@ export const AuthAccessTokenResult = Schema.Struct({
238 export type AuthAccessTokenResult = typeof AuthAccessTokenResult.Type;
239
240 export const AuthWebSocketTicketResult = Schema.Struct({
241 - ticket: TrimmedNonEmptyString,
241 + ticket: Schema.RedactedFromValue(TrimmedNonEmptyString),
242 expiresAt: Schema.DateTimeUtc,
243 });
244 export type AuthWebSocketTicketResult = typeof AuthWebSocketTicketResult.Type;
@@ -490,7 +490,7 @@ export const AuthMcpAuthorizationRequest = Schema.Struct({
490 redirect_uri: Schema.optionalKey(Schema.String),
491 code_challenge: Schema.optionalKey(Schema.String),
492 code_challenge_method: Schema.optionalKey(Schema.String),
493 - state: Schema.optionalKey(Schema.String),
493 + state: Schema.optionalKey(Schema.RedactedFromValue(Schema.String)),
494 resource: Schema.optionalKey(Schema.String),
495 });
496 export type AuthMcpAuthorizationRequest = typeof AuthMcpAuthorizationRequest.Type;
@@ -539,10 +539,10 @@ export class AuthMcpApprovalError extends Schema.TaggedError<AuthMcpApprovalErro
539
540 export const AuthMcpTokenRequest = Schema.Struct({
541 grant_type: Schema.optionalKey(Schema.String),
542 - code: Schema.optionalKey(Schema.String),
542 + code: Schema.optionalKey(Schema.RedactedFromValue(Schema.String)),
543 redirect_uri: Schema.optionalKey(Schema.String),
544 client_id: Schema.optionalKey(Schema.String),
545 - code_verifier: Schema.optionalKey(Schema.String),
545 + code_verifier: Schema.optionalKey(Schema.RedactedFromValue(Schema.String)),
546 resource: Schema.optionalKey(Schema.String),
547 }).pipe(HttpApiSchema.asFormUrlEncoded());
548 export type AuthMcpTokenRequest = typeof AuthMcpTokenRequest.Type;
packages/shared/src/httpObservability.test.ts new
+33
@@ -0,0 +1,33 @@
1 +import { describe, expect, it } from "@effect/vitest";
2 +import * as Effect from "effect/Effect";
3 +import * as Tracer from "effect/Tracer";
4 +import * as HttpClient from "effect/http/HttpClient";
5 +import * as HttpClientResponse from "effect/http/HttpClientResponse";
6 +
7 +import * as HttpObservability from "./httpObservability.ts";
8 +
9 +describe("HttpObservability.layer", () => {
10 + it.effect("redacts credential query parameters on HTTP client spans", () => {
11 + const spans: Array<Tracer.NativeSpan> = [];
12 + const tracer = Tracer.make({
13 + span: (options) => {
14 + const span = new Tracer.NativeSpan(options);
15 + spans.push(span);
16 + return span;
17 + },
18 + });
19 + const client = HttpClient.make((request) =>
20 + Effect.succeed(HttpClientResponse.fromWeb(request, new Response("ok"))),
21 + );
22 + return Effect.gen(function* () {
23 + yield* client.get("https://example.com/ws?wsTicket=secret&clientOs=linux&dpop=proof");
24 + const span = spans.find((candidate) => candidate.kind === "client")!;
25 + expect(span.attributes.get("url.full")).toBe(
26 + "https://example.com/ws?wsTicket=REDACTED&clientOs=linux&dpop=REDACTED",
27 + );
28 + expect(span.attributes.get("url.query")).toBe(
29 + "wsTicket=REDACTED&clientOs=linux&dpop=REDACTED",
30 + );
31 + }).pipe(Effect.provide(HttpObservability.layer), Effect.withTracer(tracer));
32 + });
33 +});
packages/shared/src/httpObservability.ts
+21 -4
@@ -1,9 +1,26 @@
1 import * as Effect from "effect/Effect";
2 import * as Layer from "effect/Layer";
3 import * as Headers from "effect/http/Headers";
4 +import * as UrlParams from "effect/http/UrlParams";
5
5 -export const layer = Layer.effect(
6 - Headers.CurrentRedactedNames,
7 - // `expo-session` carries the `eas login` session secret on Expo API requests.
8 - Effect.map(Headers.CurrentRedactedNames, (names) => [...names, "dpop", "expo-session"]),
6 +export const layer = Layer.mergeAll(
7 + Layer.effect(
8 + Headers.CurrentRedactedNames,
9 + // `expo-session` carries the `eas login` session secret on Expo API requests.
10 + Effect.map(Headers.CurrentRedactedNames, (names) => [...names, "dpop", "expo-session"]),
11 + ),
12 + Layer.effect(
13 + UrlParams.CurrentRedactedNames,
14 + // Socket tickets and proofs, pairing tokens, and OAuth codes travel in query strings.
15 + Effect.map(UrlParams.CurrentRedactedNames, (names) => [
16 + ...names,
17 + "wsTicket",
18 + "dpop",
19 + "token",
20 + "pairingUrl",
21 + "code",
22 + "state",
23 + "challenge",
24 + ]),
25 + ),
26 );