Add registered GitHub MCP authorization and private rate admission [skip ci]

Author: jinwandalaohu66

README.md

@@ -137,3 +137,12 @@ Redirect URI: https://link.pythonide.xin/ai-oauth/callback
 On iOS 16.2–17.3, the callback page forwards the query losslessly to
 `pythonide://oauth/custom-ai`. Keep the AI and MCP paths separate even though
 they intentionally share the same visual treatment.
+
+
+## GitHub MCP authorization
+
+The registered [PythonIDE MCP GitHub App](https://github.com/apps/pythonide-mcp) is owned by Python-IDE. The Pages production environment holds `GITHUB_MCP_CLIENT_ID` and the encrypted `GITHUB_MCP_CLIENT_SECRET`; never commit a secret. The two broker endpoints are `/mcp-oauth/github/config` and `/mcp-oauth/github/token`. Existing static OAuth callbacks and share routes keep their original owners.
+
+`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.

edge/github-oauth-rate-limit.js

@@ -0,0 +1,38 @@
+// Pages has no native RateLimit binding. This private service is only the
+// compatibility boundary to Workers' native per-location rate limiter.
+// It receives a digest, never an IP address, token, code or client secret.
+const SERVICE_URL = 'https://pythonide-mcp-auth-limiter.internal/consume';
+
+function result(status) {
+  return new Response(null, { status, headers: {
+    'Cache-Control': 'no-store',
+    ...(status === 429 ? { 'Retry-After': '60' } : {}),
+  } });
+}
+
+async function checkGitHubOAuthRateLimit(request, binding) {
+  if (!binding?.fetch) return false;
+  const ip = request.headers.get('CF-Connecting-IP');
+  if (!ip || ip.length > 64 || !/^[0-9a-fA-F:.]+$/.test(ip)) return false;
+  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',
+  }));
+  if (response.status === 429) return 'limited';
+  return response.status === 204;
+}
+
+async function handleGitHubOAuthRateLimit(request, env) {
+  if (request.url !== SERVICE_URL || request.method !== 'POST') return result(404);
+  const key = request.headers.get('X-PythonIDE-Limit-Key') || '';
+  if (!/^github-mcp:[0-9a-f]{64}$/.test(key)) return result(400);
+  if (!env?.GITHUB_MCP_AUTH_LIMIT?.limit) return result(503);
+  try {
+    const { success } = await env.GITHUB_MCP_AUTH_LIMIT.limit({ key });
+    return result(success ? 204 : 429);
+  } catch { return result(503); }
+}
+
+export { checkGitHubOAuthRateLimit, handleGitHubOAuthRateLimit };
+export default { fetch: handleGitHubOAuthRateLimit };

edge/github-oauth.js

@@ -0,0 +1,161 @@
+import { checkGitHubOAuthRateLimit } from './github-oauth-rate-limit.js';
+
+// Dedicated GitHub App grant broker. No storage bindings, community sessions,
+// user content, billing permissions, or token/body logging are used here.
+const ORIGIN = 'https://link.pythonide.xin';
+const PREFIX = '/mcp-oauth/github';
+const CALLBACK = `${ORIGIN}/mcp-oauth/callback`;
+const TOKEN_ENDPOINT = 'https://github.com/login/oauth/access_token';
+const USER_ENDPOINT = 'https://api.github.com/user';
+const MAX_BYTES = 16_384;
+
+function jsonResponse(status, body, extraHeaders = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8',
+      'Cache-Control': 'no-store',
+      Pragma: 'no-cache',
+      'Referrer-Policy': 'no-referrer',
+      'X-Content-Type-Options': 'nosniff',
+      ...extraHeaders,
+    },
+  });
+}
+
+async function readJSON(message, limit) {
+  const length = message.headers.get('content-length');
+  if (length !== null && (!/^\d+$/.test(length) || Number(length) > limit)) throw new Error('invalid_body');
+  if (!message.body) throw new Error('invalid_body');
+  const reader = message.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > limit) throw new Error('invalid_body');
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  const result = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  if (!result || typeof result !== 'object' || Array.isArray(result)) throw new Error('invalid_body');
+  return result;
+}
+
+function credential(value) {
+  return typeof value === 'string' && /^[\x21-\x7e]{1,4096}$/.test(value);
+}
+
+function lifetime(value) {
+  return value === undefined || (Number.isFinite(value) && value > 0 && value <= 31_536_000);
+}
+
+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 });
+    if (response.status >= 300 && response.status < 400) throw new Error('upstream_redirect');
+    const body = await readJSON(response, MAX_BYTES);
+    return { status: response.status, body };
+  } finally { clearTimeout(timer); }
+}
+
+async function handleGitHubOAuth(request, env, fetcher = fetch) {
+  const url = new URL(request.url);
+  if (url.origin !== ORIGIN || url.search || ![`${PREFIX}/config`, `${PREFIX}/token`].includes(url.pathname)) {
+    return jsonResponse(404, { error: 'not_found' });
+  }
+  const isConfig = url.pathname.endsWith('/config');
+  if (request.method !== (isConfig ? 'GET' : 'POST')) {
+    return jsonResponse(405, { error: 'method_not_allowed' }, { Allow: isConfig ? 'GET' : 'POST' });
+  }
+  const clientID = env?.GITHUB_MCP_CLIENT_ID;
+  const clientSecret = env?.GITHUB_MCP_CLIENT_SECRET;
+  if (typeof clientID !== 'string' || !/^[A-Za-z0-9_]{1,128}$/.test(clientID)
+      || !credential(clientSecret) || !env?.GITHUB_MCP_RATE_LIMIT?.fetch) {
+    return jsonResponse(503, { error: 'oauth_not_configured' });
+  }
+  if (isConfig) return jsonResponse(200, { schema_version: 1, client_id: clientID });
+  if (!/^application\/json(?:\s*;|$)/i.test(request.headers.get('content-type') || '')) {
+    return jsonResponse(415, { error: 'invalid_request' });
+  }
+  let body;
+  try { body = await readJSON(request, 8_192); }
+  catch { return jsonResponse(400, { error: 'invalid_request' }); }
+  const isCode = body.grant_type === 'authorization_code';
+  const isRefresh = body.grant_type === 'refresh_token';
+  const allowed = new Set(isCode
+    ? ['grant_type', 'client_id', 'code', 'code_verifier']
+    : ['grant_type', 'client_id', 'refresh_token']);
+  if ((!isCode && !isRefresh) || body.client_id !== clientID
+      || Object.keys(body).some((key) => !allowed.has(key))
+      || (isCode && (!credential(body.code) || body.code.length > 1_024
+        || typeof body.code_verifier !== 'string' || !/^[A-Za-z0-9._~-]{43,128}$/.test(body.code_verifier)))
+      || (isRefresh && !credential(body.refresh_token))) {
+    return jsonResponse(400, { error: 'invalid_request' });
+  }
+  try {
+    const admission = await checkGitHubOAuthRateLimit(request, env.GITHUB_MCP_RATE_LIMIT);
+    if (admission === 'limited') return jsonResponse(429, { error: 'rate_limited' }, { 'Retry-After': '60' });
+    if (admission !== true) return jsonResponse(503, { error: 'authorization_unavailable' });
+  } catch { return jsonResponse(503, { error: 'authorization_unavailable' }); }
+  const parameters = new URLSearchParams({ client_id: clientID, client_secret: clientSecret });
+  if (isCode) {
+    parameters.set('code', body.code);
+    parameters.set('code_verifier', body.code_verifier);
+    parameters.set('redirect_uri', CALLBACK);
+  } else {
+    parameters.set('grant_type', 'refresh_token');
+    parameters.set('refresh_token', body.refresh_token);
+  }
+  try {
+    const result = await upstreamJSON(fetcher, TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: parameters.toString(),
+    });
+    if (['bad_verification_code', 'bad_refresh_token', 'expired_refresh_token', 'invalid_grant'].includes(result.body.error)) {
+      return jsonResponse(400, { error: 'reauthentication_required' });
+    }
+    const token = result.body;
+    if (result.status !== 200 || token.error || !credential(token.access_token)
+        || String(token.token_type).toLowerCase() !== 'bearer'
+        || !lifetime(token.expires_in)
+        || (token.refresh_token !== undefined && !credential(token.refresh_token))) {
+      return jsonResponse(502, { error: 'token_exchange_failed' });
+    }
+    // Validate the actual token's identity on every grant. Never trust an
+    // account name/ID supplied by the caller or echoed through the callback.
+    const identity = await upstreamJSON(fetcher, USER_ENDPOINT, {
+      headers: { Accept: 'application/vnd.github+json', Authorization: `Bearer ${token.access_token}`,
+        'User-Agent': 'PythonIDE-MCP-OAuth' },
+    });
+    const accountID = String(identity.body.id);
+    if (identity.status !== 200 || !/^[1-9][0-9]{0,19}$/.test(accountID)
+        || (typeof identity.body.id === 'number' && !Number.isSafeInteger(identity.body.id))) {
+      return jsonResponse(502, { error: 'identity_validation_failed' });
+    }
+    return jsonResponse(200, {
+      client_id: clientID,
+      access_token: token.access_token,
+      token_type: 'bearer',
+      ...(token.expires_in !== undefined ? { expires_in: token.expires_in } : {}),
+      ...(token.refresh_token !== undefined ? { refresh_token: token.refresh_token } : {}),
+      account_id: accountID,
+    });
+  } catch {
+    // Codes and rotating refresh tokens are never retried after an ambiguous
+    // upstream outcome. The client recovers with a fresh authorization.
+    return jsonResponse(502, { error: 'token_exchange_failed' });
+  }
+}
+
+export { handleGitHubOAuth };

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

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { checkGitHubOAuthRateLimit, handleGitHubOAuthRateLimit } from '../github-oauth-rate-limit.js';
+
+const serviceURL = 'https://pythonide-mcp-auth-limiter.internal/consume';
+const key = `github-mcp:${'a'.repeat(64)}`;
+
+test('private limiter receives only an IP digest, with no credentials or body', async () => {
+  let captured;
+  const decision = await checkGitHubOAuthRateLimit(new Request('https://link.pythonide.xin/mcp-oauth/github/token', {
+    method: 'POST', headers: { 'CF-Connecting-IP': '192.0.2.10', Authorization: 'must-not-forward' }, body: 'must-not-forward',
+  }), { fetch: async (request) => { captured = request; return new Response(null, { status: 204 }); } });
+  assert.equal(decision, true);
+  assert.equal(captured.url, serviceURL);
+  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);
+  assert.equal(await captured.text(), '');
+});
+
+test('limiter rejects unrelated routes, invalid keys, missing bindings and provider failures', async () => {
+  const request = (url = serviceURL, suppliedKey = key) => new Request(url, { method: 'POST', headers: { 'X-PythonIDE-Limit-Key': suppliedKey } });
+  assert.equal((await handleGitHubOAuthRateLimit(request('https://evil.example/consume'), {})).status, 404);
+  assert.equal((await handleGitHubOAuthRateLimit(request(serviceURL, 'raw-ip'), {})).status, 400);
+  assert.equal((await handleGitHubOAuthRateLimit(request(), {})).status, 503);
+  for (const success of [true, false]) {
+    const response = await handleGitHubOAuthRateLimit(request(), { GITHUB_MCP_AUTH_LIMIT: {
+      limit: async (input) => { assert.deepEqual(input, { key }); return { success }; },
+    } });
+    assert.equal(response.status, success ? 204 : 429);
+    if (!success) assert.equal(response.headers.get('Retry-After'), '60');
+  }
+  assert.equal((await handleGitHubOAuthRateLimit(request(), { GITHUB_MCP_AUTH_LIMIT: {
+    limit: async () => { throw new Error('no details should escape'); },
+  } })).status, 503);
+});