fix: address local HTTP review findings

Author: barryroodt

CONTRIBUTING.md

@@ -29,7 +29,7 @@ pnpm dev
 Then start the server with `--http`, which serves the build the same way `mcp.supabase.com` does:
 
 ```bash
-node packages/mcp-server-supabase/dist/cli.js --http --project-ref <your project ref>
+node dist/cli.js --http --project-ref <your project ref>
 ```
 
 It binds `127.0.0.1` only and prints a ready-to-paste `.mcp.json` snippet:

packages/mcp-server-supabase/src/transports/local-http-entry.test.ts

@@ -159,14 +159,30 @@ describe('startLocalHttpEntry', () => {
   test('rejects a foreign Host header and accepts loopback hosts', async () => {
     const { port } = new URL(entry.url);
     // node:http, because fetch forbids overriding the Host header.
+    const body = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2025-06-18',
+        capabilities: {},
+        clientInfo: { name: 'host-probe', version: '1.0.0' },
+      },
+    });
     const probe = (host: string) =>
       new Promise<{ status: number; body: string }>((resolve, reject) => {
         const req = httpRequest(
           {
             host: '127.0.0.1',
             port,
             path: '/mcp',
-            headers: { ...AUTH_HEADERS, host },
+            method: 'POST',
+            headers: {
+              ...AUTH_HEADERS,
+              accept: 'application/json, text/event-stream',
+              'content-type': 'application/json',
+              host,
+            },
           },
           (res) => {
             let body = '';
@@ -176,7 +192,7 @@ describe('startLocalHttpEntry', () => {
           }
         );
         req.on('error', reject);
-        req.end();
+        req.end(body);
       });
 
     const rejected = await probe('evil.example');
@@ -191,10 +207,16 @@ describe('startLocalHttpEntry', () => {
 
     for (const host of [`127.0.0.1:${port}`, `localhost:${port}`]) {
       const response = await probe(host);
-      // Past host validation, path, and auth: the SDK answers a bare GET.
-      expect(response.status).not.toBe(403);
-      expect(response.status).not.toBe(401);
-      expect(response.status).not.toBe(404);
+      expect(response.status).toBe(200);
+      const dataLine = response.body
+        .split('\n')
+        .find((line) => line.startsWith('data: '));
+      if (!dataLine) throw new Error('expected an SSE data line');
+      expect(JSON.parse(dataLine.slice('data: '.length))).toMatchObject({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { protocolVersion: expect.any(String) },
+      });
     }
   });
 

packages/mcp-server-supabase/src/transports/node-bridge.test.ts

@@ -87,6 +87,34 @@ describe('toNodeListener', () => {
     ]);
   });
 
+  test('rejects request bodies larger than 4 MiB before calling the handler', async () => {
+    let handled = false;
+    const { origin } = await listen(async () => {
+      handled = true;
+      return new Response();
+    });
+
+    const response = await new Promise<{ status: number; body: string }>(
+      (resolve, reject) => {
+        const req = httpRequest(origin, { method: 'POST' }, (res) => {
+          let body = '';
+          res.setEncoding('utf8');
+          res.on('data', (chunk) => (body += chunk));
+          res.on('end', () => resolve({ status: res.statusCode!, body }));
+        });
+        req.on('error', reject);
+        req.write(Buffer.alloc(4 * 1024 * 1024 + 1));
+        req.end(Buffer.alloc(1024 * 1024));
+      }
+    );
+
+    expect(response.status).toBe(413);
+    expect(JSON.parse(response.body)).toEqual({
+      error: 'payload too large',
+    });
+    expect(handled).toBe(false);
+  });
+
   test('aborts the signal when the client drops mid-request and keeps serving', async () => {
     const handling = deferred();
     const release = deferred();

packages/mcp-server-supabase/src/transports/node-bridge.ts

@@ -1,5 +1,7 @@
 import type { RequestListener } from 'node:http';
 
+const MAX_REQUEST_BODY_BYTES = 4 * 1024 * 1024;
+
 // Bridge from the SDK's fetch-shaped handler to node:http. Bodies are buffered
 // on both sides on purpose: under `legacy: 'stateless'` every response is
 // request-scoped, so a workstation entry gains nothing from streaming, and
@@ -24,7 +26,23 @@ export function toNodeListener(handle: FetchHandler): RequestListener {
   return async (req, res) => {
     try {
       const chunks: Buffer[] = [];
-      for await (const chunk of req) chunks.push(chunk as Buffer);
+      let bodyBytes = 0;
+      let bodyTooLarge = false;
+      for await (const chunk of req.iterator({ destroyOnReturn: false })) {
+        const buffer = chunk as Buffer;
+        bodyBytes += buffer.length;
+        if (bodyBytes > MAX_REQUEST_BODY_BYTES) {
+          bodyTooLarge = true;
+          break;
+        }
+        chunks.push(buffer);
+      }
+      if (bodyTooLarge) {
+        req.resume();
+        res.writeHead(413, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'payload too large' }));
+        return;
+      }
       const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined;
 
       const headers = new Headers();