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("&", "&") : 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: ``, 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: ``, 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: ``, 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("&", "&") ?? "");
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
});