@devries-cameron20 / t3code-1 / commits / a09aef3287
Fork 0

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

fix(server): load PR uploads from SSO organizations (#21632)

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

Julius Marminge committed Nov 5, 2026 at 11:58 UTC a09aef3287d29f74e2270fae05ab0cef8202cfa1
5 files changed +345 -40
apps/server/src/assets/AssetAccess.test.ts
+28 -3
@@ -35,6 +35,7 @@ import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
35 import { assetFileResponse } from "../http.ts";
36 import { ASSET_ROUTE_PREFIX, issueAssetUrl, readMcpAppHtml, resolveAsset } from "./AssetAccess.ts";
37 import * as NativeAppIconResolver from "./NativeAppIconResolver.ts";
38 +import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
39 import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
40 import { fakeSourceControlDriverInstance } from "@t3tools/source-control-testing/fakeSourceControlDriver";
41 import * as BuiltInDrivers from "../sourceControl/builtInDrivers.ts";
@@ -1497,7 +1498,11 @@ describe("AssetAccess", () => {
1498 );
1499
1500 it.effect("serves a host's credentialed media through that host's driver", () => {
1500 - const fetched: Array<{ url: string; headers: Readonly<Record<string, string>> }> = [];
1501 + const fetched: Array<{
1502 + url: string;
1503 + headers: Readonly<Record<string, string>>;
1504 + repository?: string;
1505 + }> = [];
1506 const url = "https://github.com/owner/repo/blob/main/docs/shot.png";
1507 const media = sourceControlDefinitions.mediaUrl(url)!;
1508 const layerDrivers = Layer.succeed(BuiltInDrivers.SourceControlDrivers, [
@@ -1516,6 +1521,17 @@ describe("AssetAccess", () => {
1521 }),
1522 },
1523 ]);
1524 + // Clients that predate `repository` get the checkout's.
1525 + const layerIdentities = Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({
1526 + resolve: () =>
1527 + Effect.succeed({
1528 + canonicalKey: "github.com/owner/repo",
1529 + locator: { source: "git-remote", remoteName: "origin", remoteUrl: "" },
1530 + provider: media.definition.kind,
1531 + owner: "owner",
1532 + name: "repo",
1533 + }),
1534 + });
1535 return Effect.gen(function* () {
1536 const decodeAssetCreateUrlInput = Schema.decodeEffect(AssetCreateUrlInput);
1537
@@ -1539,12 +1555,21 @@ describe("AssetAccess", () => {
1555 range: "bytes=0-4",
1556 cookie: "session",
1557 });
1542 - expect(fetched).toEqual([{ url: media.fetchUrl, headers: { range: "bytes=0-4" } }]);
1558 + expect(fetched).toEqual([
1559 + { url: media.fetchUrl, headers: { range: "bytes=0-4" }, repository: "owner/repo" },
1560 + ]);
1561 expect(response.status).toBe(206);
1562 // The upstream sent no type, so it comes from the file name the host gave the media.
1563 expect(response.headers["content-type"]).toBe("image/png");
1564 expect(response.headers["content-length"]).toBe("5");
1547 - }).pipe(Effect.provide(Layer.merge(layerTest, layerDrivers)), Effect.scoped);
1565 +
1566 + // A pull request's own repository wins over the checkout it is shown in.
1567 + yield* sourceControlMediaResponse({ ...asset, repository: "enterprise/private" }, {});
1568 + expect(fetched.at(-1)?.repository).toBe("enterprise/private");
1569 + }).pipe(
1570 + Effect.provide(Layer.mergeAll(layerTest, layerDrivers, layerIdentities)),
1571 + Effect.scoped,
1572 + );
1573 });
1574
1575 it.effect("refuses media no host keeps behind a credential, without echoing the URL", () =>
apps/server/src/assets/sourceControlMediaResponse.ts
+21 -2
@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
4 import * as Option from "effect/Option";
5 import { HttpServerResponse } from "effect/http";
6
7 +import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
8 import * as BuiltInDrivers from "../sourceControl/builtInDrivers.ts";
9 import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts";
10
@@ -25,7 +26,12 @@ const SVG_CONTENT_SECURITY_POLICY = "default-src 'none'; style-src 'unsafe-inlin
26 export const sourceControlMediaResponse = Effect.fn(
27 "SourceControlMediaResponse.sourceControlMediaResponse",
28 )(function* (
28 - asset: { readonly url: string; readonly cwd: string; readonly expiresAt: number },
29 + asset: {
30 + readonly url: string;
31 + readonly cwd: string;
32 + readonly repository?: string;
33 + readonly expiresAt: number;
34 + },
35 requestHeaders: Record<string, string | undefined>,
36 ) {
37 const remainingSeconds = Math.floor((asset.expiresAt - (yield* Clock.currentTimeMillis)) / 1000);
@@ -46,7 +52,20 @@ export const sourceControlMediaResponse = Effect.fn(
52 const value = requestHeaders[name];
53 if (value !== undefined) forwarded[name] = value;
54 }
49 - const response = yield* fetchMedia({ url: asset.url, headers: forwarded });
55 + // Clients that predate `repository` fall back to the repository checked out at `cwd`.
56 + let repository = asset.repository;
57 + if (repository === undefined) {
58 + const identities = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
59 + const identity = yield* identities.resolve(asset.cwd);
60 + if (identity?.provider === media.definition.kind && identity.owner && identity.name) {
61 + repository = `${identity.owner}/${identity.name}`;
62 + }
63 + }
64 + const response = yield* fetchMedia({
65 + url: asset.url,
66 + headers: forwarded,
67 + ...(repository === undefined ? {} : { repository }),
68 + });
69 if (response === null) return HttpServerResponse.empty({ status: 502, headers });
70 // It carries none of the upstream entity headers: a `content-length` with no body behind it
71 // holds the connection open until the browser gives up on it.
packages/source-control-core/src/server/driver.ts
+2
@@ -25,6 +25,8 @@ export interface SourceControlMediaRequest {
25 readonly url: string;
26 /** Request headers to forward, such as `range`. */
27 readonly headers: Readonly<Record<string, string>>;
28 + /** `owner/name` of the change request the media is in, else of the checkout it was shown in. */
29 + readonly repository?: string;
30 }
31
32 /** The server side of a definition's `credentials.appSignIn`. */
packages/source-control-github/src/server/gitHubMediaFetch.test.ts
+158 -20
@@ -2,10 +2,78 @@ import { describe, expect, it } from "@effect/vitest";
2 import * as Effect from "effect/Effect";
3 import * as Layer from "effect/Layer";
4 import * as Redacted from "effect/Redacted";
5 +import * as TestClock from "effect/testing/TestClock";
6 import { HttpClient, HttpClientResponse } from "effect/http";
7
8 import * as GitHubCredentials from "./GitHubCredentials.ts";
9 import * as GitHubMediaFetch from "./gitHubMediaFetch.ts";
10 +import * as GitHubRest from "./GitHubRest.ts";
11 +
12 +const PR_REPOSITORY = "enterprise/private";
13 +
14 +/** An SSO organization: the upload URL answers with a sign-in page, a rendered signed URL with bytes. */
15 +const makeSsoFixture = (uploadUrl: string) => {
16 + const state = { account: "account-a", expired: new Set<string>() };
17 + const rendered: Array<GitHubRest.GitHubRestInput> = [];
18 + const signedUrls: Array<string> = [];
19 + const requests: Array<{ url: string; authorization?: string; range?: string }> = [];
20 + const credential = (host: string) =>
21 + Effect.sync(() => ({
22 + host,
23 + token: Redacted.make(state.account),
24 + fingerprint: state.account,
25 + source: "gh" as const,
26 + }));
27 + const layer = Layer.mergeAll(
28 + Layer.mock(GitHubCredentials.GitHubCredentials)({ get: credential }),
29 + Layer.mock(GitHubRest.GitHubRest)({
30 + rest: (input) =>
31 + Effect.sync(() => {
32 + rendered.push(input);
33 + const signed = `https://private-user-images.githubusercontent.com/1/upload.mp4?jwt=${state.account}-${rendered.length}&x=1`;
34 + const inRepository =
35 + (input.body as { readonly context?: string } | undefined)?.context === PR_REPOSITORY;
36 + if (inRepository) signedUrls.push(signed);
37 + return {
38 + status: 200,
39 + headers: {},
40 + body: `<p><img src="${inRepository ? signed.replaceAll("&", "&amp;") : uploadUrl}" alt=""></p>`,
41 + truncated: false,
42 + invalidUtf8: false,
43 + };
44 + }),
45 + }),
46 + Layer.succeed(
47 + HttpClient.HttpClient,
48 + HttpClient.make((request) =>
49 + Effect.sync(() => {
50 + requests.push({
51 + url: request.url,
52 + ...(request.headers.authorization
53 + ? { authorization: request.headers.authorization }
54 + : {}),
55 + ...(request.headers.range ? { range: request.headers.range } : {}),
56 + });
57 + if (request.url === uploadUrl) {
58 + return HttpClientResponse.fromWeb(
59 + request,
60 + new Response("<html>Sign in with SSO</html>", {
61 + headers: { "content-type": "text/html; charset=utf-8" },
62 + }),
63 + );
64 + }
65 + expect(signedUrls).toContain(request.url);
66 + const status = state.expired.has(request.url) ? 403 : request.headers.range ? 206 : 200;
67 + return HttpClientResponse.fromWeb(
68 + request,
69 + new Response(null, { status, headers: { "content-type": "video/mp4" } }),
70 + );
71 + }),
72 + ),
73 + ),
74 + );
75 + return { layer, state, rendered, signedUrls, requests };
76 +};
77
78 describe("GitHubMediaFetch", () => {
79 it.effect("loads private media immediately after login with the GitHub credential", () => {
@@ -24,17 +92,20 @@ describe("GitHubMediaFetch", () => {
92 expect(authorizations).toEqual([undefined, "Bearer signed-in", "Bearer signed-in"]);
93 }).pipe(
94 Effect.provide(
27 - Layer.mock(GitHubCredentials.GitHubCredentials)({
28 - get: (host) =>
29 - ++lookups === 1
30 - ? Effect.fail(new GitHubCredentials.GitHubNotSignedInError({ host }))
31 - : Effect.succeed({
32 - host,
33 - token: Redacted.make("signed-in"),
34 - source: "gh" as const,
35 - fingerprint: "fingerprint",
36 - }),
37 - }),
95 + Layer.merge(
96 + Layer.mock(GitHubRest.GitHubRest)({}),
97 + Layer.mock(GitHubCredentials.GitHubCredentials)({
98 + get: (host) =>
99 + ++lookups === 1
100 + ? Effect.fail(new GitHubCredentials.GitHubNotSignedInError({ host }))
101 + : Effect.succeed({
102 + host,
103 + token: Redacted.make("signed-in"),
104 + source: "gh" as const,
105 + fingerprint: "fingerprint",
106 + }),
107 + }),
108 + ),
109 ),
110 Effect.provideService(
111 HttpClient.HttpClient,
@@ -70,15 +141,18 @@ describe("GitHubMediaFetch", () => {
141 ]);
142 }).pipe(
143 Effect.provide(
73 - Layer.mock(GitHubCredentials.GitHubCredentials)({
74 - get: (host) =>
75 - Effect.succeed({
76 - host,
77 - token: Redacted.make("signed-in"),
78 - source: "gh" as const,
79 - fingerprint: "fingerprint",
80 - }),
81 - }),
144 + Layer.merge(
145 + Layer.mock(GitHubRest.GitHubRest)({}),
146 + Layer.mock(GitHubCredentials.GitHubCredentials)({
147 + get: (host) =>
148 + Effect.succeed({
149 + host,
150 + token: Redacted.make("signed-in"),
151 + source: "gh" as const,
152 + fingerprint: "fingerprint",
153 + }),
154 + }),
155 + ),
156 ),
157 Effect.provideService(
158 HttpClient.HttpClient,
@@ -101,4 +175,68 @@ describe("GitHubMediaFetch", () => {
175 Effect.scoped,
176 );
177 });
178 +
179 + it.effect(
180 + "renders SSO uploads in the PR repository and reuses the signed URL for a range",
181 + () => {
182 + const url = "https://github.com/user-attachments/assets/explicit-pr-context";
183 + const fixture = makeSsoFixture(url);
184 + return Effect.gen(function* () {
185 + const fetchMedia = yield* GitHubMediaFetch.make;
186 + const request = { url, headers: {}, repository: PR_REPOSITORY };
187 + expect((yield* fetchMedia(request))?.status).toBe(200);
188 + expect((yield* fetchMedia({ ...request, headers: { range: "bytes=2-5" } }))?.status).toBe(
189 + 206,
190 + );
191 + expect(fixture.rendered).toHaveLength(1);
192 + expect(fixture.rendered[0]).toMatchObject({
193 + host: "github.com",
194 + method: "POST",
195 + path: "markdown",
196 + accept: "text/html",
197 + body: { text: `![](${url})`, mode: "gfm", context: PR_REPOSITORY },
198 + });
199 + expect(fixture.requests).toEqual([
200 + { url, authorization: "Bearer account-a" },
201 + { url: fixture.signedUrls[0] },
202 + { url: fixture.signedUrls[0], range: "bytes=2-5" },
203 + ]);
204 + }).pipe(Effect.provide(fixture.layer), Effect.scoped);
205 + },
206 + );
207 +
208 + it.effect("renders a legacy upload in the repository its path names", () => {
209 + const url = `https://github.com/${PR_REPOSITORY}/assets/123/legacy`;
210 + const fixture = makeSsoFixture(url);
211 + return Effect.gen(function* () {
212 + const fetchMedia = yield* GitHubMediaFetch.make;
213 + const response = yield* fetchMedia({ url, headers: {}, repository: "personal/unrelated" });
214 + expect(response?.status).toBe(200);
215 + expect(fixture.rendered.map((input) => input.body)).toEqual([
216 + { text: `![](${url})`, mode: "gfm", context: PR_REPOSITORY },
217 + ]);
218 + }).pipe(Effect.provide(fixture.layer), Effect.scoped);
219 + });
220 +
221 + it.effect("renders a fresh signed URL after an account switch, early expiry, or its TTL", () => {
222 + const url = "https://github.com/user-attachments/assets/cache-lifecycle";
223 + const fixture = makeSsoFixture(url);
224 + const request = { url, headers: {}, repository: PR_REPOSITORY };
225 + return Effect.gen(function* () {
226 + const fetchMedia = yield* GitHubMediaFetch.make;
227 + yield* fetchMedia(request);
228 + fixture.state.account = "account-b";
229 + yield* fetchMedia(request);
230 + expect(fixture.rendered).toHaveLength(2);
231 +
232 + fixture.state.expired.add(fixture.signedUrls.at(-1)!);
233 + expect((yield* fetchMedia(request))?.status).toBe(200);
234 + expect(fixture.rendered).toHaveLength(3);
235 +
236 + yield* TestClock.adjust("6 minutes");
237 + yield* fetchMedia(request);
238 + expect(fixture.rendered).toHaveLength(4);
239 + expect(fixture.requests.at(-1)?.url).toBe(fixture.signedUrls.at(-1));
240 + }).pipe(Effect.provide(fixture.layer), Effect.scoped);
241 + });
242 });
packages/source-control-github/src/server/gitHubMediaFetch.ts
+136 -15
@@ -1,4 +1,5 @@
1 import type { SourceControlMediaRequest } from "@t3tools/source-control-core/server/driver";
2 +import * as Clock from "effect/Clock";
3 import * as Effect from "effect/Effect";
4 import * as Redacted from "effect/Redacted";
5 import {
@@ -11,6 +12,7 @@ import {
12 import { GITHUB_CREDENTIALED_MEDIA_HOSTS } from "../shared/gitHubMedia.ts";
13
14 import * as GitHubCredentials from "./GitHubCredentials.ts";
15 +import * as GitHubRest from "./GitHubRest.ts";
16
17 /**
18 * Everything a redirect leads to — the presigned object stores GitHub hands assets off to —
@@ -18,51 +20,170 @@ import * as GitHubCredentials from "./GitHubCredentials.ts";
20 * bearer token.
21 */
22 const isCredentialedHost = (url: string) => {
21 - try {
22 - return GITHUB_CREDENTIALED_MEDIA_HOSTS.has(new URL(url).hostname.toLowerCase());
23 - } catch {
24 - return false;
25 - }
23 + const target = URL.parse(url);
24 + return (
25 + target !== null &&
26 + target.protocol === "https:" &&
27 + target.port === "" &&
28 + GITHUB_CREDENTIALED_MEDIA_HOSTS.has(target.hostname.toLowerCase())
29 + );
30 };
31
32 const MAX_REDIRECTS = 3;
33 const MANUAL_REDIRECT: RequestInit = { redirect: "manual" };
34 +const MEDIA_CONTENT_TYPE_PATTERN = /^(?:image|video|audio)\/[\w!#$&^.+-]+$/i;
35 +const ATTACHMENT_PATH_PATTERN =
36 + /^\/(?:user-attachments\/assets\/[\w-]+|[^/]+\/[^/]+\/assets\/\d+\/[\w-]+)$/u;
37 +const LEGACY_ATTACHMENT_REPOSITORY_PATTERN = /^\/([^/]+\/[^/]+)\/assets\//u;
38 +const REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/u;
39 +// GitHub's signed upload links last about five minutes.
40 +const SIGNED_URL_CACHE_TTL_MS = 4 * 60_000;
41 +const SIGNED_URL_CACHE_MAX_ENTRIES = 64;
42 +
43 +const contentTypeOf = (response: HttpClientResponse.HttpClientResponse) =>
44 + response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
45 +
46 +/** The repository an upload has to be rendered in, or `undefined` when it is not an upload. */
47 +const uploadRepository = (request: SourceControlMediaRequest) => {
48 + const target = URL.parse(request.url);
49 + if (
50 + target === null ||
51 + target.protocol !== "https:" ||
52 + target.hostname !== "github.com" ||
53 + target.port !== "" ||
54 + target.username !== "" ||
55 + target.password !== "" ||
56 + !ATTACHMENT_PATH_PATTERN.test(target.pathname)
57 + ) {
58 + return undefined;
59 + }
60 + // A legacy upload names its repository; one the caller supplies cannot override that.
61 + const repository =
62 + LEGACY_ATTACHMENT_REPOSITORY_PATTERN.exec(target.pathname)?.[1] ?? request.repository;
63 + // An unusable explicit context must not fall back to an unrelated checkout.
64 + return repository !== undefined && REPOSITORY_PATTERN.test(repository) ? repository : undefined;
65 +};
66
67 export const make = Effect.gen(function* () {
68 const credentials = yield* GitHubCredentials.GitHubCredentials;
69 + const rest = yield* GitHubRest.GitHubRest;
70 const httpClient = HttpClient.withScope(yield* HttpClient.HttpClient);
71 + const signedUrls = new Map<string, { readonly at: number; readonly url: string }>();
72
73 // Both media hosts are served by github.com's account, which is the host `gh` stores it under.
74 // Read on every fetch, so media loads as soon as the user signs in.
37 - const token = Effect.suspend(() => credentials.get("github.com")).pipe(
38 - Effect.map((credential) => credential.token),
75 + const credential = Effect.suspend(() => credentials.get("github.com")).pipe(
76 Effect.orElseSucceed(() => null),
77 );
78
42 - return Effect.fn("GitHubMediaFetch.fetchMedia")(function* (request: SourceControlMediaRequest) {
43 - const bearer = yield* token;
44 - let target = request.url;
79 + const fetchFollowingRedirects = Effect.fnUntraced(function* (
80 + url: string,
81 + headers: Readonly<Record<string, string>>,
82 + token: Redacted.Redacted<string> | null,
83 + ) {
84 + let target = url;
85 for (let hop = 0; ; hop += 1) {
86 const authorization =
47 - bearer !== null && isCredentialedHost(target) ? `Bearer ${Redacted.value(bearer)}` : null;
87 + token !== null && isCredentialedHost(target) ? `Bearer ${Redacted.value(token)}` : null;
88 const response: HttpClientResponse.HttpClientResponse = yield* httpClient
89 .execute(
90 HttpClientRequest.get(target).pipe(
91 HttpClientRequest.setHeaders({
52 - ...request.headers,
92 + ...headers,
93 // The bytes are streamed straight through, so never let an encoding layer in.
94 "accept-encoding": "identity",
95 ...(authorization === null ? {} : { authorization }),
96 }),
97 ),
98 )
59 - .pipe(Effect.provideService(FetchHttpClient.RequestInit, MANUAL_REDIRECT));
99 + .pipe(
100 + Effect.provideService(FetchHttpClient.RequestInit, MANUAL_REDIRECT),
101 + // A signed URL's query string is a bearer capability; keep it out of tracing spans.
102 + Effect.provideService(HttpClient.TracerDisabledWhen, () => true),
103 + );
104 const location = response.headers.location;
105 if (response.status < 300 || response.status >= 400) return response;
106 if (!location || hop >= MAX_REDIRECTS) return null;
63 - const next = new URL(location, target);
64 - if (next.protocol !== "https:") return null;
107 + const next = URL.parse(location, target);
108 + if (next === null || next.protocol !== "https:" || next.username || next.password) {
109 + return null;
110 + }
111 target = next.toString();
112 }
113 });
114 +
115 + // An organization with SAML SSO answers a token-authenticated upload request with its sign-in
116 + // page. Rendering the link as markdown in the repository's context hands back a signed URL.
117 + const renderSignedUrl = Effect.fnUntraced(function* (url: string, repository: string) {
118 + const rendered = yield* rest
119 + .rest({
120 + host: "github.com",
121 + operation: "renderMarkdown",
122 + method: "POST",
123 + path: "markdown",
124 + accept: "text/html",
125 + body: { text: `![](${url})`, mode: "gfm", context: repository },
126 + })
127 + .pipe(Effect.orElseSucceed(() => null));
128 + if (rendered === null || rendered.status !== 200 || rendered.truncated) return null;
129 + for (const match of rendered.body.matchAll(/<img\b[^>]*\ssrc\s*=\s*(["'])(.*?)\1/giu)) {
130 + const signed = URL.parse(match[2]?.replaceAll("&amp;", "&") ?? "");
131 + if (
132 + signed?.protocol === "https:" &&
133 + signed.hostname === "private-user-images.githubusercontent.com" &&
134 + signed.port === "" &&
135 + signed.username === "" &&
136 + signed.password === "" &&
137 + signed.searchParams.get("jwt")
138 + ) {
139 + return signed.toString();
140 + }
141 + }
142 + return null;
143 + });
144 +
145 + return Effect.fn("GitHubMediaFetch.fetchMedia")(function* (request: SourceControlMediaRequest) {
146 + const signedIn = yield* credential;
147 + const repository = signedIn === null ? undefined : uploadRepository(request);
148 + const cacheKey =
149 + signedIn === null || repository === undefined
150 + ? null
151 + : [signedIn.fingerprint, repository, request.url].map(encodeURIComponent).join("|");
152 + const now = yield* Clock.currentTimeMillis;
153 + const cached = cacheKey === null ? undefined : signedUrls.get(cacheKey);
154 + let response: HttpClientResponse.HttpClientResponse | null;
155 + if (cacheKey !== null && cached !== undefined && now - cached.at < SIGNED_URL_CACHE_TTL_MS) {
156 + response = yield* fetchFollowingRedirects(cached.url, request.headers, null);
157 + if (response === null || response.status >= 400) signedUrls.delete(cacheKey);
158 + // A signed URL can expire before its TTL; only then is a fresh one worth rendering.
159 + if (response?.status !== 403) return response;
160 + } else {
161 + if (cacheKey !== null) signedUrls.delete(cacheKey);
162 + response = yield* fetchFollowingRedirects(
163 + request.url,
164 + request.headers,
165 + signedIn?.token ?? null,
166 + );
167 + if (response === null || contentTypeOf(response) !== "text/html") return response;
168 + }
169 + if (cacheKey === null || repository === undefined || signedIn === null) return response;
170 + const signed = yield* renderSignedUrl(request.url, repository);
171 + if (signed === null) return response;
172 + const media = yield* fetchFollowingRedirects(signed, request.headers, null);
173 + if (
174 + (media?.status === 200 || media?.status === 206) &&
175 + MEDIA_CONTENT_TYPE_PATTERN.test(contentTypeOf(media))
176 + ) {
177 + // The render can run under another account if the user switched mid-request.
178 + const current = yield* credential;
179 + if (current?.fingerprint === signedIn.fingerprint) {
180 + if (signedUrls.size >= SIGNED_URL_CACHE_MAX_ENTRIES) {
181 + const oldest = signedUrls.keys().next().value;
182 + if (oldest !== undefined) signedUrls.delete(oldest);
183 + }
184 + signedUrls.set(cacheKey, { at: now, url: signed });
185 + }
186 + }
187 + return media;
188 + });
189 });