Fix GitHub authorization redirect handling in workerd [skip ci]

Author: jinwandalaohu66

README.md

@@ -146,3 +146,14 @@ The registered [PythonIDE MCP GitHub App](https://github.com/apps/pythonide-mcp)
 `edge/github-oauth.js` validates fixed code/refresh grants and the resulting GitHub identity. A private service binding named `GITHUB_MCP_RATE_LIMIT` targets `pythonide-mcp-auth-limiter`, whose configuration is `edge/wrangler.github-oauth-rate-limit.json`. That service has no public route and receives only a digest for native rate admission. The configured 120 requests/60 seconds applies approximately per Cloudflare location; it is not a strict worldwide quota. No account/content/billing database bindings are added.
 
 Deploy the private limiter first, configure the Pages production service binding, then deploy this complete Pages candidate. Run `node --test edge/tests/*.test.js tests/*.test.js` before publishing. The native App is released separately.
+
+
+### Workers runtime gate
+
+Node tests alone do not verify workerd compatibility. Run the mandatory isolated runtime check with the Miniflare shipped by pinned Wrangler 4.127.1 (Miniflare 5.20260828.0-alpha):
+
+```sh
+PYTHONIDE_MINIFLARE_MODULE=/path/to/wrangler/node_modules/miniflare node --test edge/runtime-tests/github-oauth-workerd.test.js
+```
+
+This executes the production broker and private limiter modules in workerd, uses fake GitHub responses with no external network calls, verifies redirect rejection, and checks actual native rate admission. The gate never silently skips. Workers uses `redirect: "manual"` plus an explicit 3xx rejection; `redirect: "error"` is not supported by workerd.

edge/github-oauth-rate-limit.js

@@ -17,7 +17,7 @@ async function checkGitHubOAuthRateLimit(request, binding) {
   const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(`pythonide-github:${ip}`));
   const key = [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, '0')).join('');
   const response = await binding.fetch(new Request(SERVICE_URL, {
-    method: 'POST', headers: { 'X-PythonIDE-Limit-Key': `github-mcp:${key}` }, redirect: 'error',
+    method: 'POST', headers: { 'X-PythonIDE-Limit-Key': `github-mcp:${key}` }, redirect: 'manual',
   }));
   if (response.status === 429) return 'limited';
   return response.status === 204;

edge/github-oauth.js

