feat: wire cost-confirmation elicitations into the --http entry

Author: barryroodt

CONTRIBUTING.md

@@ -46,7 +46,7 @@ It binds `127.0.0.1` only and prints a ready-to-paste `.mcp.json` snippet:
 }
 ```
 
-The access token comes from the client's `Authorization` header on each request (Claude Code expands `${SUPABASE_ACCESS_TOKEN}` at connect time). There is no token flag and no token environment variable on the server side. Legacy clients work against this entry but do not see elicitations. You may need to restart the server in your MCP client after each change.
+The access token comes from the client's `Authorization` header on each request (Claude Code expands `${SUPABASE_ACCESS_TOKEN}` at connect time). There is no token flag and no token environment variable on the server side. Modern form-capable clients (Claude Code with v2 negotiation) see cost confirmations for `create_project` and `create_branch` as elicitation dialogs; legacy clients keep the `get_cost` / `confirm_cost` flow. You may need to restart the server in your MCP client after each change.
 
 The entry takes a PAT in the Authorization header. OAuth is deferred: it needs resource-server and authorization-server wiring that this PR does not contain, and a 401 challenge would send Claude Code into OAuth discovery against localhost (see the PR for details).
 

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

@@ -1,17 +1,25 @@
 import { request as httpRequest } from 'node:http';
 import {
   Client,
+  isInputRequiredResult,
   StreamableHTTPClientTransport,
 } from '@modelcontextprotocol/client';
+import type {
+  CallToolResult,
+  InputRequiredResult,
+} from '@modelcontextprotocol/client';
 import { http, HttpResponse, passthrough } from 'msw';
 import type { SetupServer } from 'msw/node';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import {
   ACCESS_TOKEN,
   API_URL,
+  createOrganization,
+  createProject,
   MCP_CLIENT_NAME,
   MCP_CLIENT_VERSION,
+  mockBranches,
   setupMockApis,
 } from '../../test/mocks.js';
 import {
@@ -219,4 +227,121 @@ describe('startLocalHttpEntry', () => {
       releaseRequest.resolve();
     }
   });
+
+  describe('cost confirmation', () => {
+    let writable!: LocalHttpEntry;
+    let writableLogLines!: string[];
+
+    beforeEach(async () => {
+      writableLogLines = [];
+      writable = await startLocalHttpEntry({
+        port: 0,
+        apiUrl: API_URL,
+        features: ['account', 'branching'],
+        log: (line) => writableLogLines.push(line),
+      });
+      mockServer.use(
+        http.all(`${new URL(writable.url).origin}/*`, () => passthrough())
+      );
+      cleanups.push(() => writable.close());
+    });
+
+    async function connectWritable(
+      mode: 'legacy' | { pin: string },
+      capabilities: ConstructorParameters<typeof Client>[1] = {
+        capabilities: {},
+      }
+    ) {
+      const transport = new StreamableHTTPClientTransport(
+        new URL(writable.url),
+        { requestInit: { headers: AUTH_HEADERS } }
+      );
+      const client = new Client(
+        { name: MCP_CLIENT_NAME, version: MCP_CLIENT_VERSION },
+        { ...capabilities, versionNegotiation: { mode } }
+      );
+      await client.connect(transport);
+      cleanups.push(() => client.close());
+      return client;
+    }
+
+    async function createBranchingProject() {
+      const org = await createOrganization({
+        name: 'My Org',
+        plan: 'free',
+        allowed_release_channels: ['ga'],
+      });
+      const project = await createProject({
+        name: 'Project 1',
+        region: 'us-east-1',
+        organization_id: org.id,
+      });
+      project.status = 'ACTIVE_HEALTHY';
+      return project;
+    }
+
+    test('a modern form-capable client receives a create_branch cost elicitation', async () => {
+      const client = await connectWritable(
+        { pin: MODERN_PROTOCOL_VERSION },
+        {
+          capabilities: { elicitation: { form: {} } },
+          inputRequired: { autoFulfill: false },
+        }
+      );
+      const project = await createBranchingProject();
+
+      const result = (await client.request(
+        {
+          method: 'tools/call',
+          params: {
+            name: 'create_branch',
+            arguments: { project_id: project.id, name: 'feature' },
+          },
+        },
+        { allowInputRequired: true }
+      )) as CallToolResult | InputRequiredResult;
+
+      if (!isInputRequiredResult(result)) {
+        throw new Error('expected an input_required result');
+      }
+      expect(result.inputRequests?.confirm_cost).toMatchObject({
+        method: 'elicitation/create',
+        params: { mode: 'form' },
+      });
+      expect(result.requestState).toBeTruthy();
+      expect(mockBranches.size).toBe(0);
+      expect(writableLogLines.at(-1)).toBe(
+        `[mcp-http] modern ${MODERN_PROTOCOL_VERSION} client=${MCP_CLIENT_NAME}/${MCP_CLIENT_VERSION}`
+      );
+    });
+
+    test('a legacy client keeps the get_cost / confirm_cost flow', async () => {
+      const client = await connectWritable('legacy');
+      const project = await createBranchingProject();
+
+      const result = await client.callTool({
+        name: 'create_branch',
+        arguments: { project_id: project.id, name: 'feature' },
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toEqual([
+        {
+          type: 'text',
+          text: JSON.stringify({
+            error: {
+              name: 'Error',
+              message:
+                'Cost confirmation ID does not match the expected cost of creating a branch.',
+            },
+          }),
+        },
+      ]);
+      expect(mockBranches.size).toBe(0);
+      // Stateless legacy serving only sees the client name on `initialize`.
+      expect(writableLogLines.at(-1)).toMatch(
+        /^\[mcp-http\] legacy client=.* \(elicitations unavailable on the legacy path\)$/
+      );
+    });
+  });
 });

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

@@ -1,3 +1,4 @@
+import { createHash, randomBytes } from 'node:crypto';
 import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import {
@@ -99,6 +100,9 @@ export async function startLocalHttpEntry(
     log = console.error,
   } = options;
   const allowedHostnames = localhostAllowedHostnames();
+  // Signs the cost-confirmation request state for this process; a restart
+  // invalidates in-flight elicitations, which is the intended scope.
+  const requestStateKey = randomBytes(32);
 
   const server = createServer(
     toNodeListener(async (request, parsedBody) => {
@@ -127,7 +131,21 @@ export async function startLocalHttpEntry(
         parseFeatureGroups(platform, features);
       }
       const handler = createSupabaseMcpHandler(
-        { platform, projectId, readOnly, features, contentApiUrl },
+        {
+          platform,
+          projectId,
+          readOnly,
+          features,
+          contentApiUrl,
+          costConfirmation: {
+            requestStateKey,
+            // PAT mode can serve several clients with different PATs in one
+            // process, so the principal is the bearer's hash.
+            // #404 (--oauth) switches this to a per-process principal; the token refreshes, the principal must not.
+            principal: createHash('sha256').update(accessToken).digest('hex'),
+            enabledTools: ['create_project', 'create_branch'],
+          },
+        },
         { legacy: 'stateless', onerror: console.error }
       );
       request.signal.addEventListener('abort', () => handler.close(), {
@@ -171,6 +189,6 @@ export function formatBanner(url: string) {
     '    }',
     '  }',
     '}',
-    'Legacy (2025-era) clients are served without elicitations. Requests log their era on stderr.',
+    'Modern form-capable clients see cost confirmations as elicitations; legacy (2025-era) clients keep get_cost / confirm_cost. Requests log their era on stderr.',
   ].join('\n');
 }