fix: harden source expansion loading

Author: adit-chandra

src/core/fileSource.test.ts

@@ -140,6 +140,48 @@ describe("createFileSourceFetcher", () => {
     expect(await fetcher.getFullText("new")).toBe("working tree\n");
   });
 
+  test("passes custom git executable through async git source reads", async () => {
+    const originalSpawn = Bun.spawn;
+    const mutableBun = Bun as unknown as { spawn: typeof Bun.spawn };
+    const spawnCalls: string[][] = [];
+
+    mutableBun.spawn = ((cmds: string[]) => {
+      spawnCalls.push(cmds);
+      return originalSpawn(
+        [
+          process.execPath,
+          "--eval",
+          `process.stdout.write(${JSON.stringify(`read:${cmds[2]}\n`)})`,
+        ],
+        {
+          stdin: "ignore",
+          stdout: "pipe",
+          stderr: "pipe",
+        },
+      );
+    }) as typeof Bun.spawn;
+
+    try {
+      const fetcher = createFileSourceFetcher(
+        {
+          old: { kind: "git-blob", repoRoot: process.cwd(), ref: "HEAD", path: "note.txt" },
+          new: { kind: "git-index", repoRoot: process.cwd(), path: "note.txt" },
+        },
+        { gitExecutable: "custom-git" },
+      );
+
+      expect(await fetcher.getFullText("old")).toBe("read:HEAD:note.txt\n");
+      expect(await fetcher.getFullText("new")).toBe("read::note.txt\n");
+    } finally {
+      mutableBun.spawn = originalSpawn;
+    }
+
+    expect(spawnCalls).toEqual([
+      ["custom-git", "show", "HEAD:note.txt"],
+      ["custom-git", "show", ":note.txt"],
+    ]);
+  });
+
   test("returns null when a git blob cannot be resolved", async () => {
     const repoRoot = createTempRepo("hunk-source-git-missing-");
     writeFileSync(join(repoRoot, "tracked.txt"), "x\n");

src/core/fileSource.ts

@@ -24,6 +24,10 @@ export interface FileSourceFetcher {
   getFullText(side: FileSourceSide): Promise<string | null>;
 }
 
+export interface FileSourceFetcherOptions {
+  gitExecutable?: string;
+}
+
 interface ResolvedSpecs {
   old: FileSourceSpec;
   new: FileSourceSpec;
@@ -77,27 +81,27 @@ async function readFsSpec(spec: Extract<FileSourceSpec, { kind: "fs" }>): Promis
 function readGitBlobSpec(
   spec: Extract<FileSourceSpec, { kind: "git-blob" }>,
   gitExecutable = "git",
-): string | null {
+): Promise<string | null> {
   return readGitObjectSpec(spec.repoRoot, `${spec.ref}:${spec.path}`, gitExecutable);
 }
 
 function readGitIndexSpec(
   spec: Extract<FileSourceSpec, { kind: "git-index" }>,
   gitExecutable = "git",
-): string | null {
+): Promise<string | null> {
   return readGitObjectSpec(spec.repoRoot, `:${spec.path}`, gitExecutable);
 }
 
 /** Read a blob-like Git object spec such as `HEAD:path` or `:path`. */
-function readGitObjectSpec(
+async function readGitObjectSpec(
   repoRoot: string,
   objectName: string,
   gitExecutable = "git",
-): string | null {
-  let proc: ReturnType<typeof Bun.spawnSync>;
+): Promise<string | null> {
+  let proc: Bun.ReadableSubprocess;
 
   try {
-    proc = Bun.spawnSync([gitExecutable, "show", objectName], {
+    proc = Bun.spawn([gitExecutable, "show", objectName], {
       cwd: repoRoot,
       stdin: "ignore",
       stdout: "pipe",
@@ -108,18 +112,34 @@ function readGitObjectSpec(
     return null;
   }
 
-  if (proc.exitCode !== 0) {
-    const stderr = Buffer.from(proc.stderr ?? []).toString("utf8");
+  let output: [number, string, string];
+  try {
+    output = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+  } catch (error) {
+    logSourceDiagnostic(`failed to collect Git source ${objectName}`, error);
+    return null;
+  }
+
+  const [exitCode, stdout, stderr] = output;
+
+  if (exitCode !== 0) {
     if (!isExpectedMissingGitSource(stderr)) {
       logSourceDiagnostic(`failed to read Git source ${objectName} in ${repoRoot}`, stderr);
     }
     return null;
   }
 
-  return Buffer.from(proc.stdout ?? []).toString("utf8");
+  return stdout;
 }
 
-async function readSpec(spec: FileSourceSpec): Promise<string | null> {
+async function readSpec(
+  spec: FileSourceSpec,
+  { gitExecutable = "git" }: FileSourceFetcherOptions = {},
+): Promise<string | null> {
   if (spec.kind === "none") {
     return null;
   }
@@ -129,14 +149,17 @@ async function readSpec(spec: FileSourceSpec): Promise<string | null> {
   }
 
   if (spec.kind === "git-index") {
-    return readGitIndexSpec(spec);
+    return readGitIndexSpec(spec, gitExecutable);
   }
 
-  return readGitBlobSpec(spec);
+  return readGitBlobSpec(spec, gitExecutable);
 }
 
 /** Build a per-file source fetcher that caches each side's resolved text. */
-export function createFileSourceFetcher(specs: ResolvedSpecs): FileSourceFetcher {
+export function createFileSourceFetcher(
+  specs: ResolvedSpecs,
+  { gitExecutable = "git" }: Readonly<FileSourceFetcherOptions> = {},
+): FileSourceFetcher {
   const cache = new Map<FileSourceSide, string | null>();
 
   return {
@@ -145,7 +168,7 @@ export function createFileSourceFetcher(specs: ResolvedSpecs): FileSourceFetcher
         return cache.get(side) ?? null;
       }
 
-      const text = await readSpec(specs[side]);
+      const text = await readSpec(specs[side], { gitExecutable });
       cache.set(side, text);
       return text;
     },

src/core/loaders.test.ts

@@ -1396,6 +1396,62 @@ describe("loadAppBootstrap source fetcher attachment", () => {
     expect(await file?.sourceFetcher?.getFullText("old")).toBe("first\n");
   });
 
+  test("git source fetchers use the custom git executable from bootstrap loading", async () => {
+    const dir = createTempRepo("hunk-source-custom-git-");
+    writeFileSync(join(dir, "value.txt"), "first\n");
+    git(dir, "add", "value.txt");
+    git(dir, "commit", "-m", "initial");
+    writeFileSync(join(dir, "value.txt"), "second\n");
+
+    const gitExecutable = "hunk-custom-git";
+    const syncCalls: string[][] = [];
+    const asyncCalls: string[][] = [];
+    const originalSpawnSync = Bun.spawnSync;
+    const originalSpawn = Bun.spawn;
+    const mutableBun = Bun as unknown as {
+      spawnSync: typeof Bun.spawnSync;
+      spawn: typeof Bun.spawn;
+    };
+
+    mutableBun.spawnSync = ((cmds: string[], options?: Parameters<typeof Bun.spawnSync>[1]) => {
+      if (cmds[0] === gitExecutable) {
+        syncCalls.push(cmds);
+        return originalSpawnSync(["git", ...cmds.slice(1)], options);
+      }
+
+      return originalSpawnSync(cmds, options);
+    }) as typeof Bun.spawnSync;
+    mutableBun.spawn = ((cmds: string[], options?: Parameters<typeof Bun.spawn>[1]) => {
+      if (cmds[0] === gitExecutable) {
+        asyncCalls.push(cmds);
+        return originalSpawn(["git", ...cmds.slice(1)], options);
+      }
+
+      return originalSpawn(cmds, options);
+    }) as typeof Bun.spawn;
+
+    try {
+      const bootstrap = await loadAppBootstrap(
+        {
+          kind: "vcs",
+          staged: false,
+          options: { mode: "auto" },
+        },
+        { cwd: dir, gitExecutable },
+      );
+
+      const file = bootstrap.changeset.files[0];
+      expect(await file?.sourceFetcher?.getFullText("old")).toBe("first\n");
+    } finally {
+      mutableBun.spawnSync = originalSpawnSync;
+      mutableBun.spawn = originalSpawn;
+    }
+
+    expect(syncCalls.some((call) => call.includes("rev-parse"))).toBe(true);
+    expect(syncCalls.some((call) => call.includes("diff"))).toBe(true);
+    expect(asyncCalls).toContainEqual([gitExecutable, "show", ":value.txt"]);
+  });
+
   test("unstaged working-tree diffs read old source from the index when it differs from HEAD", async () => {
     const dir = createTempRepo("hunk-source-git-wt-index-");
     writeFileSync(join(dir, "value.txt"), "committed\n");