Add skipPruneEdgeFunctions setting to control edge function pruning (#2228)

src/components/SupabaseIntegration.tsx

@@ -64,6 +64,17 @@ export function SupabaseIntegration() {
     }
   };
 
+  const handleSkipPruneSettingChange = async (enabled: boolean) => {
+    try {
+      await updateSettings({
+        skipPruneEdgeFunctions: enabled,
+      });
+      showSuccess("Setting updated");
+    } catch (err: any) {
+      showError(err.message || "Failed to update setting");
+    }
+  };
+
   if (!isConnected) {
     return null;
   }
@@ -146,6 +157,29 @@ export function SupabaseIntegration() {
           </div>
         </div>
       </div>
+
+      <div className="mt-4">
+        <div className="flex items-center space-x-3">
+          <Switch
+            id="skip-prune-edge-functions"
+            checked={!!settings?.skipPruneEdgeFunctions}
+            onCheckedChange={handleSkipPruneSettingChange}
+          />
+          <div className="space-y-1">
+            <Label
+              htmlFor="skip-prune-edge-functions"
+              className="text-sm font-medium"
+            >
+              Keep extra Supabase edge functions
+            </Label>
+            <p className="text-xs text-gray-500 dark:text-gray-400">
+              When disabled, edge functions deployed to Supabase but not present
+              in your codebase will be automatically deleted during sync
+              operations (e.g., after reverting or modifying shared modules).
+            </p>
+          </div>
+        </div>
+      </div>
     </div>
   );
 }

src/ipc/handlers/app_handlers.ts

