feat: add get_edge_function, condense list_edge_functions (#140)

* feat: add `get_edge_function` tool, omit body from `list_edge_functions`

* test: `get_edge_function` and `list_edge_functions`

* chore: biome formatting

* docs: `get_edge_function` readme description

* test: remove `.only`

Author: mattrossman

README.md

@@ -222,6 +222,7 @@ Enabled by default. Use `development` to target this group of tools with the [`-
 Enabled by default. Use `functions` to target this group of tools with the [`--features`](#feature-groups) option.
 
 - `list_edge_functions`: Lists all Edge Functions in a Supabase project.
+- `get_edge_function`: Retrieves file contents for an Edge Function 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.
 
 #### Branching (Experimental, requires a paid plan)

packages/mcp-server-supabase/src/platform/api-platform.ts

@@ -31,6 +31,7 @@ import {
   type DevelopmentOperations,
   type EdgeFunction,
   type EdgeFunctionsOperations,
+  type EdgeFunctionWithBody,
   type ExecuteSqlOptions,
   type GetLogsOptions,
   type ResetBranchOptions,
@@ -351,15 +352,35 @@ export function createSupabaseApiPlatform(
 
       assertSuccess(response, 'Failed to fetch Edge Functions');
 
-      // Fetch files for each Edge Function
-      return await Promise.all(
-        response.data.map(async (listedFunction) => {
-          return await functions.getEdgeFunction(
-            projectId,
-            listedFunction.slug
-          );
-        })
-      );
+      return response.data.map((edgeFunction) => {
+        const deploymentId = getDeploymentId(
+          projectId,
+          edgeFunction.id,
+          edgeFunction.version
+        );
+
+        const pathPrefix = getPathPrefix(deploymentId);
+
+        const entrypoint_path = edgeFunction.entrypoint_path
+          ? relative(
+              pathPrefix,
+              fileURLToPath(edgeFunction.entrypoint_path, { windows: false })
+            )
+          : undefined;
+
+        const import_map_path = edgeFunction.import_map_path
+          ? relative(
+              pathPrefix,
+              fileURLToPath(edgeFunction.import_map_path, { windows: false })
+            )
+          : undefined;
+
+        return {
+          ...edgeFunction,
+          entrypoint_path,
+          import_map_path,
+        };
+      });
     },
     async getEdgeFunction(projectId: string, functionSlug: string) {
       const functionResponse = await managementApiClient.GET(
@@ -440,7 +461,7 @@ export function createSupabaseApiPlatform(
         throw new Error('No data received from Edge Function body');
       }
 
-      const files: EdgeFunction['files'] = [];
+      const files: EdgeFunctionWithBody['files'] = [];
       const parts = parseMultipartStream(bodyResponse.data, { boundary });
 
       for await (const part of parts) {

packages/mcp-server-supabase/src/platform/types.ts

@@ -70,6 +70,9 @@ export const edgeFunctionSchema = z.object({
   import_map: z.boolean().optional(),
   import_map_path: z.string().optional(),
   entrypoint_path: z.string().optional(),
+});
+
+export const edgeFunctionWithBodySchema = edgeFunctionSchema.extend({
   files: z.array(
     z.object({
       name: z.string(),
@@ -134,6 +137,7 @@ export type Organization = z.infer<typeof organizationSchema>;
 export type Project = z.infer<typeof projectSchema>;
 export type Branch = z.infer<typeof branchSchema>;
 export type EdgeFunction = z.infer<typeof edgeFunctionSchema>;
+export type EdgeFunctionWithBody = z.infer<typeof edgeFunctionWithBodySchema>;
 
 export type CreateProjectOptions = z.infer<typeof createProjectOptionsSchema>;
 export type CreateBranchOptions = z.infer<typeof createBranchOptionsSchema>;
@@ -179,7 +183,7 @@ export type EdgeFunctionsOperations = {
   getEdgeFunction(
     projectId: string,
     functionSlug: string
-  ): Promise<EdgeFunction>;
+  ): Promise<EdgeFunctionWithBody>;
   deployEdgeFunction(
     projectId: string,
     options: DeployEdgeFunctionOptions

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

@@ -1221,16 +1221,77 @@ describe('tools', () => {
         updated_at: expect.stringMatching(
           /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/
         ),
-        files: [
-          {
-            name: 'index.ts',
-            content: indexContent,
-          },
-        ],
       },
     ]);
   });
 
+  test('get edge function', async () => {
+    const { callTool } = await setup();
+
+    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';
+
+    const indexContent = codeBlock`
+      Deno.serve(async (req: Request) => {
+        return new Response('Hello world!', { headers: { 'Content-Type': 'text/plain' } })
+      });
+    `;
+
+    const edgeFunction = await project.deployEdgeFunction(
+      {
+        name: 'hello-world',
+        entrypoint_path: 'index.ts',
+      },
+      [
+        new File([indexContent], 'index.ts', {
+          type: 'application/typescript',
+        }),
+      ]
+    );
+
+    const result = await callTool({
+      name: 'get_edge_function',
+      arguments: {
+        project_id: project.id,
+        function_slug: edgeFunction.slug,
+      },
+    });
+
+    expect(result).toEqual({
+      id: edgeFunction.id,
+      slug: edgeFunction.slug,
+      version: edgeFunction.version,
+      name: edgeFunction.name,
+      status: edgeFunction.status,
+      entrypoint_path: 'index.ts',
+      import_map_path: undefined,
+      import_map: false,
+      verify_jwt: true,
+      created_at: expect.stringMatching(
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/
+      ),
+      updated_at: expect.stringMatching(
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/
+      ),
+      files: [
+        {
+          name: 'index.ts',
+          content: indexContent,
+        },
+      ],
+    });
+  });
+
   test('deploy new edge function', async () => {
     const { callTool } = await setup();
 
@@ -2145,7 +2206,11 @@ describe('feature groups', () => {
     const { tools } = await client.listTools();
     const toolNames = tools.map((tool) => tool.name);
 
-    expect(toolNames).toEqual(['list_edge_functions', 'deploy_edge_function']);
+    expect(toolNames).toEqual([
+      'list_edge_functions',
+      'get_edge_function',
+      'deploy_edge_function',
+    ]);
   });
 
   test('branching tools', async () => {

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

@@ -25,6 +25,18 @@ export function getEdgeFunctionTools({
         return await functions.listEdgeFunctions(project_id);
       },
     }),
+    get_edge_function: injectableTool({
+      description:
+        'Retrieves file contents for an Edge Function in a Supabase project.',
+      parameters: z.object({
+        project_id: z.string(),
+        function_slug: z.string(),
+      }),
+      inject: { project_id },
+      execute: async ({ project_id, function_slug }) => {
+        return await functions.getEdgeFunction(project_id, function_slug);
+      },
+    }),
     deploy_edge_function: injectableTool({
       description: `Deploys an Edge Function to a Supabase project. If the function already exists, this will create a new version. Example:\n\n${edgeFunctionExample}`,
       parameters: z.object({

packages/mcp-server-supabase/test/e2e/functions.e2e.ts

@@ -1,26 +1,26 @@
 /// <reference types="../extensions.d.ts" />
 
-import { generateText, type ToolCallUnion, type ToolSet } from "ai";
-import { codeBlock } from "common-tags";
-import { describe, expect, test } from "vitest";
-import { createOrganization, createProject } from "../mocks.js";
-import { join } from "node:path/posix";
-import { getTestModel, setup } from "./utils.js";
-
-describe("edge function e2e tests", () => {
-  test("deploys an edge function", async () => {
+import { generateText, type ToolCallUnion, type ToolSet } from 'ai';
+import { codeBlock } from 'common-tags';
+import { describe, expect, test } from 'vitest';
+import { createOrganization, createProject } from '../mocks.js';
+import { join } from 'node:path/posix';
+import { getTestModel, setup } from './utils.js';
+
+describe('edge function e2e tests', () => {
+  test('deploys an edge function', async () => {
     const { client } = await setup();
     const model = getTestModel();
 
     const org = await createOrganization({
-      name: "My Org",
-      plan: "free",
-      allowed_release_channels: ["ga"],
+      name: 'My Org',
+      plan: 'free',
+      allowed_release_channels: ['ga'],
     });
 
     const project = await createProject({
-      name: "todos-app",
-      region: "us-east-1",
+      name: 'todos-app',
+      region: 'us-east-1',
       organization_id: org.id,
     });
 
@@ -32,12 +32,12 @@ describe("edge function e2e tests", () => {
       tools,
       messages: [
         {
-          role: "system",
+          role: 'system',
           content:
-            "You are a coding assistant. The current working directory is /home/user/projects/todos-app.",
+            'You are a coding assistant. The current working directory is /home/user/projects/todos-app.',
         },
         {
-          role: "user",
+          role: 'user',
           content: `Deploy an edge function to project with ref ${project.id} that returns the current time in UTC.`,
         },
       ],
@@ -48,27 +48,27 @@ describe("edge function e2e tests", () => {
     });
 
     expect(toolCalls).toContainEqual(
-      expect.objectContaining({ toolName: "deploy_edge_function" }),
+      expect.objectContaining({ toolName: 'deploy_edge_function' })
     );
 
     await expect(text).toMatchCriteria(
-      "Confirms the successful deployment of an edge function that will return the current time in UTC. It describes steps to test the function.",
+      'Confirms the successful deployment of an edge function that will return the current time in UTC. It describes steps to test the function.'
     );
   });
 
-  test("modifies an edge function", async () => {
+  test('modifies an edge function', async () => {
     const { client } = await setup();
     const model = getTestModel();
 
     const org = await createOrganization({
-      name: "My Org",
-      plan: "free",
-      allowed_release_channels: ["ga"],
+      name: 'My Org',
+      plan: 'free',
+      allowed_release_channels: ['ga'],
     });
 
     const project = await createProject({
-      name: "todos-app",
-      region: "us-east-1",
+      name: 'todos-app',
+      region: 'us-east-1',
       organization_id: org.id,
     });
 
@@ -80,14 +80,14 @@ describe("edge function e2e tests", () => {
 
     const edgeFunction = await project.deployEdgeFunction(
       {
-        name: "hello-world",
-        entrypoint_path: "index.ts",
+        name: 'hello-world',
+        entrypoint_path: 'index.ts',
       },
       [
-        new File([code], "index.ts", {
-          type: "application/typescript",
+        new File([code], 'index.ts', {
+          type: 'application/typescript',
         }),
-      ],
+      ]
     );
 
     const toolCalls: ToolCallUnion<ToolSet>[] = [];
@@ -98,36 +98,39 @@ describe("edge function e2e tests", () => {
       tools,
       messages: [
         {
-          role: "system",
+          role: 'system',
           content:
-            "You are a coding assistant. The current working directory is /home/user/projects/todos-app.",
+            'You are a coding assistant. The current working directory is /home/user/projects/todos-app.',
         },
         {
-          role: "user",
+          role: 'user',
           content: `Change my edge function (project id ${project.id}) to replace "world" with "Earth".`,
         },
       ],
-      maxSteps: 3,
+      maxSteps: 4,
       async onStepFinish({ toolCalls: tools }) {
         toolCalls.push(...tools);
       },
     });
 
-    expect(toolCalls).toHaveLength(2);
+    expect(toolCalls).toHaveLength(3);
     expect(toolCalls[0]).toEqual(
-      expect.objectContaining({ toolName: "list_edge_functions" }),
+      expect.objectContaining({ toolName: 'list_edge_functions' })
     );
     expect(toolCalls[1]).toEqual(
-      expect.objectContaining({ toolName: "deploy_edge_function" }),
+      expect.objectContaining({ toolName: 'get_edge_function' })
+    );
+    expect(toolCalls[2]).toEqual(
+      expect.objectContaining({ toolName: 'deploy_edge_function' })
     );
 
     await expect(text).toMatchCriteria(
-      "Confirms the successful modification of an Edge Function.",
+      'Confirms the successful modification of an Edge Function.'
     );
 
     expect(edgeFunction.files).toHaveLength(1);
     expect(edgeFunction.files[0].name).toBe(
-      join(edgeFunction.pathPrefix, "index.ts"),
+      join(edgeFunction.pathPrefix, 'index.ts')
     );
     await expect(edgeFunction.files[0].text()).resolves.toEqual(codeBlock`
       Deno.serve(async (req: Request) => {