Add plain text response support for release and PR pages (#221)

* feat: add text/plain markdown responses for release and PR routes

Requests with an Accept: text/plain header to /release, /release/:version,
/release/compare/:from/:to, and /pr/:number now receive a pure markdown
representation of the page content instead of the HTML UI.

- Add wantsTextPlain/textPlainResponse helpers
- Extract groupReleaseNotes (raw markdown) from renderGroupedReleaseNotes
- Expose rawTitle/rawBody on cached PR details (cache key bumped to v2)

* fix: use load context to pass text/plain body through to entry server

Remix unwraps Response bodies from component-route loaders during
document requests instead of sending them directly. Work around this
by stashing the markdown body on the load context and short-circuiting
in handleRequest (which receives loadContext as its fifth argument)
before React renders.

* feat: respect HTTP(S)_PROXY env vars for outbound fetch calls

Use undici's EnvHttpProxyAgent as the global dispatcher when proxy
environment variables are set, so release data and GitHub API calls
work behind corporate proxies.

---------

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

Author: MarshallOfSound

app/data/github-data.ts

@@ -274,6 +274,7 @@ export const getPRDetails = memoize(
           backportOf = {
             number: parentPR.number,
             title: renderPRTitleMarkdownSafely(parentPR.title),
+            rawTitle: parentPR.title,
             author: parentPR.user?.login || 'Unknown User',
             authorAvatar: parentPR.user?.avatar_url || null,
             authorUrl: parentPR.user?.html_url || null,
@@ -290,7 +291,9 @@ export const getPRDetails = memoize(
       return {
         number: pr.number,
         title: renderPRTitleMarkdownSafely(pr.title),
+        rawTitle: pr.title,
         body: styleHtmlContent((pr as unknown as Record<string, string>).body_html),
+        rawBody: pr.body || '',
         url: pr.html_url,
         state: pr.state,
         createdAt: pr.created_at,
@@ -328,7 +331,7 @@ export const getPRDetails = memoize(
       return null;
     }
   },
-  getKeyvCache('github-pr-details'),
+  getKeyvCache('github-pr-details-v2'),
   {
     // Cache for 10 minutes
     ttl: 10 * 60 * 1_000,

app/data/markdown.ts

@@ -44,7 +44,7 @@ const knownSections = [
   'Unknown',
 ];
 
-export const renderGroupedReleaseNotes = (versions: { version: string; content: string }[]) => {
+export const groupReleaseNotes = (versions: { version: string; content: string }[]) => {
   const groups: Record<string, { version: string; content: string }[]> = Object.create(null);
   for (const key of knownSections) {
     groups[key] = [];
@@ -57,7 +57,7 @@ export const renderGroupedReleaseNotes = (versions: { version: string; content:
       groups[groupName] = groups[groupName] || [];
       groups[groupName].unshift({
         version,
-        content: DOMPurify.sanitize(noListMD.render(groupContent.trim())),
+        content: groupContent.trim(),
       });
     }
   }
@@ -70,3 +70,14 @@ export const renderGroupedReleaseNotes = (versions: { version: string; content:
 
   return groups;
 };
+
+export const renderGroupedReleaseNotes = (versions: { version: string; content: string }[]) => {
+  const groups = groupReleaseNotes(versions);
+  for (const key of Object.keys(groups)) {
+    groups[key] = groups[key].map(({ version, content }) => ({
+      version,
+      content: DOMPurify.sanitize(noListMD.render(content)),
+    }));
+  }
+  return groups;
+};

app/entry.server.tsx

@@ -1,20 +1,42 @@
 import { PassThrough } from 'node:stream';
 
-import type { ActionFunctionArgs, EntryContext, LoaderFunctionArgs } from '@remix-run/node';
+import type {
+  ActionFunctionArgs,
+  AppLoadContext,
+  EntryContext,
+  LoaderFunctionArgs,
+} from '@remix-run/node';
 import { createReadableStreamFromReadable } from '@remix-run/node';
 import { RemixServer } from '@remix-run/react';
 import { isbot } from 'isbot';
 import { renderToPipeableStream } from 'react-dom/server';
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 import { startDataRefreshTimer } from './data/fresh-interval';
 
+if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy) {
+  setGlobalDispatcher(new EnvHttpProxyAgent());
+}
+
 export const streamTimeout = 10_000;
 
 export default function handleRequest(
   request: Request,
   responseStatusCode: number,
   responseHeaders: Headers,
   remixContext: EntryContext,
+  loadContext: AppLoadContext,
 ) {
+  if (typeof loadContext.textPlainBody === 'string') {
+    responseHeaders.set('Content-Type', 'text/plain; charset=utf-8');
+    if (loadContext.cacheControl) {
+      responseHeaders.set('Cache-Control', loadContext.cacheControl as string);
+    }
+    return new Response(loadContext.textPlainBody, {
+      status: responseStatusCode,
+      headers: responseHeaders,
+    });
+  }
+
   return isbot(request.headers.get('user-agent') || '')
     ? handleBotRequest(request, responseStatusCode, responseHeaders, remixContext)
     : handleBrowserRequest(request, responseStatusCode, responseHeaders, remixContext);

app/helpers/request.ts

@@ -0,0 +1,22 @@
+import type { AppLoadContext, TypedResponse } from '@remix-run/node';
+
+export function wantsTextPlain(request: Request) {
+  const accept = request.headers.get('accept');
+  if (!accept) return false;
+  return accept
+    .split(',')
+    .map((type) => type.split(';')[0].trim())
+    .includes('text/plain');
+}
+
+export function textPlainResponse(
+  context: AppLoadContext,
+  body: string,
+  cacheControl: string,
+): TypedResponse<never> {
+  context.textPlainBody = body;
+  context.cacheControl = cacheControl;
+  // Remix will unwrap this into loader data, but entry.server.tsx
+  // short-circuits before rendering when textPlainBody is set.
+  return new Response(null, { status: 200 }) as TypedResponse<never>;
+}

app/routes/pr/details.tsx

@@ -20,6 +20,7 @@ import {
 import { PageHeader } from '~/components/PageHeader';
 import { SemverBlock } from '~/components/SemverBlock';
 import { NoBackports } from '~/components/NoBackports';
+import { textPlainResponse, wantsTextPlain } from '~/helpers/request';
 import { guessTimeZoneFromRequest } from '~/helpers/timezone';
 import { prettyDateString } from '~/helpers/time';
 
@@ -45,6 +46,57 @@ export const loader = async (args: LoaderFunctionArgs) => {
   }
 
   let pr = await getPRDetails(parseInt(number, 10));
+
+  if (wantsTextPlain(args.request)) {
+    if (!pr) {
+      return textPlainResponse(args.context, `# PR #${number}\n\nNot found.\n`, 'private, max-age=60');
+    }
+    const state = pr.merged ? 'merged' : pr.state;
+    const lines = [
+      `# PR #${pr.number}: ${pr.rawTitle}`,
+      '',
+      `- State: ${state}`,
+      `- Author: ${pr.author}`,
+      `- Created: ${pr.createdAt}`,
+    ];
+    if (pr.mergedAt) lines.push(`- Merged: ${pr.mergedAt}`);
+    lines.push(`- Target branch: ${pr.targetBranch}`);
+    if (pr.semver) lines.push(`- Semver impact: ${pr.semver}`);
+    if (pr.releasedIn) lines.push(`- Released in: v${pr.releasedIn}`);
+    lines.push(`- URL: ${pr.url}`, '');
+
+    if (pr.backportOf) {
+      const parentState = pr.backportOf.merged ? 'merged' : pr.backportOf.state;
+      lines.push(
+        '## Backport Of',
+        '',
+        `- PR: #${pr.backportOf.number}: ${pr.backportOf.rawTitle}`,
+        `- Author: ${pr.backportOf.author}`,
+        `- State: ${parentState}`,
+      );
+      if (pr.backportOf.mergedAt) lines.push(`- Merged: ${pr.backportOf.mergedAt}`);
+      lines.push(`- URL: ${pr.backportOf.url}`, '');
+    }
+
+    if (pr.backports) {
+      lines.push('## Backports', '');
+      if (pr.backports.length === 0) {
+        lines.push('No backports.', '');
+      } else {
+        lines.push('| Branch | State | PR | Released In |', '| --- | --- | --- | --- |');
+        for (const bp of pr.backports) {
+          const prRef = bp.backportPRNumber ? `#${bp.backportPRNumber}` : '';
+          const released = bp.releasedIn ? `v${bp.releasedIn}` : '';
+          lines.push(`| ${bp.targetBranch} | ${bp.state} | ${prRef} | ${released} |`);
+        }
+        lines.push('');
+      }
+    }
+
+    lines.push('## Description', '', pr.rawBody.trim(), '');
+    return textPlainResponse(args.context, lines.join('\n'), 'private, max-age=60');
+  }
+
   if (pr) {
     const timeZone = guessTimeZoneFromRequest(args.request);
 

app/routes/release/all.tsx

@@ -8,6 +8,7 @@ import { Pagination } from '~/components/Pagination';
 import { ReleaseTable } from '~/components/ReleaseTable';
 import { Select } from '~/components/Select';
 import { getReleasesOrUpdate } from '~/data/release-data';
+import { textPlainResponse, wantsTextPlain } from '~/helpers/request';
 import { guessTimeZoneFromRequest } from '~/helpers/timezone';
 
 export const meta: MetaFunction = () => {
@@ -75,6 +76,27 @@ export const loader = async (args: LoaderFunctionArgs) => {
     return redirect(`/release?channel=${encodeURIComponent(channel)}`);
   }
 
+  if (wantsTextPlain(args.request)) {
+    const channelName =
+      channel === 'stable' ? 'Stable' : channel === 'pre' ? 'Pre-release' : 'Nightly';
+    const majorSuffix = major !== null ? ` (v${major})` : '';
+    const lines = [
+      `# Electron Releases — ${channelName}${majorSuffix}`,
+      '',
+      `Page ${page} of ${Math.max(maxPage, 1)}`,
+      '',
+      '| Version | Date | Chromium | Node.js | V8 |',
+      '| --- | --- | --- | --- | --- |',
+    ];
+    for (const release of inChannel.slice(start, end)) {
+      lines.push(
+        `| v${release.version} | ${release.fullDate} | ${release.chrome} | ${release.node} | ${release.v8} |`,
+      );
+    }
+    lines.push('');
+    return textPlainResponse(args.context, lines.join('\n'), 'private, max-age=30');
+  }
+
   const timeZone = guessTimeZoneFromRequest(args.request);
 
   args.context.cacheControl = 'private, max-age=30';

app/routes/release/compare.tsx

@@ -18,7 +18,8 @@ import {
 } from '@icons-pack/react-simple-icons';
 import { getGitHubReleaseNotes } from '~/data/github-data';
 import { getAllVersionsInMajor, getReleaseForVersion, VersionFilter } from '~/data/release-data';
-import { renderGroupedReleaseNotes } from '~/data/markdown';
+import { groupReleaseNotes, renderGroupedReleaseNotes } from '~/data/markdown';
+import { textPlainResponse, wantsTextPlain } from '~/helpers/request';
 import { ArrowDown, ArrowRight } from 'lucide-react';
 import { VersionInfo } from '~/components/VersionInfo';
 import { useCallback } from 'react';
@@ -79,22 +80,50 @@ export const loader = async (args: LoaderFunctionArgs) => {
     return redirect('/release');
   }
 
-  const grouped = renderGroupedReleaseNotes(
-    versionsForNotes.map((version, i) => {
-      let releaseNotes = githubReleaseNotes[i]!;
-      const parsed = semverParse(version);
-      if (parsed?.prerelease.length) {
-        releaseNotes = releaseNotes?.split(new RegExp(`@${escapeRegExp(version)}\`?.`))[1];
+  const processedNotes = versionsForNotes.map((version, i) => {
+    let releaseNotes = githubReleaseNotes[i]!;
+    const parsed = semverParse(version);
+    if (parsed?.prerelease.length) {
+      releaseNotes = releaseNotes?.split(new RegExp(`@${escapeRegExp(version)}\`?.`))[1];
+    }
+    releaseNotes =
+      releaseNotes?.replace(/# Release Notes for [^\r\n]+(?:(?:\n)|(?:\r\n))/i, '') || 'Missing...';
+    return {
+      version,
+      content: releaseNotes,
+    };
+  });
+
+  if (wantsTextPlain(args.request)) {
+    const dep = (name: string, from: string, to: string) =>
+      from === to ? `- ${name}: ${from}` : `- ${name}: ${from} → ${to}`;
+    const lines = [
+      `# Electron Release Comparison: ${fromVersion} → ${toVersion}`,
+      '',
+      `${toVersion} includes changes from ${versionsBetween.length + 1} version${
+        versionsBetween.length ? 's' : ''
+      } since ${fromVersion}.`,
+      '',
+      '## Dependency Changes',
+      '',
+      dep('Chromium', fromElectronRelease.chrome, toElectronRelease.chrome),
+      dep('Node.js', fromElectronRelease.node, toElectronRelease.node),
+      dep('V8', fromElectronRelease.v8, toElectronRelease.v8),
+      '',
+      '## Combined Release Notes',
+      '',
+    ];
+    const rawGrouped = groupReleaseNotes(processedNotes);
+    for (const groupName of Object.keys(rawGrouped)) {
+      lines.push(`### ${groupName}`, '');
+      for (const { version, content } of rawGrouped[groupName]) {
+        lines.push(`#### v${version}`, '', content, '');
       }
-      releaseNotes =
-        releaseNotes?.replace(/# Release Notes for [^\r\n]+(?:(?:\n)|(?:\r\n))/i, '') ||
-        'Missing...';
-      return {
-        version,
-        content: releaseNotes,
-      };
-    }),
-  );
+    }
+    return textPlainResponse(args.context, lines.join('\n'), 'private, max-age=300');
+  }
+
+  const grouped = renderGroupedReleaseNotes(processedNotes);
 
   args.context.cacheControl = 'private, max-age=300';
 

app/routes/release/single.tsx

@@ -18,6 +18,7 @@ import {
   VersionFilter,
 } from '~/data/release-data';
 import { renderMarkdownSafely } from '~/data/markdown';
+import { textPlainResponse, wantsTextPlain } from '~/helpers/request';
 import { VersionInfo } from '~/components/VersionInfo';
 import { useCallback } from 'react';
 import { PageHeader } from '~/components/PageHeader';
@@ -66,6 +67,33 @@ export const loader = async (args: LoaderFunctionArgs) => {
   const isLatestStable = latestReleases.latestSupported[0]?.version === version.substr(1);
   const isLatestPreRelease = latestReleases.lastPreRelease?.version === version.substr(1);
 
+  if (wantsTextPlain(args.request)) {
+    const tags: string[] = [];
+    if (isLatestStable) tags.push('Latest Stable');
+    if (isLatestPreRelease) tags.push('Latest Pre Release');
+    const lines = [
+      `# Electron ${version}${tags.length ? ` (${tags.join(', ')})` : ''}`,
+      '',
+      '## Install',
+      '',
+      '```',
+      `npm install --save-dev electron@${version.substring(1)}`,
+      '```',
+      '',
+      '## Dependencies',
+      '',
+      `- Chromium: ${electronRelease.chrome}`,
+      `- Node.js: ${electronRelease.node}`,
+      `- V8: ${electronRelease.v8}`,
+      '',
+      '## Release Notes',
+      '',
+      releaseNotes.trim(),
+      '',
+    ];
+    return textPlainResponse(args.context, lines.join('\n'), 'private, max-age=300');
+  }
+
   args.context.cacheControl = 'private, max-age=300';
   return {
     allVersionsInMajor,

package.json

@@ -36,7 +36,8 @@
     "markdown-it": "^14.1.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "semver": "^7.7.1"
+    "semver": "^7.7.1",
+    "undici": "^6.24.1"
   },
   "devDependencies": {
     "@eslint/compat": "^1.2.8",

yarn.lock

@@ -9207,6 +9207,7 @@ __metadata:
     semver: "npm:^7.7.1"
     tailwindcss: "npm:^3.4.4"
     typescript: "npm:^5.1.6"
+    undici: "npm:^6.24.1"
     vite: "npm:^7.3.1"
     vite-tsconfig-paths: "npm:^4.2.1"
     vitest: "npm:^3.1.2"
@@ -10676,7 +10677,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"undici@npm:^6.21.2":
+"undici@npm:^6.21.2, undici@npm:^6.24.1":
   version: 6.24.1
   resolution: "undici@npm:6.24.1"
   checksum: 10c0/53fdbaa357139a2c12deed34f67d67fc6ad269630ba85a1507e7717f53ad2d3a02c95fbd17d3ab321e34c60b6f0a716cdc2f7e2eca1e07178702dc89cc3a73c4