feat: list and deploy edge functions

Author: gregnr

package-lock.json

@@ -29,10 +29,11 @@
     }
   },
   "dependencies": {
+    "@deno/eszip": "^0.84.0",
     "@modelcontextprotocol/sdk": "^1.4.1",
     "@supabase/mcp-utils": "0.1.3",
     "common-tags": "^1.8.2",
-    "openapi-fetch": "^0.13.4",
+    "openapi-fetch": "^0.13.5",
     "zod": "^3.24.1"
   },
   "devDependencies": {

packages/mcp-server-supabase/package.json

@@ -0,0 +1,17 @@
+/**
+ * Gets the deployment ID for an Edge Function.
+ */
+export function getDeploymentId(
+  projectId: string,
+  functionId: string,
+  functionVersion: number
+): string {
+  return `${projectId}_${functionId}_${functionVersion}`;
+}
+
+/**
+ * Gets the path prefix applied to each file in an Edge Function.
+ */
+export function getPathPrefix(deploymentId: string) {
+  return `/tmp/user_fn_${deploymentId}/`;
+}

packages/mcp-server-supabase/src/edge-function.ts

@@ -0,0 +1,100 @@
+import { codeBlock } from 'common-tags';
+import { open, type FileHandle } from 'node:fs/promises';
+import { describe, expect, test } from 'vitest';
+import { bundleFiles, extractFiles } from './eszip.js';
+
+describe('eszip', () => {
+  test('extract files', async () => {
+    const helloContent = codeBlock`
+      export function hello(): string {
+        return 'Hello, world!';
+      }
+    `;
+    const helloFile = new File([helloContent], 'hello.ts', {
+      type: 'application/typescript',
+    });
+
+    const indexContent = codeBlock`
+      import { hello } from './hello.ts';
+
+      Deno.serve(async (req: Request) => {
+        return new Response(hello(), { headers: { 'Content-Type': 'text/plain' } })
+      });
+    `;
+    const indexFile = new File([indexContent], 'index.ts', {
+      type: 'application/typescript',
+    });
+
+    const eszip = await bundleFiles([indexFile, helloFile]);
+    const extractedFiles = await extractFiles(eszip);
+
+    expect(extractedFiles).toHaveLength(2);
+
+    const extractedIndexFile = extractedFiles.find(
+      (file) => file.name === 'index.ts'
+    );
+    const extractedHelloFile = extractedFiles.find(
+      (file) => file.name === 'hello.ts'
+    );
+
+    expect(extractedIndexFile).toBeDefined();
+    expect(extractedIndexFile!.type).toBe('application/typescript');
+    await expect(extractedIndexFile!.text()).resolves.toBe(indexContent);
+
+    expect(extractedHelloFile).toBeDefined();
+    expect(extractedHelloFile!.type).toBe('application/typescript');
+    await expect(extractedHelloFile!.text()).resolves.toBe(helloContent);
+  });
+});
+
+export class Source implements UnderlyingSource<Uint8Array> {
+  type = 'bytes' as const;
+  autoAllocateChunkSize = 1024;
+
+  path: string | URL;
+  controller?: ReadableByteStreamController;
+  file?: FileHandle;
+
+  constructor(path: string | URL) {
+    this.path = path;
+  }
+
+  async start(controller: ReadableStreamController<Uint8Array>) {
+    if (!('byobRequest' in controller)) {
+      throw new Error('ReadableStreamController does not support byobRequest');
+    }
+
+    this.file = await open(this.path);
+    this.controller = controller;
+  }
+
+  async pull() {
+    console.log('Pulling data...');
+    if (!this.controller || !this.file) {
+      throw new Error('ReadableStream has not been started');
+    }
+
+    if (!this.controller.byobRequest) {
+      throw new Error('ReadableStreamController does not support byobRequest');
+    }
+
+    const view = this.controller.byobRequest.view as NodeJS.ArrayBufferView;
+
+    if (!view) {
+      throw new Error('ReadableStreamController does not have a view');
+    }
+
+    const { bytesRead } = await this.file.read({
+      buffer: view,
+      offset: view.byteOffset,
+      length: view.byteLength,
+    });
+
+    if (bytesRead === 0) {
+      await this.file.close();
+      this.controller.close();
+    }
+
+    this.controller.byobRequest.respond(view.byteLength);
+  }
+}

packages/mcp-server-supabase/src/eszip.test.ts

@@ -0,0 +1,108 @@
+import { build, Parser } from '@deno/eszip';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+
+const parser = await Parser.createInstance();
+const sourceMapSchema = z.object({
+  version: z.number(),
+  sources: z.array(z.string()),
+  sourcesContent: z.array(z.string()).optional(),
+  names: z.array(z.string()),
+  mappings: z.string(),
+});
+
+/**
+ * Extracts source files from an eszip archive.
+ *
+ * Optionally removes the given path prefix from file names.
+ *
+ * If a file contains a source map, it will return the
+ * original TypeScript source instead of the transpiled file.
+ */
+export async function extractFiles(
+  eszip: Uint8Array,
+  pathPrefix: string = '/'
+) {
+  let specifiers: string[] = [];
+
+  if (eszip instanceof ReadableStream) {
+    const reader = eszip.getReader({ mode: 'byob' });
+    specifiers = await parser.parse(reader);
+  } else {
+    specifiers = await parser.parseBytes(eszip);
+  }
+
+  await parser.load();
+
+  const fileSpecifiers = specifiers.filter((specifier) =>
+    specifier.startsWith('file://')
+  );
+
+  const files = await Promise.all(
+    fileSpecifiers.map(async (specifier) => {
+      const source: string = await parser.getModuleSource(specifier);
+      const sourceMapString: string =
+        await parser.getModuleSourceMap(specifier);
+
+      const filePath = relative(pathPrefix, fileURLToPath(specifier));
+
+      const file = new File([source], filePath, {
+        type: 'text/plain',
+      });
+
+      if (!sourceMapString) {
+        return file;
+      }
+
+      const sourceMap = sourceMapSchema.parse(JSON.parse(sourceMapString));
+
+      const [typeScriptSource] = sourceMap.sourcesContent ?? [];
+
+      if (!typeScriptSource) {
+        return file;
+      }
+
+      const sourceFile = new File([typeScriptSource], filePath, {
+        type: 'application/typescript',
+      });
+
+      return sourceFile;
+    })
+  );
+
+  return files;
+}
+
+/**
+ * Bundles files into an eszip archive.
+ *
+ * Optionally prefixes the file names with a given path.
+ */
+export async function bundleFiles(files: File[], pathPrefix: string = '/') {
+  const specifiers = files.map(
+    (file) => `file://${join(pathPrefix, file.name)}`
+  );
+  const eszip = await build(specifiers, async (specifier: string) => {
+    if (specifier.startsWith('file://')) {
+      const file = files.find(
+        (file) => `file://${join(pathPrefix, file.name)}` === specifier
+      );
+
+      if (!file) {
+        throw new Error(`File not found: ${specifier}`);
+      }
+
+      return {
+        kind: 'module',
+        specifier,
+        headers: {
+          'content-type': file.type,
+        },
+        content: await file.text(),
+      };
+    }
+  });
+
+  return eszip;
+}

packages/mcp-server-supabase/src/eszip.ts

@@ -19,7 +19,6 @@ export function createManagementApiClient(
   return createClient<paths>({
     baseUrl,
     headers: {
-      'Content-Type': 'application/json',
       Authorization: `Bearer ${accessToken}`,
       ...headers,
     },
@@ -53,7 +52,7 @@ export function assertSuccess<
   if ('error' in response) {
     if (response.response.status === 401) {
       throw new Error(
-        'Unauthorized. Please provide a valid access token to the MCP server via the --access-token flag.'
+        'Unauthorized. Please provide a valid access token to the MCP server via the --access-token flag or SUPABASE_ACCESS_TOKEN.'
       );
     }