fix(cli): map function paths to container mounts

Author: jgoux

apps/cli/src/legacy/commands/start/services/edge-runtime.service.integration.test.ts

@@ -1,4 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 
 import { describe, expect, it } from "@effect/vitest";
@@ -289,6 +296,55 @@ describe("legacyStartEdgeRuntimeContainer", () => {
     }),
   );
 
+  it.effect("maps canonical function paths to the mounted root target", () =>
+    Effect.gen(function* () {
+      const slug = "hello";
+      const canonicalWorkdir = join(tempWorkdir.current, "canonical");
+      const linkedWorkdir = join(tempWorkdir.current, "linked");
+      const canonicalFunctionsDir = join(canonicalWorkdir, "supabase", "functions");
+      const mountedFunctionsDir = join(linkedWorkdir, "supabase", "functions");
+      mkdirSync(join(canonicalFunctionsDir, slug), { recursive: true });
+      symlinkSync(canonicalWorkdir, linkedWorkdir, "dir");
+      const canonicalEntrypoint = join(
+        realpathSync(canonicalWorkdir),
+        "supabase",
+        "functions",
+        slug,
+        "index.ts",
+      );
+      writeFileSync(canonicalEntrypoint, "Deno.serve(() => new Response('ok'));");
+
+      const fnConfig = {
+        enabled: true,
+        verify_jwt: true,
+        import_map: "",
+        entrypoint: canonicalEntrypoint,
+        static_files: [],
+        env: {},
+      };
+      const mock = mockDockerSpawner();
+      const out = mockOutput();
+
+      yield* legacyStartEdgeRuntimeContainer({
+        ...baseInput(linkedWorkdir),
+        configDeclaredFunctions: { [slug]: fnConfig },
+        configFunctions: { [slug]: fnConfig },
+        rawConfigFunctions: { [slug]: fnConfig },
+      }).pipe(
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, mock.spawner),
+        Effect.provide(out.layer),
+      );
+
+      const entries = envEntries(mock.runCall!);
+      const configPrefix = "SUPABASE_INTERNAL_FUNCTIONS_CONFIG=";
+      const configEntry = entries.find((entry) => entry.startsWith(configPrefix));
+      expect(configEntry).toBeDefined();
+      expect(JSON.parse(configEntry!.slice(configPrefix.length))).toMatchObject({
+        hello: { entrypointPath: toDockerPath(join(mountedFunctionsDir, slug, "index.ts")) },
+      });
+    }),
+  );
+
   it.effect("omits --workdir when no bind mounts the project root into the container (#6035)", () =>
     Effect.gen(function* () {
       const mock = mockDockerSpawner();

apps/cli/src/legacy/commands/start/start.slim-images.e2e.test.ts

@@ -105,6 +105,31 @@ async function containerHealthStatus(name: string): Promise<string> {
   return stdout.trim();
 }
 
+async function edgeRuntimeFailureDiagnostics(name: string): Promise<string> {
+  let mounts = "<unavailable>";
+  try {
+    const { stdout } = await execFileAsync("docker", [
+      "inspect",
+      name,
+      "--format",
+      "{{json .Mounts}}",
+    ]);
+    mounts = stdout.trim() || "[]";
+  } catch (error) {
+    mounts = `<unavailable: ${error instanceof Error ? error.message : String(error)}>`;
+  }
+
+  let logs = "<unavailable>";
+  try {
+    const { stdout, stderr } = await execFileAsync("docker", ["logs", name]);
+    logs = `${stdout}${stderr}`.trim() || "<empty>";
+  } catch (error) {
+    logs = `<unavailable: ${error instanceof Error ? error.message : String(error)}>`;
+  }
+
+  return `edge runtime Mounts: ${mounts}\nedge runtime logs:\n${logs}`;
+}
+
 async function runWgetInImage(
   image: string,
   args: ReadonlyArray<string>,
@@ -258,7 +283,11 @@ describe("supabase start slim images (e2e)", () => {
         body: JSON.stringify({ name: "Functions" }),
       });
       const body = await invoked.text();
-      expect(invoked.ok, body).toBe(true);
+      if (!invoked.ok) {
+        throw new Error(
+          `Functions request failed (${invoked.status}): ${body}\n${await edgeRuntimeFailureDiagnostics(edgeRuntimeContainer)}`,
+        );
+      }
       expect(JSON.parse(body)).toEqual({ message: "Hello Functions!" });
     },
   );

apps/cli/src/shared/functions/serve.ts

@@ -4,8 +4,8 @@ import {
   type ResolvedFunctionConfig as ManifestFunctionConfig,
 } from "@supabase/config/effect";
 import { edgeRuntimeNofileUlimit } from "../stack-constants.ts";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { isAbsolute, join, resolve } from "node:path";
+import { mkdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { Effect, Option, Redacted, Stream } from "effect";
 import { parseDotEnv } from "../../legacy/shared/legacy-dotenv.ts";
 import { Output } from "../output/output.service.ts";
@@ -318,8 +318,21 @@ const parseFunctionEnvFile = Effect.fnUntraced(function* (pathname: string) {
 function toFunctionContainerConfig(
   config: ResolvedDeployFunctionConfig,
   envFile: Readonly<Record<string, string>>,
+  pathMappings: ReadonlyArray<{ readonly hostRoot: string; readonly containerRoot: string }>,
 ): ServeFunctionContainerConfig {
-  const toContainerPath = (pathname: string) => toDockerPath(resolve(pathname));
+  const toContainerPath = (pathname: string) => {
+    const resolvedPath = resolve(pathname);
+    for (const mapping of pathMappings) {
+      const relativePath = relative(mapping.hostRoot, resolvedPath);
+      if (
+        relativePath === "" ||
+        (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`))
+      ) {
+        return join(mapping.containerRoot, relativePath).replaceAll("\\", "/");
+      }
+    }
+    return toDockerPath(resolvedPath);
+  };
 
   return {
     // The Go serve path defaults verifyJWT to true when verify_jwt is not set in
@@ -649,6 +662,17 @@ export const startEdgeRuntimeContainer = Effect.fn("functions.startEdgeRuntimeCo
     );
 
     const functionsDir = join(input.projectRoot, functionsDirName);
+    const functionsRoot = resolve(functionsDir);
+    const containerFunctionsRoot = toDockerPath(functionsRoot);
+    const canonicalFunctionsRoot = yield* Effect.promise(() =>
+      realpath(functionsRoot).catch(() => functionsRoot),
+    );
+    const pathMappings = [
+      { hostRoot: functionsRoot, containerRoot: containerFunctionsRoot },
+      ...(canonicalFunctionsRoot === functionsRoot
+        ? []
+        : [{ hostRoot: canonicalFunctionsRoot, containerRoot: containerFunctionsRoot }]),
+    ];
     const functionBinds = new Map<string, DockerBind>();
     const emittedScopeWarnings = new Set<string>();
     const functionsConfig: Record<string, ServeFunctionContainerConfig> = {};
@@ -692,7 +716,7 @@ export const startEdgeRuntimeContainer = Effect.fn("functions.startEdgeRuntimeCo
         input.discoverFunctionEnvFiles && Option.isNone(input.envFile)
           ? yield* parseFunctionEnvFile(join(functionsDir, config.slug, ".env"))
           : {};
-      functionsConfig[config.slug] = toFunctionContainerConfig(config, functionEnv);
+      functionsConfig[config.slug] = toFunctionContainerConfig(config, functionEnv, pathMappings);
     }
 
     const binds = [...functionBinds.values()];
@@ -716,7 +740,7 @@ export const startEdgeRuntimeContainer = Effect.fn("functions.startEdgeRuntimeCo
       `SUPABASE_INTERNAL_JWT_SECRET=${input.authArtifacts.jwtSecret}`,
       `SUPABASE_JWKS=${input.authArtifacts.jwks}`,
       `SUPABASE_INTERNAL_HOST_PORT=${input.config.apiPort}`,
-      `SUPABASE_INTERNAL_FUNCTIONS_ROOT=${toDockerPath(functionsDir)}`,
+      `SUPABASE_INTERNAL_FUNCTIONS_ROOT=${containerFunctionsRoot}`,
       `SUPABASE_INTERNAL_FUNCTIONS_CONFIG=${JSON.stringify(functionsConfig)}`,
       ...(input.debug ? ["SUPABASE_INTERNAL_DEBUG=true"] : []),
     ];