authorgravatar for maria@kuuro.netmaria <maria@kuuro.net> 2026-09-16 18:08:41-03:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2026-09-16 18:08:41-03:00
log32e8b2584556c0c55ce0d1d8f72b506cb771d60d
treebd5ea61160ad8c1b7c4e9f13a3dab60e305242a9
parent384de0858d1f59ca2ad7c660544a5290fd9138cb
signature Signed by PGP key B5690EEEBB952194

fix(web): show private repository media in pull request tabs (#11706)

Co-authored-by: maria-rcks <254055478+maria-rcks@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

12 files changed, 615 insertions(+), 28 deletions(-)

apps/server/src/assets/AssetAccess.test.ts+111-5
......@@ -2,7 +2,7 @@
22import * as NodeServices from "@effect/platform-node/NodeServices";
33import * as NodeHttpPlatform from "@effect/platform-node/NodeHttpPlatform";
44import * as NodeFSP from "node:fs/promises";
5import { AssetPreviewTypeValidationError, ThreadId } from "@t3tools/contracts";
5import { AssetAccessError, AssetPreviewTypeValidationError, ThreadId } from "@t3tools/contracts";
66import { PROJECT_FAVICON_FALLBACK_MARKER } from "@t3tools/shared/projectFavicon";
77import { describe, expect, it } from "@effect/vitest";
88import * as Crypto from "effect/Crypto";
......@@ -11,8 +11,10 @@ import * as FileSystem from "effect/FileSystem";
1111import * as Layer from "effect/Layer";
1212import * as Path from "effect/Path";
1313import * as PlatformError from "effect/PlatformError";
14import * as Schema from "effect/Schema";
1415import * as TestClock from "effect/testing/TestClock";
15import { HttpServerResponse } from "effect/unstable/http";
16import { HttpClient, HttpClientResponse, HttpServerResponse } from "effect/unstable/http";
17import { ChildProcessSpawner } from "effect/unstable/process";
1618import { vi } from "vite-plus/test";
1719
1820import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
......@@ -25,6 +27,8 @@ import { ASSET_ROUTE_PREFIX, issueAssetUrl, resolveAsset } from "./AssetAccess.t
2527import * as NativeAppIconResolver from "./NativeAppIconResolver.ts";
2628import { openMediaFile } from "./MediaFile.ts";
2729import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
30import * as GitHubCli from "../sourceControl/GitHubCli.ts";
31import { githubMediaResponse } from "./GitHubMediaFetch.ts";
2832
2933vi.mock("node:fs/promises", async (importOriginal) => {
3034 const actual = await importOriginal<typeof NodeFSP>();
......@@ -47,6 +51,52 @@ const testLayer = Layer.mergeAll(
4751).pipe(Layer.provideMerge(NodeServices.layer));
4852
4953describe("AssetAccess", () => {
54 it.effect("loads private media immediately after login and reuses the found credential", () => {
55 let lookups = 0;
56 const authorizations: Array<string | undefined> = [];
57 return Effect.gen(function* () {
58 const asset = {
59 url: "https://raw.githubusercontent.com/owner/repo/main/shot.png",
60 cwd: "/repo",
61 expiresAt: Number.MAX_SAFE_INTEGER,
62 };
63 expect((yield* githubMediaResponse(asset, {})).status).toBe(404);
64 expect((yield* githubMediaResponse(asset, {})).status).toBe(200);
65 expect((yield* githubMediaResponse(asset, {})).status).toBe(200);
66 expect(lookups).toBe(2);
67 expect(authorizations).toEqual([undefined, "Bearer signed-in", "Bearer signed-in"]);
68 }).pipe(
69 Effect.provide(
70 Layer.mock(GitHubCli.GitHubCli)({
71 execute: () =>
72 Effect.sync(() => ({
73 exitCode: ChildProcessSpawner.ExitCode(0),
74 stdout: ++lookups === 1 ? "" : "signed-in",
75 stderr: "",
76 stdoutTruncated: false,
77 stderrTruncated: false,
78 })),
79 }),
80 ),
81 Effect.provideService(
82 HttpClient.HttpClient,
83 HttpClient.make((request) => {
84 authorizations.push(request.headers.authorization);
85 return Effect.succeed(
86 HttpClientResponse.fromWeb(
87 request,
88 new Response(null, {
89 status: request.headers.authorization ? 200 : 404,
90 headers: { "content-type": "image/png" },
91 }),
92 ),
93 );
94 }),
95 ),
96 Effect.scoped,
97 );
98 });
99
50100 it.effect("issues exact URLs for media and browser documents outside the workspace", () =>
51101 Effect.gen(function* () {
52102 const fs = yield* FileSystem.FileSystem;
......@@ -228,7 +278,7 @@ describe("AssetAccess", () => {
228278 suffix.slice(0, separator),
229279 suffix.slice(separator + 1),
230280 );
231 if (!asset) throw new Error("Expected a resolved media file");
281 if (asset?.kind !== "file") throw new Error("Expected a resolved media file");
232282
233283 yield* fs.rename(filePath, savedPath);
234284 yield* fs.symlink(secretPath, filePath);
......@@ -391,7 +441,7 @@ describe("AssetAccess", () => {
391441 const name = suffix.slice(separator + 1);
392442 yield* fs.writeFileString(filePath, "in-place edit");
393443 const edited = yield* resolveAsset(token, name);
394 if (!edited) throw new Error("Expected the edited media file");
444 if (edited?.kind !== "file") throw new Error("Expected the edited media file");
395445 const editedResponse = HttpServerResponse.toWeb(yield* assetFileResponse(edited));
396446 expect(yield* Effect.promise(() => editedResponse.text())).toBe("in-place edit");
397447
......@@ -407,7 +457,7 @@ describe("AssetAccess", () => {
407457 renewedSuffix.slice(0, renewedSeparator),
408458 renewedSuffix.slice(renewedSeparator + 1),
409459 );
410 if (!renewedAsset) throw new Error("Expected the replacement media file");
460 if (renewedAsset?.kind !== "file") throw new Error("Expected the replacement media file");
411461 const renewedResponse = HttpServerResponse.toWeb(yield* assetFileResponse(renewedAsset));
412462 expect(yield* Effect.promise(() => renewedResponse.text())).toBe("replacement");
413463 yield* fs.remove(filePath);
......@@ -1062,4 +1112,60 @@ describe("AssetAccess", () => {
10621112 expect(error.cause).toBe(resolutionCause);
10631113 }).pipe(Effect.provide(testLayer)),
10641114 );
1115
1116 it.effect("serves GitHub-hosted pull request media through the repository's credential", () =>
1117 Effect.gen(function* () {
1118 const resolve = (relativeUrl: string) => {
1119 const suffix = relativeUrl.slice(`${ASSET_ROUTE_PREFIX}/`.length);
1120 const separator = suffix.indexOf("/");
1121 return resolveAsset(suffix.slice(0, separator), suffix.slice(separator + 1));
1122 };
1123 const issue = (url: string) =>
1124 issueAssetUrl({ resource: { _tag: "github-media", cwd: "/repo", url } });
1125
1126 const attachment = yield* issue(
1127 "https://github.com/user-attachments/assets/1a1842fb-6383-492f-873c-57aa0033fa6c",
1128 );
1129 expect(attachment.relativeUrl.endsWith("/1a1842fb-6383-492f-873c-57aa0033fa6c")).toBe(true);
1130 expect(yield* resolve(attachment.relativeUrl)).toEqual({
1131 kind: "github-media",
1132 url: "https://github.com/user-attachments/assets/1a1842fb-6383-492f-873c-57aa0033fa6c",
1133 cwd: "/repo",
1134 // The signed URL's own expiry, which is how long a client may keep the bytes.
1135 expiresAt: attachment.expiresAt,
1136 });
1137
1138 // A `blob` link addresses the page; only the raw host answers a credential with bytes.
1139 const committed = yield* issue("https://github.com/owner/repo/blob/main/docs/shot.png");
1140 expect(yield* resolve(committed.relativeUrl)).toMatchObject({
1141 url: "https://raw.githubusercontent.com/owner/repo/main/docs/shot.png",
1142 });
1143
1144 // The pre-`user-attachments` form, Git LFS bytes, and a name no `decodeURIComponent`
1145 // accepts all arrive from real bodies.
1146 const legacy = yield* issue("https://github.com/owner/repo/assets/45952064/1a1842fb");
1147 expect(yield* resolve(legacy.relativeUrl)).toMatchObject({
1148 url: "https://github.com/owner/repo/assets/45952064/1a1842fb",
1149 });
1150 const lfs = yield* issue("https://media.githubusercontent.com/media/owner/repo/main/a.mp4");
1151 expect(yield* resolve(lfs.relativeUrl)).toMatchObject({
1152 url: "https://media.githubusercontent.com/media/owner/repo/main/a.mp4",
1153 });
1154 const awkward = yield* issue("https://raw.githubusercontent.com/o/r/main/100%.png");
1155 expect(awkward.relativeUrl.endsWith("/100%25.png")).toBe(true);
1156
1157 for (const url of [
1158 "https://example.com/shot.png",
1159 "https://example.com/shot.png?token=private-media-token",
1160 "http://github.com/user-attachments/assets/1a1842fb",
1161 "https://github.com/owner/repo/pull/1",
1162 "https://github.com/owner/repo/blob/main/",
1163 ]) {
1164 const error = yield* issue(url).pipe(Effect.flip);
1165 expect(error._tag).toBe("AssetGitHubMediaUrlValidationError");
1166 const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(AssetAccessError))(error);
1167 expect(encoded).not.toContain(url);
1168 }
1169 }).pipe(Effect.provide(testLayer)),
1170 );
10651171});
apps/server/src/assets/AssetAccess.ts+51-8
......@@ -1,6 +1,7 @@
11import type { AssetResource } from "@t3tools/contracts";
22import {
33 AssetAttachmentNotFoundError,
4 AssetGitHubMediaUrlValidationError,
45 AssetPreviewTypeValidationError,
56 AssetProjectFaviconInspectionError,
67 AssetProjectFaviconNotFoundError,
......@@ -27,6 +28,7 @@ import {
2728 readImageDimensions,
2829 type ImageDimensions,
2930} from "@t3tools/shared/imageDimensions";
31import { githubMediaFetchUrl, githubMediaFileName } from "@t3tools/shared/githubMedia";
3032import { PROJECT_FAVICON_FALLBACK_MARKER } from "@t3tools/shared/projectFavicon";
3133import * as Clock from "effect/Clock";
3234import * as Crypto from "effect/Crypto";
......@@ -135,6 +137,14 @@ const AssetClaimsSchema = Schema.Union([
135137 app: ToolActivityNativeAppReference,
136138 expiresAt: Schema.Number,
137139 }),
140 Schema.Struct({
141 version: Schema.Literal(1),
142 kind: Schema.Literal("github-media"),
143 /** Already narrowed to a GitHub media host at mint time; the signature is what keeps it there. */
144 url: Schema.String,
145 cwd: Schema.String,
146 expiresAt: Schema.Number,
147 }),
138148]);
139149type AssetClaims = typeof AssetClaimsSchema.Type;
140150
......@@ -142,14 +152,23 @@ const AssetClaimsJson = Schema.fromJsonString(AssetClaimsSchema);
142152const decodeAssetClaims = Schema.decodeUnknownOption(AssetClaimsJson);
143153const encodeAssetClaims = Schema.encodeSync(AssetClaimsJson);
144154
145export type ResolvedAsset = {
146 readonly kind: "file";
147 readonly path: string;
148 readonly download?: boolean;
149 readonly fileName?: string;
150 readonly mimeType?: string;
151 readonly file?: OpenMediaFile;
152};
155export type ResolvedAsset =
156 | {
157 readonly kind: "file";
158 readonly path: string;
159 readonly download?: boolean;
160 readonly fileName?: string;
161 readonly mimeType?: string;
162 readonly file?: OpenMediaFile;
163 }
164 | {
165 readonly kind: "github-media";
166 readonly url: string;
167 readonly cwd: string;
168 /** When the signed URL that granted this stops working, which bounds how long a client
169 may keep the bytes it fetched with it. */
170 readonly expiresAt: number;
171 };
153172
154173function decodeClaims(encodedPayload: string): AssetClaims | null {
155174 try {
......@@ -657,6 +676,21 @@ export const issueAssetUrl = Effect.fn("AssetAccess.issueAssetUrl")(function* (i
657676 fileName = "native-app-icon.png";
658677 break;
659678 }
679 case "github-media": {
680 const fetchUrl = githubMediaFetchUrl(input.resource.url);
681 if (fetchUrl === null) {
682 return yield* new AssetGitHubMediaUrlValidationError({});
683 }
684 claims = {
685 version: 1,
686 kind: "github-media",
687 url: fetchUrl,
688 cwd: input.resource.cwd,
689 expiresAt,
690 };
691 fileName = githubMediaFileName(fetchUrl);
692 break;
693 }
660694 }
661695
662696 const secretStore = yield* ServerSecretStore.ServerSecretStore;
......@@ -757,6 +791,15 @@ export const resolveAsset = Effect.fn("AssetAccess.resolveAsset")(function* (
757791 : null;
758792 }
759793
794 if (claims.kind === "github-media") {
795 return {
796 kind: "github-media",
797 url: claims.url,
798 cwd: claims.cwd,
799 expiresAt: claims.expiresAt,
800 } satisfies ResolvedAsset;
801 }
802
760803 if (claims.kind === "native-app-icon") {
761804 const nativeAppIconResolver = yield* NativeAppIconResolver.NativeAppIconResolver;
762805 const iconPath = yield* nativeAppIconResolver.resolve(claims.app);
apps/server/src/assets/GitHubMediaFetch.ts created+196
......@@ -0,0 +1,196 @@
1import Mime from "@effect/platform-node/Mime";
2import { githubMediaFileName } from "@t3tools/shared/githubMedia";
3import * as Clock from "effect/Clock";
4import * as Effect from "effect/Effect";
5import * as Redacted from "effect/Redacted";
6import {
7 FetchHttpClient,
8 HttpClient,
9 HttpClientRequest,
10 HttpServerResponse,
11 type HttpClientResponse,
12} from "effect/unstable/http";
13
14import * as GitHubCli from "../sourceControl/GitHubCli.ts";
15
16/**
17 * Exactly the hosts the credential is for. Everything a redirect leads to — the presigned
18 * object stores GitHub hands assets off to — authorizes with its own signature, and some of
19 * them reject a request that also carries a bearer token.
20 */
21const CREDENTIALED_HOSTS = new Set([
22 "github.com",
23 "www.github.com",
24 "raw.githubusercontent.com",
25 "media.githubusercontent.com",
26]);
27const isCredentialedHost = (url: string) => {
28 try {
29 return CREDENTIALED_HOSTS.has(new URL(url).hostname.toLowerCase());
30 } catch {
31 return false;
32 }
33};
34
35/** GitHub answers an asset request with a 302 to a signed object URL that needs no credential. */
36const MAX_REDIRECTS = 3;
37/** Following the redirect here, rather than in `fetch`, is what keeps the token on GitHub. */
38const MANUAL_REDIRECT: RequestInit = { redirect: "manual" };
39const TOKEN_CACHE_TTL_MS = 5 * 60_000;
40const TOKEN_CACHE_MAX_ENTRIES = 32;
41/** Passed through so a seek in a long video costs one upstream range request, not a full download. */
42const FORWARDED_REQUEST_HEADERS = ["range", "if-range"] as const;
43const FORWARDED_RESPONSE_HEADERS = [
44 "content-type",
45 "content-length",
46 "content-range",
47 "accept-ranges",
48 "etag",
49 "last-modified",
50] as const;
51/** A pull request embeds pictures and recordings. Anything else is not served from our origin. */
52const MEDIA_CONTENT_TYPE_PATTERN = /^(?:image|video|audio)\/[\w!#$&^.+-]+$/i;
53const SVG_CONTENT_TYPE = "image/svg+xml";
54// An SVG is a document: same policy the asset route gives a workspace SVG, so one embedded in a
55// body cannot run script against this origin.
56const SVG_CONTENT_SECURITY_POLICY = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
57
58/**
59 * A media request per image and one per video seek, each of which would otherwise spawn `gh`.
60 * The token is what `gh auth token` would print again on the next call, and it is held no longer
61 * than a signed asset URL lives.
62 */
63const tokenCache = new Map<string, { readonly at: number; readonly token: Redacted.Redacted }>();
64
65const githubToken = Effect.fn("GitHubMediaFetch.githubToken")(function* (input: {
66 readonly cwd: string;
67 readonly host: string;
68}) {
69 // `gh` stores a token per host, not per repository, so the directory it runs in is not part
70 // of the answer and must not fragment the cache a client could otherwise churn. This route
71 // pins no credential; if it ever does, the pin belongs in this key.
72 const key = input.host;
73 const now = yield* Clock.currentTimeMillis;
74 const cached = tokenCache.get(key);
75 if (cached !== undefined && now - cached.at < TOKEN_CACHE_TTL_MS) return cached.token;
76 const github = yield* GitHubCli.GitHubCli;
77 // No credential is a normal state: a public asset still loads, and a private one fails the way
78 // it does in a browser that is not signed in.
79 const token = yield* github
80 .execute({
81 cwd: input.cwd,
82 args: ["auth", "token", "--hostname", input.host],
83 env: { GH_DEBUG: "" },
84 })
85 .pipe(
86 Effect.map((output) => output.stdout.trim()),
87 Effect.orElseSucceed(() => ""),
88 );
89 // A login or recovered CLI failure must take effect on the next media request.
90 if (token.length === 0) return null;
91 if (tokenCache.size >= TOKEN_CACHE_MAX_ENTRIES) {
92 tokenCache.delete(tokenCache.keys().next().value!);
93 }
94 const redacted = Redacted.make(token);
95 tokenCache.set(key, { at: now, token: redacted });
96 return redacted;
97});
98
99/**
100 * Follows GitHub's redirect to the signed object itself, and never carries the credential off
101 * GitHub: the object URL authorizes with its own signature, and the store it lives in has no
102 * business seeing a token.
103 */
104const fetchFollowingRedirects = Effect.fn("GitHubMediaFetch.fetchFollowingRedirects")(function* (
105 url: string,
106 headers: Record<string, string>,
107 token: Redacted.Redacted | null,
108) {
109 const httpClient = HttpClient.withScope(yield* HttpClient.HttpClient);
110 let target = url;
111 for (let hop = 0; ; hop += 1) {
112 // The credential rides only on a request to GitHub itself. A redirect leads to a signed
113 // object URL that authorizes on its own, and the store it lives in has no business seeing
114 // a token — deciding that from the target, not from the hop count, is what makes it so.
115 const authorization =
116 token !== null && isCredentialedHost(target) ? `Bearer ${Redacted.value(token)}` : null;
117 const response: HttpClientResponse.HttpClientResponse = yield* httpClient
118 .execute(
119 HttpClientRequest.get(target).pipe(
120 HttpClientRequest.setHeaders({
121 ...headers,
122 // The bytes are streamed straight through, so never let an encoding layer in.
123 "accept-encoding": "identity",
124 ...(authorization === null ? {} : { authorization }),
125 }),
126 ),
127 )
128 .pipe(Effect.provideService(FetchHttpClient.RequestInit, MANUAL_REDIRECT));
129 const location = response.headers.location;
130 if (response.status < 300 || response.status >= 400) return response;
131 // A chain this long is not GitHub answering with bytes, and its body is not the media.
132 if (!location || hop >= MAX_REDIRECTS) return null;
133 const next = new URL(location, target);
134 if (next.protocol !== "https:") return null;
135 target = next.toString();
136 }
137});
138
139/**
140 * Serves media a pull request body points at on GitHub through the `gh` credential, which is the
141 * only thing that distinguishes a readable private attachment from a 404.
142 */
143export const githubMediaResponse = Effect.fn("GitHubMediaFetch.githubMediaResponse")(function* (
144 asset: { readonly url: string; readonly cwd: string; readonly expiresAt: number },
145 requestHeaders: Record<string, string | undefined>,
146) {
147 // Both media hosts are served by github.com's account, which is the host `gh` stores it under.
148 const token = yield* githubToken({ cwd: asset.cwd, host: "github.com" });
149 const forwarded: Record<string, string> = {};
150 for (const name of FORWARDED_REQUEST_HEADERS) {
151 const value = requestHeaders[name];
152 if (value !== undefined) forwarded[name] = value;
153 }
154 const response = yield* fetchFollowingRedirects(asset.url, forwarded, token);
155 // An upload GitHub hosts never changes under its URL, so the only thing a cached copy must
156 // not outlive is the signed URL that granted it — which is the same bound the URL itself has.
157 const remainingSeconds = Math.floor((asset.expiresAt - (yield* Clock.currentTimeMillis)) / 1000);
158 const headers: Record<string, string> = {
159 "cache-control":
160 remainingSeconds > 0 ? `private, max-age=${remainingSeconds}` : "private, no-store",
161 "x-content-type-options": "nosniff",
162 };
163 if (response === null) return HttpServerResponse.empty({ status: 502, headers });
164 // An upstream refusal is the client's answer, not this server's fault; only a broken hop is.
165 // It carries none of the upstream entity headers: a `content-length` with no body behind it
166 // holds the connection open until the browser gives up on it.
167 if (response.status >= 400) {
168 return HttpServerResponse.empty({
169 status: response.status >= 500 ? 502 : response.status,
170 headers,
171 });
172 }
173 // Only pictures and recordings leave this origin, and never on GitHub's word alone: the raw
174 // host labels every committed binary `application/octet-stream`, so the name decides those.
175 const upstreamType =
176 response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
177 const contentType = MEDIA_CONTENT_TYPE_PATTERN.test(upstreamType)
178 ? upstreamType
179 : (Mime.getType(githubMediaFileName(asset.url))?.toLowerCase() ?? "");
180 if (!MEDIA_CONTENT_TYPE_PATTERN.test(contentType)) {
181 return HttpServerResponse.empty({ status: 415, headers });
182 }
183 for (const name of FORWARDED_RESPONSE_HEADERS) {
184 const value = response.headers[name];
185 if (value !== undefined) headers[name] = value;
186 }
187 headers["content-type"] = contentType;
188 if (contentType === SVG_CONTENT_TYPE) {
189 headers["content-security-policy"] = SVG_CONTENT_SECURITY_POLICY;
190 }
191 return HttpServerResponse.stream(response.stream, {
192 status: response.status,
193 headers,
194 contentType,
195 });
196});
apps/server/src/http.ts+14
......@@ -29,6 +29,7 @@ import { OtlpTracer, OtlpSerialization } from "effect/unstable/observability";
2929
3030import * as ServerConfig from "./config.ts";
3131import { ASSET_ROUTE_PREFIX, resolveAsset } from "./assets/AssetAccess.ts";
32import { githubMediaResponse } from "./assets/GitHubMediaFetch.ts";
3233import { statMediaFile, streamMediaFile, type OpenMediaFile } from "./assets/MediaFile.ts";
3334import {
3435 ATTACHMENT_UPLOAD_ROUTE_PREFIX,
......@@ -391,6 +392,19 @@ export const assetRouteLayer = HttpRouter.add(
391392 if (!asset) {
392393 return HttpServerResponse.text("Not Found", { status: 404 });
393394 }
395 if (asset.kind === "github-media") {
396 return yield* githubMediaResponse(asset, request.headers).pipe(
397 Effect.tapError((cause) =>
398 Effect.logWarning("Failed to fetch GitHub media.", { url: asset.url, cause }),
399 ),
400 Effect.orElseSucceed(() =>
401 HttpServerResponse.empty({
402 status: 502,
403 headers: { "cache-control": "private, no-store", "x-content-type-options": "nosniff" },
404 }),
405 ),
406 );
407 }
394408 return yield* assetFileResponse(
395409 asset,
396410 request.method === "GET" ? request.headers.range : undefined,
apps/server/src/server.test.ts+2-1
......@@ -169,6 +169,7 @@ import * as VcsDriver from "./vcs/VcsDriver.ts";
169169import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts";
170170import * as VcsDriverRegistry from "./vcs/VcsDriverRegistry.ts";
171171import * as VcsProvisioningService from "./vcs/VcsProvisioningService.ts";
172import * as GitHubCli from "./sourceControl/GitHubCli.ts";
172173import * as VcsProcess from "./vcs/VcsProcess.ts";
173174import * as GitWorkflowService from "./git/GitWorkflowService.ts";
174175import * as ReviewService from "./review/ReviewService.ts";
......@@ -1210,7 +1211,7 @@ const buildAppUnderTest = (options?: {
12101211 Layer.provideMerge(ServerSecretStore.layer),
12111212 Layer.provide(workspaceAndProjectServicesLayer),
12121213 Layer.provideMerge(FetchHttpClient.layer),
1213 Layer.provide(VcsProcess.layer),
1214 Layer.provide(GitHubCli.layer.pipe(Layer.provideMerge(VcsProcess.layer))),
12141215 Layer.provide(layerConfig),
12151216 );
12161217
apps/server/src/server.ts+3-1
......@@ -485,8 +485,10 @@ const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(
485485 // Core Services
486486 Layer.provideMerge(ServerSettingsLayerLive),
487487 Layer.provideMerge(CheckpointingLayerLive),
488 // `GitHubCli` is the registry's own instance, exposed because the asset route fetches
489 // GitHub-hosted pull request media with the repository's credential.
488490 Layer.provideMerge(
489 Layer.mergeAll(SourceControlProviderRegistryLayerLive, PullRequestServiceLive),
491 Layer.mergeAll(SourceControlProviderRegistryLayerLive, PullRequestServiceLive, GitHubCli.layer),
490492 ),
491493 Layer.provideMerge(GitLayerLive),
492494 Layer.provideMerge(VcsLayerLive),
apps/server/src/ws.ts+2
......@@ -3083,6 +3083,8 @@ const makeWsRpcLayer = (
30833083 if (
30843084 input.resource._tag === "attachment" ||
30853085 input.resource._tag === "native-app-icon" ||
3086 // GitHub media names the repository it authenticates through itself.
3087 input.resource._tag === "github-media" ||
30863088 (input.resource._tag === "media-file" && path.isAbsolute(input.resource.path))
30873089 ) {
30883090 return yield* issueAssetUrl({ resource: input.resource });
apps/web/src/components/ChatMarkdown.tsx+88-12
......@@ -34,6 +34,7 @@ import type {
3434 ThreadPullRequestKey,
3535} from "@t3tools/contracts";
3636import { faviconUrlForOrigin } from "@t3tools/shared/favicon";
37import { githubMediaFetchUrl } from "@t3tools/shared/githubMedia";
3738import {
3839 isAtomCommandInterrupted,
3940 squashAtomCommandFailure,
......@@ -220,6 +221,9 @@ interface ChatMarkdownProps {
220221 extraRemarkPlugins?: NonNullable<ReactMarkdownOptions["remarkPlugins"]>;
221222 /** Renders a `t3-context://` link as a chip; without it the link shows its label as text. */
222223 renderContextReference?: ((reference: ChatMarkdownContextReference) => ReactNode) | undefined;
224 /** Loads GitHub-hosted media through `cwd`'s GitHub credential, which a private repository's
225 uploads need; without it those images and videos load unauthenticated and 404. */
226 githubMedia?: boolean | undefined;
223227 /** Levels added to each markdown heading in the accessibility tree so the
224228 text nests under the heading that introduces it, such as a chat message's
225229 author. Rendered tags and their styling are unchanged. */
......@@ -1573,7 +1577,7 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
15731577 readonly environmentId: EnvironmentId;
15741578 readonly resource: Extract<
15751579 AssetResource,
1576 { readonly _tag: "attachment" | "workspace-file" | "media-file" }
1580 { readonly _tag: "attachment" | "workspace-file" | "media-file" | "github-media" }
15771581 >;
15781582 readonly kind?: "image" | "video";
15791583 readonly alt: string;
......@@ -1584,6 +1588,18 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
15841588 /** Caps the box height in rem while keeping the image's ratio; 30 by default. */
15851589 readonly maxHeightRem?: number | undefined;
15861590 readonly style?: CSSProperties | undefined;
1591 readonly className?: string | undefined;
1592 /** Sanitized authored attributes (`id`, `align`, …) that fragment links and layout rely on. */
1593 readonly imageProps?:
1594 | Omit<ComponentProps<"img">, "src" | "alt" | "className" | "style">
1595 | undefined;
1596 /** Where the media also lives on the web, for the failure state's escape hatch. */
1597 readonly originalUrl?: string | undefined;
1598 /** The workspace media frame, on by default; off for media that keeps the author's own box. */
1599 readonly framed?: boolean | undefined;
1600 /** Loaded instead of the failure state when no URL can be signed, such as against a server
1601 too old to know this resource. Only safe when the client can reach it directly. */
1602 readonly fallbackSrc?: string | undefined;
15871603 readonly workspaceRoot?: string | undefined;
15881604 readonly onImageExpand?: ((preview: ExpandedImagePreview) => void) | undefined;
15891605}) {
......@@ -1596,9 +1612,19 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
15961612 : resource._tag === "workspace-file" && props.workspaceRoot
15971613 ? `${props.workspaceRoot.replace(/[\\/]+$/, "")}/${resource.path}`
15981614 : undefined;
1599 const reference = path ? mediaFileReference(path, props.workspaceRoot) : undefined;
1600 const relativePath = reference?.relativePath;
1601 const src = assetUrl._tag === "Success" ? assetUrl.url + (props.srcFragment ?? "") : null;
1615 const reference = path
1616 ? mediaFileReference(path, props.workspaceRoot)
1617 : props.originalUrl
1618 ? mediaUrlReference(props.originalUrl)
1619 : undefined;
1620 const relativePath = reference?.kind === "file" ? reference.relativePath : undefined;
1621 const fallbackSrc = assetUrl._tag === "Failure" ? props.fallbackSrc : undefined;
1622 const src =
1623 assetUrl._tag === "Success"
1624 ? assetUrl.url + (props.srcFragment ?? "")
1625 : fallbackSrc === undefined
1626 ? null
1627 : fallbackSrc + (props.srcFragment ?? "");
16021628 // The server reads the pixel size from the file header, so the slot can be
16031629 // the image's final box instead of a 16:9 guess. An authored size wins; a
16041630 // caller's height cap shrinks the box while keeping the ratio.
......@@ -1615,9 +1641,11 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
16151641 kind: props.kind ?? "image",
16161642 name: props.alt || (props.kind ?? "image"),
16171643 src,
1618 asset: { environmentId: props.environmentId, resource },
1644 ...(fallbackSrc === undefined
1645 ? { asset: { environmentId: props.environmentId, resource } }
1646 : {}),
16191647 ...(reference ? { reference } : {}),
1620 ...(relativePath && resource._tag !== "attachment"
1648 ...(relativePath && (resource._tag === "media-file" || resource._tag === "workspace-file")
16211649 ? {
16221650 onOpenFile: () =>
16231651 useRightPanelStore
......@@ -1634,9 +1662,10 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
16341662 return (
16351663 <ChatMarkdownVideo
16361664 src={src}
1637 sourceFailed={assetUrl._tag === "Failure"}
1665 sourceFailed={assetUrl._tag === "Failure" && fallbackSrc === undefined}
16381666 alt={props.alt}
16391667 copyMarkdown={props.copyMarkdown}
1668 originalUrl={props.originalUrl}
16401669 style={props.style}
16411670 mediaIdentity={JSON.stringify([props.environmentId, props.resource, props.srcFragment])}
16421671 onRetry={refreshAssetUrl}
......@@ -1649,13 +1678,18 @@ export const ChatMarkdownAssetImage = memo(function ChatMarkdownAssetImage(props
16491678 <ChatMarkdownImage
16501679 key={JSON.stringify([props.environmentId, props.resource, props.srcFragment])}
16511680 src={src}
1652 sourceFailed={assetUrl._tag === "Failure"}
1681 sourceFailed={assetUrl._tag === "Failure" && fallbackSrc === undefined}
16531682 alt={props.alt}
16541683 copyMarkdown={props.copyMarkdown}
16551684 standalone={props.standalone ?? true}
1656 className={CHAT_MARKDOWN_WORKSPACE_IMAGE_CLASS_NAME}
1685 className={cn(
1686 props.framed === false ? undefined : CHAT_MARKDOWN_WORKSPACE_IMAGE_CLASS_NAME,
1687 props.className,
1688 )}
16571689 style={style}
1690 imageProps={props.imageProps}
16581691 actionsSource={actionsSource}
1692 originalUrl={props.originalUrl}
16591693 onImageExpand={props.onImageExpand}
16601694 />
16611695 );
......@@ -2226,6 +2260,7 @@ function useChatMarkdownState({
22262260 onImageExpand,
22272261 renderContextReference,
22282262 headingLevelOffset = 0,
2263 githubMedia = false,
22292264}: ChatMarkdownProps) {
22302265 const { resolvedTheme } = useTheme();
22312266 const [localMediaPreview, setLocalMediaPreview] = useState<ExpandedImagePreview | null>(null);
......@@ -2623,6 +2658,7 @@ function useChatMarkdownState({
26232658 environmentId,
26242659 expandMedia,
26252660 fileLinkChip,
2661 githubMedia,
26262662 renderContextReference,
26272663 headingLevelOffset,
26282664 imageBaseDir,
......@@ -2652,6 +2688,7 @@ function useChatMarkdownState({
26522688 environmentId,
26532689 expandMedia,
26542690 fileLinkChip,
2691 githubMedia,
26552692 renderContextReference,
26562693 headingLevelOffset,
26572694 imageBaseDir,
......@@ -3081,9 +3118,15 @@ const CHAT_MARKDOWN_COMPONENTS = {
30813118 );
30823119 },
30833120 img: function MarkdownImage({ node, title, src, alt, ...props }) {
3084 const { expandMedia, cwd, imageBaseDir, threadRef, renderContextReference } = use(
3085 ChatMarkdownRendererContext,
3086 );
3121 const {
3122 expandMedia,
3123 cwd,
3124 environmentId,
3125 githubMedia,
3126 imageBaseDir,
3127 threadRef,
3128 renderContextReference,
3129 } = use(ChatMarkdownRendererContext);
30873130 const imageExpand = use(MarkdownLinkContext) ? undefined : expandMedia;
30883131 const contextReference = typeof src === "string" ? parseComposerContextHref(src) : null;
30893132 if (contextReference) {
......@@ -3109,6 +3152,39 @@ const CHAT_MARKDOWN_COMPONENTS = {
31093152 const authoredSizeStyle = authoredImageSizeStyle(width, height);
31103153 const imageSource = classifyMarkdownImageSource(classifiedSrc, imageBaseDir ?? cwd);
31113154 const kind = mediaKindFromPath(classifiedSrc) ?? "image";
3155 const directUri = imageSource._tag === "Direct" ? imageSource.uri : null;
3156 const githubMediaUrl =
3157 directUri === null ? null : githubMediaFetchUrl(resolveProtocolRelativeMediaUrl(directUri));
3158 if (
3159 githubMedia &&
3160 cwd !== undefined &&
3161 environmentId !== null &&
3162 directUri !== null &&
3163 githubMediaUrl !== null
3164 ) {
3165 return (
3166 <ChatMarkdownAssetImage
3167 environmentId={environmentId}
3168 resource={{ _tag: "github-media", cwd, url: githubMediaUrl }}
3169 alt={altText}
3170 kind={kind}
3171 copyMarkdown={copyMarkdown}
3172 standalone={standalone}
3173 className={className}
3174 style={authoredSizeStyle}
3175 imageProps={imageProps}
3176 srcFragment={markdownImageSourceFragment(classifiedSrc)}
3177 originalUrl={resolveProtocolRelativeMediaUrl(directUri)}
3178 // A pull request body draws its own boxes; keep the author's, not the workspace frame.
3179 framed={false}
3180 // A server too old to sign this resource, or one with no route to GitHub, still leaves
3181 // the public half of these working exactly as it did before. The canonical URL, not the
3182 // authored one: a `blob` link addresses the page, and only the raw host has the bytes.
3183 fallbackSrc={githubMediaUrl}
3184 onImageExpand={imageExpand}
3185 />
3186 );
3187 }
31123188 if (imageSource._tag === "Direct") {
31133189 const mediaSrc = resolveProtocolRelativeMediaUrl(imageSource.uri);
31143190 const originalUrl =
apps/web/src/components/pullRequest/PullRequestMarkdown.tsx+57-1
......@@ -1,8 +1,11 @@
11import { ExternalLinkIcon, PaperclipIcon } from "lucide-react";
2import type { EnvironmentId, ScopedThreadRef } from "@t3tools/contracts";
2import { markdownImageSourceFragment } from "@t3tools/client-runtime/markdown-images";
3import { githubMediaFetchUrl } from "@t3tools/shared/githubMedia";
4import type { AssetResource, EnvironmentId, ScopedThreadRef } from "@t3tools/contracts";
35import { createContext, useContext, useMemo } from "react";
46import type { Options as ReactMarkdownOptions } from "react-markdown";
57
8import { useAssetUrlRefresh, useAssetUrlState } from "~/assets/assetUrls";
69import { cn } from "~/lib/utils";
710import { PULL_REQUESTS_PANEL_REF } from "~/rightPanelStore";
811
......@@ -15,6 +18,46 @@ export const PullRequestMarkdownContext = createContext<{
1518 threadRef: ScopedThreadRef | null;
1619} | null>(null);
1720
21/**
22 * A video GitHub hosts for the repository. It plays through a signed asset URL the server
23 * fetches with the repository's GitHub credential, which is what a private repository's
24 * uploads need; the URL is re-signed on retry, so a stale one recovers without a reload.
25 */
26function PullRequestGitHubVideo({
27 environmentId,
28 cwd,
29 url,
30 fetchUrl,
31}: {
32 environmentId: EnvironmentId;
33 cwd: string;
34 /** What the body authored, which is what "Open original" should reach. */
35 url: string;
36 /** The canonical GitHub media URL: a `blob` link addresses the page, not the bytes. */
37 fetchUrl: string;
38}) {
39 const resource = useMemo<AssetResource>(
40 () => ({ _tag: "github-media", cwd, url: fetchUrl }),
41 [cwd, fetchUrl],
42 );
43 const assetUrl = useAssetUrlState(environmentId, resource);
44 const refreshAssetUrl = useAssetUrlRefresh(environmentId, resource);
45 // A server too old to sign this resource, or one with no route to GitHub, still leaves a
46 // public repository's video playing exactly as it did before.
47 const src =
48 assetUrl._tag === "Success" ? assetUrl.url : assetUrl._tag === "Failure" ? fetchUrl : null;
49 return (
50 <MediaVideoPlayer
51 src={src === null ? null : src + markdownImageSourceFragment(url)}
52 originalUrl={url}
53 label="Pull request video"
54 className="w-full"
55 videoClassName="rounded-lg border border-border/60"
56 onRetry={refreshAssetUrl}
57 />
58 );
59}
60
1861/** Renders PR uploads inline, with retry and an original link when video playback fails. */
1962export function PullRequestMarkdown({
2063 text,
......@@ -57,6 +100,19 @@ export function PullRequestMarkdown({
57100 pullRequestPanelRef={resolvedThreadRef ?? PULL_REQUESTS_PANEL_REF}
58101 environmentId={environmentId}
59102 extraRemarkPlugins={extraRemarkPlugins}
103 githubMedia
104 />
105 );
106 }
107 const githubMediaUrl = segment.media === "video" ? githubMediaFetchUrl(segment.url) : null;
108 if (githubMediaUrl !== null) {
109 return (
110 <PullRequestGitHubVideo
111 key={`${segment.id}:${segment.url}`}
112 environmentId={environmentId}
113 cwd={cwd}
114 url={segment.url}
115 fetchUrl={githubMediaUrl}
60116 />
61117 );
62118 }
packages/contracts/src/assets.ts+17
......@@ -50,6 +50,13 @@ export const AssetResource = Schema.Union([
5050 Schema.TaggedStruct("native-app-icon", {
5151 app: ToolActivityNativeAppReference,
5252 }),
53 // An upload a pull request body points at on GitHub. A private repository serves these only
54 // to a request that carries a credential, which the client has none of, so the server fetches
55 // them with the `gh` credential the repository at `cwd` authenticates with.
56 Schema.TaggedStruct("github-media", {
57 cwd: TrimmedNonEmptyString.check(Schema.isMaxLength(ASSET_PATH_MAX_LENGTH)),
58 url: TrimmedNonEmptyString.check(Schema.isMaxLength(2048)),
59 }),
5360]);
5461export type AssetResource = typeof AssetResource.Type;
5562
......@@ -285,6 +292,15 @@ export class AssetSigningKeyLoadError extends Schema.TaggedError<AssetSigningKey
285292 }
286293}
287294
295export class AssetGitHubMediaUrlValidationError extends Schema.TaggedError<AssetGitHubMediaUrlValidationError>()(
296 "AssetGitHubMediaUrlValidationError",
297 {},
298) {
299 override get message(): string {
300 return "Only media hosted by GitHub can be fetched with a GitHub credential.";
301 }
302}
303
288304export const AssetAccessError = Schema.Union([
289305 AssetWorkspaceContextNotFoundError,
290306 AssetWorkspaceContextResolutionError,
......@@ -298,6 +314,7 @@ export const AssetAccessError = Schema.Union([
298314 AssetProjectFaviconResolutionError,
299315 AssetProjectFaviconInspectionError,
300316 AssetProjectFaviconNotFoundError,
317 AssetGitHubMediaUrlValidationError,
301318 AssetSigningKeyLoadError,
302319]);
303320export type AssetAccessError = typeof AssetAccessError.Type;
packages/shared/package.json+4
......@@ -43,6 +43,10 @@
4343 "types": "./src/git.ts",
4444 "import": "./src/git.ts"
4545 },
46 "./githubMedia": {
47 "types": "./src/githubMedia.ts",
48 "import": "./src/githubMedia.ts"
49 },
4650 "./sourceControl": {
4751 "types": "./src/sourceControl.ts",
4852 "import": "./src/sourceControl.ts"
packages/shared/src/githubMedia.ts created+70
......@@ -0,0 +1,70 @@
1/**
2 * Media a pull request body points at on GitHub's own hosts. In a private repository GitHub
3 * answers an unauthenticated request for one with 404 — a screenshot dropped into a description
4 * becomes `github.com/user-attachments/assets/<id>`, and a file committed alongside the code
5 * becomes a `raw.githubusercontent.com` path — so the renderer, which carries no GitHub session,
6 * draws a broken image where the reviewer expects the evidence. The server can fetch these with
7 * the `gh` credential and hand the bytes back.
8 *
9 * Only hosts where a credential is what decides the answer belong here. `objects.githubusercontent.com`
10 * and the `private-user-images` links GitHub's own HTML carries are already signed and load on their
11 * own, and a token does nothing for them once that signature expires.
12 */
13
14const RAW_HOST = "raw.githubusercontent.com";
15/** Git LFS pointers resolve here, which is where an LFS-tracked screenshot's bytes live. */
16const LFS_HOST = "media.githubusercontent.com";
17const ATTACHMENT_PATH_PATTERN = /^\/user-attachments\/assets\/[\w-]+$/u;
18/** What GitHub wrote into a body before `user-attachments`; older descriptions still carry it. */
19const LEGACY_ATTACHMENT_PATH_PATTERN = /^\/[^/]+\/[^/]+\/assets\/\d+\/[\w-]+$/u;
20/** `blob` and `raw` both address file bytes; `raw` is the one the token is honoured on. */
21const REPOSITORY_FILE_PATTERN = /^\/([^/]+)\/([^/]+)\/(?:raw|blob)\/(.*[^/])$/u;
22
23/** Port, userinfo, and fragment say nothing about which bytes GitHub will serve. */
24function canonicalUrl(host: string, url: URL): string {
25 return `https://${host}${url.pathname}${url.search}`;
26}
27
28/**
29 * The URL to fetch with a GitHub credential for `source`, or null when the source is not
30 * GitHub-hosted media — those keep loading directly, exactly as they do today.
31 */
32export function githubMediaFetchUrl(source: string): string | null {
33 let url: URL;
34 try {
35 url = new URL(source);
36 } catch {
37 return null;
38 }
39 if (url.protocol !== "https:") return null;
40 const host = url.hostname.toLowerCase();
41 if (host === RAW_HOST || host === LFS_HOST) return canonicalUrl(host, url);
42 if (host !== "github.com" && host !== "www.github.com") return null;
43 if (
44 ATTACHMENT_PATH_PATTERN.test(url.pathname) ||
45 LEGACY_ATTACHMENT_PATH_PATTERN.test(url.pathname)
46 ) {
47 return `https://github.com${url.pathname}`;
48 }
49 const repositoryFile = REPOSITORY_FILE_PATTERN.exec(url.pathname);
50 // `?raw=true` is how the web UI spells "the bytes, not the page"; the raw host needs no query.
51 return repositoryFile
52 ? `https://${RAW_HOST}/${repositoryFile[1]}/${repositoryFile[2]}/${repositoryFile[3]}`
53 : null;
54}
55
56/**
57 * Last path segment, for the signed URL's display name. A percent sequence GitHub accepts but
58 * `decodeURIComponent` rejects is left encoded rather than failing the whole asset.
59 */
60export function githubMediaFileName(fetchUrl: string): string {
61 const segment = new URL(fetchUrl).pathname.split("/").pop() ?? "";
62 let decoded: string;
63 try {
64 decoded = decodeURIComponent(segment);
65 } catch {
66 decoded = segment;
67 }
68 const name = decoded.replace(/[\p{Cc}\\/]/gu, "");
69 return name.length > 0 ? name : "github-media";
70}