@@ -61,7 +61,9 @@ async function upstreamJSON(fetcher, url, options) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 10_000);
   try {
-    const response = await fetcher(url, { ...options, redirect: 'error', signal: controller.signal });
+    // Workers rejects redirect:"error" during Request construction. Manual
+    // mode plus an explicit 3xx rejection preserves the same security policy.
+    const response = await fetcher(url, { ...options, redirect: 'manual', signal: controller.signal });
     if (response.status >= 300 && response.status < 400) throw new Error('upstream_redirect');
     const body = await readJSON(response, MAX_BYTES);
     return { status: response.status, body };

edge/runtime-tests/github-oauth-workerd.test.js

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+// Run with Wrangler's bundled Miniflare, or an installed compatible Miniflare.
+// Never skip: this gate must execute in workerd, not Node's fetch polyfill.
+const require = createRequire(import.meta.url);
+const { Miniflare, convertV4MiniflareOptions } = require(process.env.PYTHONIDE_MINIFLARE_MODULE || 'miniflare');
+const runtime = (options) => new Miniflare(convertV4MiniflareOptions(options));
+const root = process.env.PYTHONIDE_WORKERD_SOURCE_ROOT
+  || fileURLToPath(new URL('../', import.meta.url));
+const modules = ['worker.js', 'github-oauth.js', 'github-oauth-rate-limit.js']
+  .map((name) => ({ type: 'ESModule', path: path.join(root, name) }));
+const origin = 'https://link.pythonide.xin';
+const headers = { 'Content-Type': 'application/json', 'CF-Connecting-IP': '192.0.2.25' };
+const grant = { grant_type: 'authorization_code', client_id: 'Iv1_fixture',
+  code: 'fixture-code', code_verifier: 'v'.repeat(43) };
+
+test('real workerd crosses the private binding and rejects upstream redirects', { timeout: 30_000 }, async () => {
+  let mode = 'success';
+  const calls = [];
+  const mf = runtime({
+    workers: [
+      { name: 'broker', modules, modulesRoot: root, compatibilityDate: '2026-08-16',
+        bindings: { GITHUB_MCP_CLIENT_ID: 'Iv1_fixture', GITHUB_MCP_CLIENT_SECRET: 'fixture-secret' },
+        serviceBindings: { GITHUB_MCP_RATE_LIMIT: 'limiter' },
+        outboundService: async (request) => {
+          calls.push(request.url);
+          if (request.url === 'https://github.com/login/oauth/access_token') {
+            const body = new URLSearchParams(await request.text());
+            assert.equal(body.get('client_secret'), 'fixture-secret');
+            if (mode === 'redirect') return new Response(null, { status: 302, headers: { Location: 'https://evil.example/token' } });
+            if (mode === 'invalid_code') return Response.json({ error: 'bad_verification_code' });
+            return Response.json({ access_token: 'ghu_fixture', token_type: 'bearer', expires_in: 28_800, refresh_token: 'ghr_fixture' });
+          }
+          assert.equal(request.url, 'https://api.github.com/user');
+          assert.equal(request.headers.get('Authorization'), 'Bearer ghu_fixture');
+          return Response.json({ id: 1234 });
+        } },
+      { name: 'limiter', modules: [modules[2]], modulesRoot: root, compatibilityDate: '2026-08-16',
+        ratelimits: { GITHUB_MCP_AUTH_LIMIT: { namespace_id: '1', simple: { limit: 120, period: 60 } } } },
+    ],
+  });
+  try {
+    const response = await mf.dispatchFetch(`${origin}/mcp-oauth/github/token`, {
+      method: 'POST', headers, body: JSON.stringify(grant),
+    });
+    assert.equal(response.status, 200, await response.clone().text());
+    assert.equal((await response.json()).account_id, '1234');
+    assert.deepEqual(calls, ['https://github.com/login/oauth/access_token', 'https://api.github.com/user']);
+    for (const nextMode of ['invalid_code', 'redirect']) {
+      mode = nextMode;
+      calls.length = 0;
+      const refused = await mf.dispatchFetch(`${origin}/mcp-oauth/github/token`, {
+        method: 'POST', headers, body: JSON.stringify(grant),
+      });
+      assert.equal(refused.status, nextMode === 'redirect' ? 502 : 400);
+      assert.deepEqual(calls, ['https://github.com/login/oauth/access_token']);
+    }
+  } finally { await mf.dispose(); }
+});
+
+test('real workerd enforces native admission before allowing further grants', { timeout: 30_000 }, async () => {
+  const mf = runtime({ modules: [modules[2]], modulesRoot: root, compatibilityDate: '2026-08-16',
+    ratelimits: { GITHUB_MCP_AUTH_LIMIT: { namespace_id: '2', simple: { limit: 2, period: 60 } } } });
+  try {
+    const statuses = [];
+    for (let index = 0; index < 3; index += 1) {
+      const response = await mf.dispatchFetch('https://pythonide-mcp-auth-limiter.internal/consume', {
+        method: 'POST', headers: { 'X-PythonIDE-Limit-Key': `github-mcp:${'a'.repeat(64)}` },
+      });
+      statuses.push(response.status);
+    }
+    assert.deepEqual(statuses, [204, 204, 429]);
+  } finally { await mf.dispose(); }
+});

edge/tests/github-oauth-rate-limit.test.js

@@ -12,6 +12,7 @@ test('private limiter receives only an IP digest, with no credentials or body',
   }), { fetch: async (request) => { captured = request; return new Response(null, { status: 204 }); } });
   assert.equal(decision, true);
   assert.equal(captured.url, serviceURL);
+  assert.equal(captured.redirect, 'manual');
   assert.match(captured.headers.get('X-PythonIDE-Limit-Key'), /^github-mcp:[0-9a-f]{64}$/);
   assert.equal(captured.headers.has('Authorization'), false);
   assert.equal(captured.headers.has('CF-Connecting-IP'), false);

edge/tests/github-oauth.test.js

@@ -33,7 +33,7 @@ test('code grant pins client, callback, PKCE, upstream and validates actual acco
   const calls = [];
   const fetcher = async (url, options) => {
     calls.push({ url, options });
-    assert.equal(options.redirect, 'error');
+    assert.equal(options.redirect, 'manual');
     if (calls.length === 1) {
       assert.equal(url, 'https://github.com/login/oauth/access_token');
       assert.equal(options.method, 'POST');