@@ -1248,10 +1248,12 @@ export function registerAppHandlers() {
           logger.info(
             `Shared module ${filePath} modified, redeploying all Supabase functions`,
           );
+          const settings = readSettings();
           const deployErrors = await deployAllSupabaseFunctions({
             appPath,
             supabaseProjectId: app.supabaseProjectId,
             supabaseOrganizationSlug: app.supabaseOrganizationSlug ?? null,
+            skipPruneEdgeFunctions: settings.skipPruneEdgeFunctions ?? false,
           });
           if (deployErrors.length > 0) {
             return {

src/ipc/handlers/version_handlers.ts

@@ -11,6 +11,7 @@ import { createTypedHandler } from "./base";
 import { versionContracts } from "../types/version";
 
 import { deployAllSupabaseFunctions } from "../../supabase_admin/supabase_utils";
+import { readSettings } from "../../main/settings";
 import {
   gitCheckout,
   gitCommit,
@@ -333,10 +334,12 @@ export function registerVersionHandlers() {
           logger.info(
             `Re-deploying all Supabase edge functions for app ${appId} after revert`,
           );
+          const settings = readSettings();
           const deployErrors = await deployAllSupabaseFunctions({
             appPath,
             supabaseProjectId: app.supabaseProjectId,
             supabaseOrganizationSlug: app.supabaseOrganizationSlug ?? null,
+            skipPruneEdgeFunctions: settings.skipPruneEdgeFunctions ?? false,
           });
 
           if (deployErrors.length > 0) {

src/ipc/processors/response_processor.ts

@@ -487,11 +487,13 @@ export async function processFullResponseActions(
         logger.info(
           "Shared modules changed, redeploying all Supabase functions",
         );
+        const settings = readSettings();
         const deployErrors = await deployAllSupabaseFunctions({
           appPath,
           supabaseProjectId: chatWithApp.app.supabaseProjectId,
           supabaseOrganizationSlug:
             chatWithApp.app.supabaseOrganizationSlug ?? null,
+          skipPruneEdgeFunctions: settings.skipPruneEdgeFunctions ?? false,
         });
         if (deployErrors.length > 0) {
           for (const err of deployErrors) {

src/lib/schemas.ts

@@ -293,6 +293,7 @@ export const UserSettingsSchema = z
     selectedTemplateId: z.string(),
     selectedThemeId: z.string().optional(),
     enableSupabaseWriteSqlMigration: z.boolean().optional(),
+    skipPruneEdgeFunctions: z.boolean().optional(),
     selectedChatMode: ChatModeSchema.optional(),
     defaultChatMode: ChatModeSchema.optional(),
     acceptedCommunityCode: z.boolean().optional(),

src/pro/main/ipc/handlers/local_agent/processors/file_operations.ts

@@ -9,6 +9,7 @@ import {
   getGitUncommittedFiles,
 } from "@/ipc/utils/git_utils";
 import { deployAllSupabaseFunctions } from "../../../../../../supabase_admin/supabase_utils";
+import { readSettings } from "../../../../../../main/settings";
 import type { AgentContext } from "../tools/types";
 
 const logger = log.scope("file_operations");
@@ -37,10 +38,12 @@ export async function deployAllFunctionsIfNeeded(
 
   try {
     logger.info("Shared modules changed, redeploying all Supabase functions");
+    const settings = readSettings();
     const deployErrors = await deployAllSupabaseFunctions({
       appPath: ctx.appPath,
       supabaseProjectId: ctx.supabaseProjectId,
       supabaseOrganizationSlug: ctx.supabaseOrganizationSlug ?? null,
+      skipPruneEdgeFunctions: settings.skipPruneEdgeFunctions ?? false,
     });
 
     if (deployErrors.length > 0) {

src/supabase_admin/supabase_management_client.ts

@@ -627,6 +627,42 @@ export async function deleteSupabaseFunction({
   );
 }
 
+export async function listSupabaseFunctions({
+  supabaseProjectId,
+  organizationSlug,
+}: {
+  supabaseProjectId: string;
+  organizationSlug: string | null;
+}): Promise<DeployedFunctionResponse[]> {
+  if (IS_TEST_BUILD) {
+    return [];
+  }
+
+  logger.info(`Listing Supabase functions for project: ${supabaseProjectId}`);
+  const supabase = await getSupabaseClient({ organizationSlug });
+
+  const response = await fetchWithRetry(
+    `https://api.supabase.com/v1/projects/${supabaseProjectId}/functions`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${(supabase as any).options.accessToken}`,
+      },
+    },
+    `List Supabase functions for ${supabaseProjectId}`,
+  );
+
+  if (response.status !== 200) {
+    throw await createResponseError(response, "list functions");
+  }
+
+  const functions: DeployedFunctionResponse[] = await response.json();
+  logger.info(
+    `Found ${functions.length} functions for project: ${supabaseProjectId}`,
+  );
+  return functions;
+}
+
 export async function listSupabaseBranches({
   supabaseProjectId,
   organizationSlug,

src/supabase_admin/supabase_utils.ts

@@ -3,7 +3,9 @@ import path from "node:path";
 import log from "electron-log";
 import {
   bulkUpdateFunctions,
+  deleteSupabaseFunction,
   deploySupabaseFunction,
+  listSupabaseFunctions,
   type DeployedFunctionResponse,
 } from "./supabase_management_client";
 
@@ -76,16 +78,20 @@ export function extractFunctionNameFromPath(filePath: string): string {
  * Deploys all Supabase edge functions found in the app's supabase/functions directory
  * @param appPath - The absolute path to the app directory
  * @param supabaseProjectId - The Supabase project ID
+ * @param supabaseOrganizationSlug - The Supabase organization slug
+ * @param skipPruneEdgeFunctions - If false, delete any deployed edge functions that are not in the codebase
  * @returns An array of error messages for functions that failed to deploy (empty if all succeeded)
  */
 export async function deployAllSupabaseFunctions({
   appPath,
   supabaseProjectId,
   supabaseOrganizationSlug,
+  skipPruneEdgeFunctions,
 }: {
   appPath: string;
   supabaseProjectId: string;
   supabaseOrganizationSlug: string | null;
+  skipPruneEdgeFunctions: boolean;
 }): Promise<string[]> {
   const functionsDir = path.join(appPath, "supabase", "functions");
 
@@ -186,6 +192,49 @@ export async function deployAllSupabaseFunctions({
         errors.push(errorMessage);
       }
     }
+
+    // Prune dangling edge functions (deployed but not in codebase)
+    if (!skipPruneEdgeFunctions) {
+      try {
+        logger.info("Checking for dangling edge functions to prune...");
+        const deployedFunctions = await listSupabaseFunctions({
+          supabaseProjectId,
+          organizationSlug: supabaseOrganizationSlug,
+        });
+
+        const localFunctionNames = new Set(validFunctions);
+        const danglingFunctions = deployedFunctions.filter(
+          (fn) => !localFunctionNames.has(fn.slug),
+        );
+
+        if (danglingFunctions.length > 0) {
+          logger.info(
+            `Found ${danglingFunctions.length} dangling edge functions to prune: ${danglingFunctions.map((fn) => fn.slug).join(", ")}`,
+          );
+
+          for (const fn of danglingFunctions) {
+            try {
+              await deleteSupabaseFunction({
+                supabaseProjectId,
+                functionName: fn.slug,
+                organizationSlug: supabaseOrganizationSlug,
+              });
+              logger.info(`Pruned dangling edge function: ${fn.slug}`);
+            } catch (deleteError: any) {
+              const errorMessage = `Failed to prune edge function ${fn.slug}: ${deleteError.message}`;
+              logger.error(errorMessage, deleteError);
+              errors.push(errorMessage);
+            }
+          }
+        } else {
+          logger.info("No dangling edge functions found");
+        }
+      } catch (pruneError: any) {
+        const errorMessage = `Failed to check for dangling edge functions: ${pruneError.message}`;
+        logger.error(errorMessage, pruneError);
+        errors.push(errorMessage);
+      }
+    }
   } catch (error: any) {
     const errorMessage = `Error reading functions directory: ${error.message}`;
     logger.error(errorMessage, error);