Refresh Git worktree identity safely

Co-authored-by: codex <codex@users.noreply.github.com>

Author: juliusmarminge

apps/server/src/vcs/GitVcsDriverCore.test.ts

@@ -42,6 +42,21 @@ const makeNonRepositoryHandle = () =>
     getOutputFd: () => Stream.empty,
   });
 
+const makeSuccessfulHandle = (stdout: string) =>
+  ChildProcessSpawner.makeHandle({
+    pid: ChildProcessSpawner.ProcessId(1),
+    exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
+    isRunning: Effect.succeed(false),
+    kill: () => Effect.void,
+    unref: Effect.succeed(Effect.void),
+    stdin: Sink.drain,
+    stdout: Stream.encodeText(Stream.make(stdout)),
+    stderr: Stream.empty,
+    all: Stream.empty,
+    getInputFd: () => Sink.drain,
+    getOutputFd: () => Stream.empty,
+  });
+
 const makeTmpDir = (
   prefix = "git-vcs-driver-test-",
 ): Effect.Effect<string, PlatformError.PlatformError, FileSystem.FileSystem | Scope.Scope> =>
@@ -321,6 +336,70 @@ it.effect("marks the current branch when worktree metadata is unavailable", () =
   ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
 );
 
+it.effect("ignores worktree metadata for directories that no longer exist", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+      const missingWorktreePath = "/missing/deleted-worktree";
+      const staleWorktreeSpawner = ChildProcessSpawner.make((command) =>
+        Effect.gen(function* () {
+          if (!ChildProcess.isStandardCommand(command)) {
+            return yield* Effect.die("expected a standard Git command");
+          }
+          const isWorktreeList =
+            command.args.includes("worktree") && command.args.includes("--porcelain");
+          if (isWorktreeList) {
+            return makeSuccessfulHandle(
+              `worktree ${missingWorktreePath}\nHEAD deadbeef\nbranch refs/heads/stale-worktree\n\n`,
+            );
+          }
+          return yield* delegate.spawn(command);
+        }),
+      );
+      const driver = yield* makeGitVcsDriverCore().pipe(
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, staleWorktreeSpawner),
+      );
+      const cwd = yield* makeTmpDir();
+      yield* initRepoWithCommit(cwd).pipe(Effect.provideService(GitVcsDriver.GitVcsDriver, driver));
+      yield* git(cwd, ["branch", "stale-worktree"]).pipe(
+        Effect.provideService(GitVcsDriver.GitVcsDriver, driver),
+      );
+
+      const refs = yield* driver.listRefs({ cwd, refresh: true });
+
+      assert.equal(refs.refs.find((ref) => ref.name === "stale-worktree")?.worktreePath, null);
+    }),
+  ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
+it.effect("refreshes the current branch after an external checkout", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const driver = yield* GitVcsDriver.GitVcsDriver;
+      const cwd = yield* makeTmpDir();
+      const { initialBranch } = yield* initRepoWithCommit(cwd);
+      yield* git(cwd, ["branch", "external-checkout"]);
+
+      const initialRefs = yield* driver.listRefs({ cwd, refresh: true });
+      assert.isTrue(initialRefs.refs.find((ref) => ref.name === initialBranch)?.current);
+
+      // Raw execute intentionally bypasses the driver's mutation invalidation,
+      // matching a checkout performed by another process.
+      yield* driver.execute({
+        operation: "GitVcsDriver.test.externalCheckout",
+        cwd,
+        args: ["checkout", "external-checkout"],
+        timeoutMs: 10_000,
+      });
+      yield* TestClock.adjust("6 seconds");
+
+      const refreshedRefs = yield* driver.listRefs({ cwd, refresh: true });
+      assert.isTrue(refreshedRefs.refs.find((ref) => ref.name === "external-checkout")?.current);
+      assert.isFalse(refreshedRefs.refs.find((ref) => ref.name === initialBranch)?.current);
+    }),
+  ).pipe(Effect.provide(TestLayer)),
+);
+
 it.effect("backs off failed upstream refreshes across linked worktrees", () =>
   Effect.scoped(
     Effect.gen(function* () {

apps/server/src/vcs/GitVcsDriverCore.ts

@@ -55,6 +55,7 @@ const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
 const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2_048;
 const REPOSITORY_PATHS_CACHE_CAPACITY = 2_048;
 const REPOSITORY_PATHS_CACHE_TTL = Duration.minutes(10);
+const REPOSITORY_PATHS_REFRESH_COALESCE_TTL = Duration.seconds(5);
 const NON_REPOSITORY_PATHS_CACHE_TTL = Duration.seconds(1);
 const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
 const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
@@ -1085,9 +1086,27 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       }),
     },
   );
