Merge pull request #58 from supabase-community/feat/edge-functions

feat: list and deploy edge functions

Author: gregnr

README.md

@@ -146,6 +146,11 @@ The following Supabase tools are available to the LLM:
 - `execute_sql`: Executes raw SQL in the database. LLMs should use this for regular queries that don't change the schema.
 - `get_logs`: Gets logs for a Supabase project by service type (api, postgres, edge functions, auth, storage, realtime). LLMs can use this to help with debugging and monitoring service performance.
 
+#### Edge Function Management
+
+- `list_edge_functions`: Lists all Edge Functions in a Supabase project.
+- `deploy_edge_function`: Deploys a new Edge Function to a Supabase project. LLMs can use this to deploy new functions or update existing ones.
+
 #### Project Configuration
 
 - `get_project_url`: Gets the API URL for a project.

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,129 @@
+import { codeBlock } from 'common-tags';
+import { fileURLToPath } from 'url';
+import { extractFiles } from './eszip.js';
+import {
+  assertSuccess,
+  type ManagementApiClient,
+} from './management-api/index.js';
+
+/**
+ * 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}/`;
+}
+
+export const edgeFunctionExample = codeBlock`
+  import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+
+  Deno.serve(async (req: Request) => {
+    const data = {
+      message: "Hello there!"
+    };
+    
+    return new Response(JSON.stringify(data), {
+      headers: {
+        'Content-Type': 'application/json',
+        'Connection': 'keep-alive'
+      }
+    });
+  });
+`;
+
+/**
+ * Fetches a full Edge Function from the Supabase Management API.
+
+ * - Includes both function metadata and the contents of each file.
+ * - Normalizes file paths to be relative to the project root.
+ */
+export async function getFullEdgeFunction(
+  managementApiClient: ManagementApiClient,
+  projectId: string,
+  functionSlug: string
+) {
+  const functionResponse = await managementApiClient.GET(
+    '/v1/projects/{ref}/functions/{function_slug}',
+    {
+      params: {
+        path: {
+          ref: projectId,
+          function_slug: functionSlug,
+        },
+      },
+    }
+  );
+
+  if (functionResponse.error) {
+    return {
+      data: undefined,
+      error: functionResponse.error as { message: string },
+    };
+  }
+
+  assertSuccess(functionResponse, 'Failed to fetch Edge Function');
+
+  const edgeFunction = functionResponse.data;
+
+  const deploymentId = getDeploymentId(
+    projectId,
+    edgeFunction.id,
+    edgeFunction.version
+  );
+
+  const pathPrefix = getPathPrefix(deploymentId);
+
+  const entrypoint_path = edgeFunction.entrypoint_path
+    ? fileURLToPath(edgeFunction.entrypoint_path).replace(pathPrefix, '')
+    : undefined;
+
+  const import_map_path = edgeFunction.import_map_path
+    ? fileURLToPath(edgeFunction.import_map_path).replace(pathPrefix, '')
+    : undefined;
+
+  const eszipResponse = await managementApiClient.GET(
+    '/v1/projects/{ref}/functions/{function_slug}/body',
+    {
+      params: {
+        path: {
+          ref: projectId,
+          function_slug: functionSlug,
+        },
+      },
+      parseAs: 'arrayBuffer',
+    }
+  );
+
+  assertSuccess(eszipResponse, 'Failed to fetch Edge Function eszip bundle');
+
+  const extractedFiles = await extractFiles(
+    new Uint8Array(eszipResponse.data),
+    pathPrefix
+  );
+
+  const files = await Promise.all(
+    extractedFiles.map(async (file) => ({
+      name: file.name,
+      content: await file.text(),
+    }))
+  );
+
+  const normalizedFunction = {
+    ...edgeFunction,
+    entrypoint_path,
+    import_map_path,
+    files,
+  };
+
+  return { data: normalizedFunction, error: undefined };
+}

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

@@ -0,0 +1,99 @@
+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() {
+    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);
+  }
+}