+  const repositoryPathsRefreshCache = yield* Cache.makeWith(
+    (cwd: string) =>
+      Cache.invalidate(repositoryPathsCache, cwd).pipe(
+        Effect.andThen(Cache.get(repositoryPathsCache, cwd)),
+      ),
+    {
+      capacity: REPOSITORY_PATHS_CACHE_CAPACITY,
+      timeToLive: Exit.match({
+        onSuccess: (repositoryPaths) =>
+          repositoryPaths === null
+            ? NON_REPOSITORY_PATHS_CACHE_TTL
+            : REPOSITORY_PATHS_REFRESH_COALESCE_TTL,
+        onFailure: () => Duration.zero,
+      }),
+    },
+  );
   const normalizeRepositoryPathsCacheKey = (cwd: string) => path.normalize(path.resolve(cwd));
-  const resolveRepositoryPaths = (cwd: string) =>
-    Cache.get(repositoryPathsCache, normalizeRepositoryPathsCacheKey(cwd));
+  const resolveRepositoryPaths = (cwd: string, refresh = false) => {
+    const cacheKey = normalizeRepositoryPathsCacheKey(cwd);
+    return Cache.get(refresh ? repositoryPathsRefreshCache : repositoryPathsCache, cacheKey);
+  };
 
   const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) {
     const repositoryPaths = yield* resolveRepositoryPaths(cwd);
@@ -2189,15 +2208,23 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       defaultRefResult.exitCode === 0
         ? defaultRefResult.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
         : null;
-    const worktreeMap =
+    const parsedWorktreeEntries =
       worktreeListResult.exitCode === 0
-        ? new Map(
-            [...parseWorktreeBranchPaths(worktreeListResult.stdout)].map(
-              ([branchName, worktreePath]) =>
-                [branchName, path.normalize(path.resolve(worktreePath))] as const,
-            ),
+        ? [...parseWorktreeBranchPaths(worktreeListResult.stdout)].map(
+            ([branchName, worktreePath]) =>
+              [branchName, path.normalize(path.resolve(worktreePath))] as const,
           )
-        : new Map<string, string>();
+        : [];
+    const existingWorktreeEntries = yield* Effect.filter(
+      parsedWorktreeEntries,
+      ([, worktreePath]) =>
+        fileSystem.stat(worktreePath).pipe(
+          Effect.as(true),
+          Effect.orElseSucceed(() => false),
+        ),
+      { concurrency: 16 },
+    );
+    const worktreeMap = new Map(existingWorktreeEntries);
     const localBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];
     const remoteBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];
 
@@ -2313,12 +2340,13 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     if (repositoryPaths === null) return;
     yield* Cache.invalidate(listRefsRefreshSnapshotCache, repositoryPaths.gitCommonDir);
     bumpListRefsEpoch(repositoryPaths.gitCommonDir);
+    yield* Cache.invalidate(repositoryPathsRefreshCache, repositoryPathsCacheKey);
     yield* Cache.invalidate(repositoryPathsCache, repositoryPathsCacheKey);
   });
 
   const listRefs: GitVcsDriver.GitVcsDriver["Service"]["listRefs"] = Effect.fn("listRefs")(
     function* (input) {
-      const repositoryPaths = yield* resolveRepositoryPaths(input.cwd).pipe(
+      const repositoryPaths = yield* resolveRepositoryPaths(input.cwd, input.refresh === true).pipe(
         Effect.catchTags({
           GitCommandError: (error) =>
             isMissingGitCwdError(error) ? Effect.succeed(null) : Effect.fail(error),
@@ -2675,6 +2703,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     input,
   ) =>
     initRepo(input).pipe(
+      Effect.tap(() =>
+        Cache.invalidate(repositoryPathsRefreshCache, normalizeRepositoryPathsCacheKey(input.cwd)),
+      ),
       Effect.tap(() =>
         Cache.invalidate(repositoryPathsCache, normalizeRepositoryPathsCacheKey(input.cwd)),
       ),