Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Fix Git ref refresh resource storms (#4727)

Julius Marminge38a6e3ce65b1
diff --git a/apps/mobile/src/connection/environment-cache-store.test.ts b/apps/mobile/src/connection/environment-cache-store.test.ts
index 0caf2b415..ecb706f97 100644
--- a/apps/mobile/src/connection/environment-cache-store.test.ts
+++ b/apps/mobile/src/connection/environment-cache-store.test.ts
@@ -42,6 +42,12 @@ function makeDatabase() {
removed.push(id);
values.delete(id);
}),
+ clearCacheKind: (environmentId, kind) =>
+ Effect.sync(() => {
+ for (const key of values.keys()) {
+ if (key.startsWith(`${environmentId}:${kind}:`)) values.delete(key);
+ }
+ }),
clearEnvironmentCache: (environmentId) =>
Effect.sync(() => {
for (const key of values.keys()) {
@@ -80,6 +86,36 @@ describe("mobile SQLite environment cache store", () => {
}),
);
+ it.effect("removes one persisted VCS ref snapshot", () =>
+ Effect.gen(function* () {
+ const memory = makeDatabase();
+ const store = yield* make().pipe(Effect.provideService(MobileDatabase, memory.database));
+ yield* store.saveVcsRefs(ENVIRONMENT_ID, "/repo", REFS);
+
+ yield* store.removeVcsRefs(ENVIRONMENT_ID, "/repo");
+
+ expect(yield* store.loadVcsRefs(ENVIRONMENT_ID, "/repo")).toEqual(Option.none());
+ expect(memory.removed).toContain(cacheId(ENVIRONMENT_ID, "vcs-refs", "/repo"));
+ }),
+ );
+
+ it.effect("clears every persisted VCS ref snapshot in one environment", () =>
+ Effect.gen(function* () {
+ const memory = makeDatabase();
+ const store = yield* make().pipe(Effect.provideService(MobileDatabase, memory.database));
+ const otherEnvironmentId = EnvironmentId.make("environment-2");
+ yield* store.saveVcsRefs(ENVIRONMENT_ID, "/repo", REFS);
+ yield* store.saveVcsRefs(ENVIRONMENT_ID, "/repo-worktree", REFS);
+ yield* store.saveVcsRefs(otherEnvironmentId, "/repo", REFS);
+
+ yield* store.clearVcsRefs(ENVIRONMENT_ID);
+
+ expect(yield* store.loadVcsRefs(ENVIRONMENT_ID, "/repo")).toEqual(Option.none());
+ expect(yield* store.loadVcsRefs(ENVIRONMENT_ID, "/repo-worktree")).toEqual(Option.none());
+ expect(yield* store.loadVcsRefs(otherEnvironmentId, "/repo")).toEqual(Option.some(REFS));
+ }),
+ );
+
it.effect("clears one environment without touching another", () =>
Effect.gen(function* () {
const memory = makeDatabase();
diff --git a/apps/mobile/src/connection/environment-cache-store.ts b/apps/mobile/src/connection/environment-cache-store.ts
index 04729ad21..6573c9e11 100644
--- a/apps/mobile/src/connection/environment-cache-store.ts
+++ b/apps/mobile/src/connection/environment-cache-store.ts
@@ -223,6 +223,16 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
.pipe(Effect.mapError(mapDatabaseError("save-vcs-refs")));
},
),
+ removeVcsRefs: Effect.fn("MobileEnvironmentCache.removeVcsRefs")((environmentId, cwd) =>
+ database
+ .removeCache(environmentId, "vcs-refs", cwd)
+ .pipe(Effect.mapError(mapDatabaseError("remove-vcs-refs"))),
+ ),
+ clearVcsRefs: Effect.fn("MobileEnvironmentCache.clearVcsRefs")((environmentId) =>
+ database
+ .clearCacheKind(environmentId, "vcs-refs")
+ .pipe(Effect.mapError(mapDatabaseError("clear-vcs-refs"))),
+ ),
clear: Effect.fn("MobileEnvironmentCache.clear")((environmentId) =>
database
.clearEnvironmentCache(environmentId)
diff --git a/apps/mobile/src/persistence/mobile-database.ts b/apps/mobile/src/persistence/mobile-database.ts
index 33eb50f64..3d50a2dbc 100644
--- a/apps/mobile/src/persistence/mobile-database.ts
+++ b/apps/mobile/src/persistence/mobile-database.ts
@@ -46,6 +46,7 @@ const MobileDatabaseOperation = Schema.Literals([
"load-cache",
"save-cache",
"remove-cache",
+ "clear-cache-kind",
"clear-environment-cache",
"clear-all-caches",
"inspect-caches",
@@ -203,6 +204,10 @@ export class MobileDatabase extends Context.Service<
kind: ClientCacheKind,
cacheKey: string,
) => Effect.Effect<void, MobileDatabaseError>;
+ readonly clearCacheKind: (
+ environmentId: EnvironmentId,
+ kind: ClientCacheKind,
+ ) => Effect.Effect<void, MobileDatabaseError>;
readonly clearEnvironmentCache: (
environmentId: EnvironmentId,
) => Effect.Effect<void, MobileDatabaseError>;
@@ -322,6 +327,17 @@ const makeAvailable = Effect.gen(function* () {
catch: databaseError("remove-cache"),
}).pipe(Effect.asVoid),
),
+ clearCacheKind: Effect.fn("MobileDatabase.clearCacheKind")((environmentId, kind) =>
+ Effect.tryPromise({
+ try: () =>
+ database.runAsync(
+ "DELETE FROM client_cache WHERE environment_id = ? AND kind = ?",
+ environmentId,
+ kind,
+ ),
+ catch: databaseError("clear-cache-kind"),
+ }).pipe(Effect.asVoid),
+ ),
clearEnvironmentCache: Effect.fn("MobileDatabase.clearEnvironmentCache")((environmentId) =>
Effect.tryPromise({
try: () =>
@@ -392,6 +408,7 @@ function makeUnavailable(error: MobileDatabaseError): MobileDatabase["Service"]
loadCache: () => fail,
saveCache: () => fail,
removeCache: () => fail,
+ clearCacheKind: () => fail,
clearEnvironmentCache: () => fail,
clearAllCaches: fail,
inspectCaches: fail,
diff --git a/apps/server/src/git/GitManager.ts b/apps/server/src/git/GitManager.ts
index 95e5affc2..da002df5e 100644
--- a/apps/server/src/git/GitManager.ts
+++ b/apps/server/src/git/GitManager.ts
@@ -1794,7 +1794,7 @@ export const make = Effect.gen(function* () {
resolvePullRequestWorktreeLocalBranchName(pullRequestWithRemoteInfo);
const findLocalHeadBranch = Effect.fn("findLocalHeadBranch")(function* (cwd: string) {
- const result = yield* gitCore.listRefs({ cwd });
+ const result = yield* gitCore.listRefs({ cwd, refresh: true });
const localBranch = result.refs.find(
(branch) => !branch.isRemote && branch.name === localPullRequestBranch,
);
diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts
index 7b5956de0..941d92cdb 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.test.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts
@@ -1,18 +1,22 @@
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it, describe } from "@effect/vitest";
+import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
+import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
+import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
+import * as TestClock from "effect/testing/TestClock";
import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
import { GitCommandError } from "@t3tools/contracts";
import { ServerConfig } from "../config.ts";
-import { splitNullSeparatedGitStdoutPaths } from "./GitVcsDriverCore.ts";
+import { makeGitVcsDriverCore, splitNullSeparatedGitStdoutPaths } from "./GitVcsDriverCore.ts";
import * as GitVcsDriver from "./GitVcsDriver.ts";
const ServerConfigLayer = ServerConfig.layerTest(process.cwd(), {
@@ -38,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> =>
@@ -129,11 +148,434 @@ it.effect("uses stable diagnostics for every parsed non-repository command", ()
assert.deepStrictEqual(commands, [
{ args: ["status", "--porcelain=2", "--branch"], lcAll: "C" },
{ args: ["rev-parse", "--abbrev-ref", "HEAD"], lcAll: "C" },
- { args: ["branch", "--no-color", "--no-column"], lcAll: "C" },
+ { args: ["rev-parse", "--git-common-dir"], lcAll: "C" },
]);
}).pipe(Effect.provide(layer));
});
+it.effect("coalesces concurrent ref pages into one repository snapshot", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const spawnedArgs = yield* Ref.make<ReadonlyArray<ReadonlyArray<string>>>([]);
+ const firstWorktreeScanStarted = yield* Deferred.make<void>();
+ const remoteNamesScanCompleted = yield* Deferred.make<void>();
+ const delayFirstWorktreeScan = yield* Ref.make(true);
+ const countingSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ yield* Ref.update(spawnedArgs, (current) => [...current, command.args]);
+ const isWorktreeScan =
+ command.args.includes("worktree") && command.args.includes("--porcelain");
+ const shouldDelay =
+ isWorktreeScan && (yield* Ref.getAndSet(delayFirstWorktreeScan, false));
+ if (shouldDelay) {
+ yield* Deferred.succeed(firstWorktreeScanStarted, undefined);
+ yield* Effect.sleep("8 seconds");
+ }
+ const handle = yield* delegate.spawn(command);
+ const isRemoteNamesScan =
+ command.args.length === 3 &&
+ command.args[0] === "--git-dir" &&
+ command.args[2] === "remote";
+ return isRemoteNamesScan
+ ? ChildProcessSpawner.makeHandle({
+ ...handle,
+ exitCode: handle.exitCode.pipe(
+ Effect.tap(() => Deferred.succeed(remoteNamesScanCompleted, undefined)),
+ ),
+ })
+ : handle;
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, countingSpawner),
+ );
+ const cwd = yield* makeTmpDir();
+ const runGit = (args: ReadonlyArray<string>) =>
+ driver.execute({
+ operation: "GitVcsDriver.test.coalescedListRefs",
+ cwd,
+ args,
+ timeoutMs: 10_000,
+ });
+
+ yield* driver.initRepo({ cwd });
+ yield* runGit(["config", "user.email", "[email protected]"]);
+ yield* runGit(["config", "user.name", "Test"]);
+ yield* writeTextFile(cwd, "README.md", "# test\n");
+ yield* runGit(["add", "."]);
+ yield* runGit(["commit", "-m", "initial commit"]);
+ yield* Ref.set(spawnedArgs, []);
+
+ const initialRequest = yield* driver
+ .listRefs({ cwd, refresh: true, limit: 100 })
+ .pipe(Effect.forkChild({ startImmediately: true }));
+ yield* Deferred.await(firstWorktreeScanStarted);
+ yield* Deferred.await(remoteNamesScanCompleted);
+ yield* TestClock.adjust("6 seconds");
+ const laterRequests = yield* Effect.all(
+ Array.from({ length: 30 }, (_, index) =>
+ driver.listRefs({
+ cwd,
+ refresh: true,
+ query: `missing-${index}`,
+ limit: 100,
+ }),
+ ),
+ { concurrency: "unbounded" },
+ ).pipe(Effect.forkChild({ startImmediately: true }));
+ yield* TestClock.adjust("2 seconds");
+ yield* Fiber.join(initialRequest);
+ yield* Fiber.join(laterRequests);
+ yield* driver.listRefs({ cwd, cursor: 1, limit: 100 });
+
+ const firstSnapshotCommands = yield* Ref.get(spawnedArgs);
+ const snapshotRefScans = firstSnapshotCommands.filter(
+ (args) =>
+ args.includes("for-each-ref") &&
+ args.includes("refs/heads") &&
+ args.includes("refs/remotes"),
+ );
+ const worktreeScans = firstSnapshotCommands.filter(
+ (args) => args.includes("worktree") && args.includes("--porcelain"),
+ );
+ assert.equal(snapshotRefScans.length, 1);
+ assert.equal(worktreeScans.length, 1);
+
+ yield* driver.createRef({ cwd, refName: "feature/cache-invalidation" });
+ const refreshed = yield* driver.listRefs({ cwd, limit: 100 });
+ assert.equal(
+ refreshed.refs.some((ref) => ref.name === "feature/cache-invalidation"),
+ true,
+ );
+ const allCommands = yield* Ref.get(spawnedArgs);
+ assert.equal(
+ allCommands.filter(
+ (args) =>
+ args.includes("for-each-ref") &&
+ args.includes("refs/heads") &&
+ args.includes("refs/remotes"),
+ ).length,
+ 2,
+ );
+ }),
+ ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
+it.effect("retries an in-flight ref snapshot invalidated by a mutation", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const firstWorktreeScanStarted = yield* Deferred.make<void>();
+ const firstRefScanCompleted = yield* Deferred.make<void>();
+ const releaseFirstWorktreeScan = yield* Deferred.make<void>();
+ const delayFirstWorktreeScan = yield* Ref.make(true);
+ const refScans = yield* Ref.make(0);
+ const coordinatingSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ const isWorktreeScan =
+ command.args.includes("worktree") && command.args.includes("--porcelain");
+ if (isWorktreeScan && (yield* Ref.getAndSet(delayFirstWorktreeScan, false))) {
+ yield* Deferred.succeed(firstWorktreeScanStarted, undefined);
+ yield* Deferred.await(releaseFirstWorktreeScan);
+ }
+ const handle = yield* delegate.spawn(command);
+ const isRefScan =
+ command.args.includes("for-each-ref") &&
+ command.args.includes("refs/heads") &&
+ command.args.includes("refs/remotes");
+ if (!isRefScan) return handle;
+ const scan = yield* Ref.updateAndGet(refScans, (count) => count + 1);
+ return scan === 1
+ ? ChildProcessSpawner.makeHandle({
+ ...handle,
+ exitCode: handle.exitCode.pipe(
+ Effect.tap(() => Deferred.succeed(firstRefScanCompleted, undefined)),
+ ),
+ })
+ : handle;
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, coordinatingSpawner),
+ );
+ const cwd = yield* makeTmpDir();
+ yield* initRepoWithCommit(cwd).pipe(Effect.provideService(GitVcsDriver.GitVcsDriver, driver));
+
+ const inFlight = yield* driver
+ .listRefs({ cwd, refresh: true, limit: 100 })
+ .pipe(Effect.forkChild({ startImmediately: true }));
+ yield* Deferred.await(firstWorktreeScanStarted);
+ yield* Deferred.await(firstRefScanCompleted);
+
+ yield* driver.createRef({ cwd, refName: "feature/during-refresh" });
+ yield* Deferred.succeed(releaseFirstWorktreeScan, undefined);
+
+ const refs = yield* Fiber.join(inFlight);
+ assert.isTrue(refs.refs.some((ref) => ref.name === "feature/during-refresh"));
+ assert.equal(yield* Ref.get(refScans), 2);
+ }),
+ ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
+it.effect("invalidates a ref snapshot when a mutation fails after changing Git", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const partiallyFailingSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ if (command.args[0] === "branch" && command.args[1] === "feature/partial-failure") {
+ const handle = yield* delegate.spawn(command);
+ yield* handle.exitCode;
+ return makeNonRepositoryHandle();
+ }
+ return yield* delegate.spawn(command);
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, partiallyFailingSpawner),
+ );
+ const cwd = yield* makeTmpDir();
+ yield* initRepoWithCommit(cwd).pipe(Effect.provideService(GitVcsDriver.GitVcsDriver, driver));
+ yield* driver.listRefs({ cwd, refresh: true });
+
+ yield* driver.createRef({ cwd, refName: "feature/partial-failure" }).pipe(Effect.flip);
+
+ const refs = yield* driver.listRefs({ cwd });
+ assert.isTrue(refs.refs.some((ref) => ref.name === "feature/partial-failure"));
+ }),
+ ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
+it.effect("fails a ref snapshot when for-each-ref exits unsuccessfully", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const snapshotAttempts = yield* Ref.make(0);
+ const failingSnapshotSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ if (command.args.includes("for-each-ref")) {
+ yield* Ref.update(snapshotAttempts, (count) => count + 1);
+ return makeNonRepositoryHandle();
+ }
+ return yield* delegate.spawn(command);
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, failingSnapshotSpawner),
+ );
+ const cwd = yield* makeTmpDir();
+ yield* initRepoWithCommit(cwd).pipe(Effect.provideService(GitVcsDriver.GitVcsDriver, driver));
+
+ const error = yield* driver.listRefs({ cwd, refresh: true }).pipe(Effect.flip);
+
+ assert.deepInclude(error, {
+ _tag: "GitCommandError",
+ operation: "GitVcsDriver.listRefs.snapshotRefs",
+ detail: "Git ref snapshot enumeration failed.",
+ exitCode: 128,
+ });
+ assert.equal(yield* Ref.get(snapshotAttempts), 1);
+ }),
+ ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
+it.effect("marks the current branch when worktree metadata is unavailable", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const incompleteMetadataSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ const isWorktreeRoot =
+ command.args.includes("rev-parse") && command.args.includes("--show-toplevel");
+ const isWorktreeList =
+ command.args.includes("worktree") && command.args.includes("--porcelain");
+ if (isWorktreeRoot || isWorktreeList) {
+ return makeNonRepositoryHandle();
+ }
+ return yield* delegate.spawn(command);
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, incompleteMetadataSpawner),
+ );
+ const cwd = yield* makeTmpDir();
+ const { initialBranch } = yield* initRepoWithCommit(cwd).pipe(
+ Effect.provideService(GitVcsDriver.GitVcsDriver, driver),
+ );
+
+ const refs = yield* driver.listRefs({ cwd, refresh: true });
+
+ assert.isTrue(refs.isRepo);
+ assert.isTrue(refs.refs.find((ref) => ref.name === initialBranch)?.current);
+ }),
+ ).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}\0HEAD deadbeef\0branch refs/heads/stale-worktree\0\0`,
+ );
+ }
+ 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* () {
+ const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const fetchAttempts = yield* Ref.make(0);
+ const failingFetchSpawner = ChildProcessSpawner.make((command) =>
+ Effect.gen(function* () {
+ if (!ChildProcess.isStandardCommand(command)) {
+ return yield* Effect.die("expected a standard Git command");
+ }
+ if (command.args.includes("fetch") && command.args.includes("--quiet")) {
+ yield* Ref.update(fetchAttempts, (count) => count + 1);
+ return makeNonRepositoryHandle();
+ }
+ return yield* delegate.spawn(command);
+ }),
+ );
+ const driver = yield* makeGitVcsDriverCore().pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, failingFetchSpawner),
+ );
+ const fileSystem = yield* FileSystem.FileSystem;
+ const cwd = yield* makeTmpDir();
+ const remote = yield* makeTmpDir("git-vcs-driver-remote-");
+ const worktreesRoot = yield* makeTmpDir("git-vcs-driver-worktrees-");
+ const pathService = yield* Path.Path;
+ const worktreePath = pathService.join(worktreesRoot, "linked");
+ const runGit = (workingDirectory: string, args: ReadonlyArray<string>) =>
+ driver.execute({
+ operation: "GitVcsDriver.test.upstreamRefreshBackoff",
+ cwd: workingDirectory,
+ args,
+ timeoutMs: 10_000,
+ });
+
+ yield* driver.initRepo({ cwd });
+ yield* runGit(cwd, ["config", "user.email", "[email protected]"]);
+ yield* runGit(cwd, ["config", "user.name", "Test"]);
+ yield* writeTextFile(cwd, "README.md", "# test\n");
+ yield* runGit(cwd, ["add", "."]);
+ yield* runGit(cwd, ["commit", "-m", "initial commit"]);
+ const initialBranch = (yield* runGit(cwd, ["branch", "--show-current"])).stdout.trim();
+ yield* runGit(remote, ["init", "--bare"]);
+ yield* runGit(cwd, ["remote", "add", "origin", remote]);
+ yield* runGit(cwd, ["push", "-u", "origin", initialBranch]);
+ yield* runGit(cwd, ["worktree", "add", "-b", "feature/linked", worktreePath]);
+ yield* runGit(worktreePath, [
+ "branch",
+ "--set-upstream-to",
+ `origin/${initialBranch}`,
+ "feature/linked",
+ ]);
+ const rootCommonDir = (yield* runGit(cwd, ["rev-parse", "--git-common-dir"])).stdout.trim();
+ const linkedCommonDir = (yield* runGit(worktreePath, [
+ "rev-parse",
+ "--git-common-dir",
+ ])).stdout.trim();
+ assert.equal(
+ yield* fileSystem.realPath(pathService.resolve(cwd, rootCommonDir)),
+ yield* fileSystem.realPath(pathService.resolve(worktreePath, linkedCommonDir)),
+ );
+ yield* Ref.set(fetchAttempts, 0);
+
+ yield* driver.statusDetailsRemote(cwd);
+ yield* driver.statusDetailsRemote(worktreePath);
+ assert.equal(yield* Ref.get(fetchAttempts), 1);
+
+ yield* TestClock.adjust("29 seconds");
+ yield* driver.statusDetailsRemote(worktreePath);
+ assert.equal(yield* Ref.get(fetchAttempts), 1);
+
+ yield* TestClock.adjust("1 second");
+ yield* driver.statusDetailsRemote(cwd);
+ assert.equal(yield* Ref.get(fetchAttempts), 2);
+
+ yield* TestClock.adjust("59 seconds");
+ yield* driver.statusDetailsRemote(worktreePath);
+ assert.equal(yield* Ref.get(fetchAttempts), 2);
+
+ yield* TestClock.adjust("1 second");
+ yield* driver.statusDetailsRemote(cwd);
+ assert.equal(yield* Ref.get(fetchAttempts), 3);
+ }),
+ ).pipe(Effect.provide(ServerConfigLayer.pipe(Layer.provideMerge(NodeServices.layer)))),
+);
+
it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
describe("process environment", () => {
it.effect("preserves the caller locale for general Git subprocesses", () =>
@@ -661,6 +1103,33 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
});
describe("worktree operations", () => {
+ it.effect("preserves newline characters in worktree paths when listing refs", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTmpDir();
+ yield* initRepoWithCommit(cwd);
+ const worktreesRoot = yield* makeTmpDir("git-vcs-driver-worktrees-");
+ const fileSystem = yield* FileSystem.FileSystem;
+ const pathService = yield* Path.Path;
+ const worktreePath = pathService.join(worktreesRoot, "linked\nworktree");
+ const driver = yield* GitVcsDriver.GitVcsDriver;
+
+ yield* git(cwd, ["worktree", "add", "-b", "feature/newline-path", worktreePath]);
+
+ const refs = yield* driver.listRefs({ cwd, refresh: true });
+ const listedPath = refs.refs.find(
+ (ref) => ref.name === "feature/newline-path",
+ )?.worktreePath;
+
+ if (typeof listedPath !== "string") {
+ return assert.fail("expected the linked branch to include its worktree path");
+ }
+ assert.equal(
+ yield* fileSystem.realPath(listedPath),
+ yield* fileSystem.realPath(worktreePath),
+ );
+ }),
+ );
+
it.effect("creates and removes a worktree for a new refName", () =>
Effect.gen(function* () {
const cwd = yield* makeTmpDir();
diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts
index 33eb6d40d..f739c98da 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.ts
@@ -50,8 +50,17 @@ const WORKSPACE_FILES_MAX_OUTPUT_BYTES = 120_000;
const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
-const STATUS_UPSTREAM_REFRESH_FAILURE_COOLDOWN = Duration.seconds(5);
+const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
+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);
+const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
+const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
GCM_INTERACTIVE: "never",
GIT_ASKPASS: "",
@@ -95,6 +104,35 @@ class StatusRemoteRefreshCacheKey extends Data.Class<{
remoteName: string;
}> {}
+function statusUpstreamRefreshFailureCooldown(consecutiveFailures: number): Duration.Duration {
+ const exponent = Math.max(0, consecutiveFailures - 1);
+ const cooldownMs =
+ Duration.toMillis(STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN) * Math.pow(2, exponent);
+ return Duration.min(Duration.millis(cooldownMs), STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN);
+}
+
+class GitRefsSnapshotCacheKey extends Data.Class<{
+ gitCommonDir: string;
+ epoch: number;
+}> {}
+
+class GitRefsRefreshCacheKey extends Data.Class<{
+ gitCommonDir: string;
+ generation: number;
+}> {}
+
+interface GitRepositoryPaths {
+ readonly gitCommonDir: string;
+ readonly worktreeRoot: string | null;
+ readonly currentBranch: string | null;
+}
+
+interface GitRefsSnapshot {
+ readonly localBranches: ReadonlyArray<VcsRef>;
+ readonly remoteBranches: ReadonlyArray<VcsRef>;
+ readonly hasPrimaryRemote: boolean;
+}
+
interface ExecuteGitOptions {
stdin?: string | undefined;
timeoutMs?: number | undefined;
@@ -161,21 +199,6 @@ function parsePorcelainPath(line: string): string | null {
return filePath.length > 0 ? filePath : null;
}
-function parseBranchLine(line: string): { name: string; current: boolean } | null {
- const trimmed = line.trim();
- if (trimmed.length === 0) return null;
-
- const name = trimmed.replace(/^[*+]\s+/, "");
- // Exclude symbolic refs like: "origin/HEAD -> origin/main".
- // Exclude detached HEAD pseudo-refs like: "(HEAD detached at origin/main)".
- if (name.includes(" -> ") || name.startsWith("(")) return null;
-
- return {
- name,
- current: trimmed.startsWith("* "),
- };
-}
-
function filterBranchesForListQuery(
refs: ReadonlyArray<VcsRef>,
query?: string,
@@ -210,6 +233,37 @@ function paginateBranches(input: {
};
}
+function parseWorktreeBranchPaths(stdout: string): ReadonlyMap<string, string> {
+ const worktreePaths = new Map<string, string>();
+ let currentPath: string | null = null;
+ let currentBranch: string | null = null;
+ let currentPrunable = false;
+
+ const flush = () => {
+ if (currentPath !== null && currentBranch !== null && !currentPrunable) {
+ worktreePaths.set(currentBranch, currentPath);
+ }
+ currentPath = null;
+ currentBranch = null;
+ currentPrunable = false;
+ };
+
+ for (const field of stdout.split("\0")) {
+ if (field === "") {
+ flush();
+ } else if (field.startsWith("worktree ")) {
+ currentPath = field.slice("worktree ".length);
+ } else if (field.startsWith("branch refs/heads/")) {
+ currentBranch = field.slice("branch refs/heads/".length);
+ } else if (field === "prunable" || field.startsWith("prunable ")) {
+ currentPrunable = true;
+ }
+ }
+ flush();
+
+ return worktreePaths;
+}
+
function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
const parts = input.split("\0");
if (parts.length === 0) return [];
@@ -937,35 +991,183 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
fetchCwd,
["--git-dir", gitCommonDir, "fetch", "--quiet", "--no-tags", remoteName],
{
- allowNonZeroExit: true,
env: STATUS_UPSTREAM_REFRESH_ENV,
+ fallbackErrorDetail: "Background Git fetch exited with a non-zero status.",
timeoutMs: Duration.toMillis(STATUS_UPSTREAM_REFRESH_TIMEOUT),
},
).pipe(Effect.asVoid);
};
+ const resolveRepositoryPathsUncached = Effect.fn("resolveRepositoryPathsUncached")(function* (
+ cwd: string,
+ ) {
+ const commonDirResult = yield* executeGitWithStableDiagnostics(
+ "GitVcsDriver.resolveRepositoryPaths.commonDir",
+ cwd,
+ ["rev-parse", "--git-common-dir"],
+ {
+ timeoutMs: 5_000,
+ allowNonZeroExit: true,
+ },
+ );
+ if (commonDirResult.exitCode !== 0) {
+ const stderr = commonDirResult.stderr.trim();
+ if (isNonRepositoryGitStderr(stderr)) {
+ return null;
+ }
+ return yield* new GitCommandError({
+ ...gitCommandContext({
+ operation: "GitVcsDriver.resolveRepositoryPaths.commonDir",
+ cwd,
+ args: ["rev-parse", "--git-common-dir"],
+ }),
+ detail: "Failed to resolve the Git common directory.",
+ exitCode: commonDirResult.exitCode,
+ stdoutLength: commonDirResult.stdout.length,
+ stderrLength: commonDirResult.stderr.length,
+ });
+ }
+
+ const commonDirOutput = commonDirResult.stdout.trim();
+ const resolvedGitCommonDir = path.isAbsolute(commonDirOutput)
+ ? path.normalize(commonDirOutput)
+ : path.resolve(cwd, commonDirOutput);
+ const gitCommonDir = yield* fileSystem
+ .realPath(resolvedGitCommonDir)
+ .pipe(Effect.orElseSucceed(() => resolvedGitCommonDir));
+ const [worktreeRootResult, currentBranchResult] = yield* Effect.all(
+ [
+ executeGit(
+ "GitVcsDriver.resolveRepositoryPaths.worktreeRoot",
+ cwd,
+ ["rev-parse", "--show-toplevel"],
+ {
+ timeoutMs: 5_000,
+ allowNonZeroExit: true,
+ },
+ ),
+ executeGit(
+ "GitVcsDriver.resolveRepositoryPaths.currentBranch",
+ cwd,
+ ["symbolic-ref", "--quiet", "--short", "HEAD"],
+ {
+ timeoutMs: 5_000,
+ allowNonZeroExit: true,
+ },
+ ),
+ ],
+ { concurrency: 2 },
+ );
+ const worktreeRootOutput = worktreeRootResult.stdout.trim();
+ const worktreeRoot =
+ worktreeRootResult.exitCode === 0 && worktreeRootOutput.length > 0
+ ? path.normalize(
+ path.isAbsolute(worktreeRootOutput)
+ ? worktreeRootOutput
+ : path.resolve(cwd, worktreeRootOutput),
+ )
+ : null;
+ const currentBranchOutput = currentBranchResult.stdout.trim();
+ const currentBranch =
+ currentBranchResult.exitCode === 0 && currentBranchOutput.length > 0
+ ? currentBranchOutput
+ : null;
+
+ return {
+ gitCommonDir,
+ worktreeRoot,
+ currentBranch,
+ } satisfies GitRepositoryPaths;
+ });
+
+ const repositoryPathsCache = yield* Cache.makeWith(
+ (cwd: string) => resolveRepositoryPathsUncached(cwd),
+ {
+ capacity: REPOSITORY_PATHS_CACHE_CAPACITY,
+ timeToLive: Exit.match({
+ onSuccess: (repositoryPaths) =>
+ repositoryPaths === null ? NON_REPOSITORY_PATHS_CACHE_TTL : REPOSITORY_PATHS_CACHE_TTL,
+ onFailure: () => Duration.zero,
+ }),
+ },
+ );
+ 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, refresh = false) => {
+ const cacheKey = normalizeRepositoryPathsCacheKey(cwd);
+ return Cache.get(refresh ? repositoryPathsRefreshCache : repositoryPathsCache, cacheKey);
+ };
+
const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) {
- const gitCommonDir = yield* runGitStdout("GitVcsDriver.resolveGitCommonDir", cwd, [
- "rev-parse",
- "--git-common-dir",
- ]).pipe(Effect.map((stdout) => stdout.trim()));
- return path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(cwd, gitCommonDir);
+ const repositoryPaths = yield* resolveRepositoryPaths(cwd);
+ if (repositoryPaths !== null) {
+ return repositoryPaths.gitCommonDir;
+ }
+ return yield* new GitCommandError({
+ ...gitCommandContext({
+ operation: "GitVcsDriver.resolveGitCommonDir",
+ cwd,
+ args: ["rev-parse", "--git-common-dir"],
+ }),
+ detail: "Cannot resolve a Git common directory outside a repository.",
+ });
});
+ const statusRemoteRefreshFailureCounts = new Map<string, number>();
+ const statusRemoteRefreshFailureKey = (cacheKey: StatusRemoteRefreshCacheKey) =>
+ `${cacheKey.gitCommonDir}\0${cacheKey.remoteName}`;
+ const recordStatusRemoteRefreshFailure = (cacheKey: StatusRemoteRefreshCacheKey) => {
+ const key = statusRemoteRefreshFailureKey(cacheKey);
+ const nextCount = (statusRemoteRefreshFailureCounts.get(key) ?? 0) + 1;
+ statusRemoteRefreshFailureCounts.delete(key);
+ statusRemoteRefreshFailureCounts.set(key, nextCount);
+ if (statusRemoteRefreshFailureCounts.size > STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY) {
+ const oldestKey = statusRemoteRefreshFailureCounts.keys().next().value;
+ if (oldestKey !== undefined) {
+ statusRemoteRefreshFailureCounts.delete(oldestKey);
+ }
+ }
+ };
+ const clearStatusRemoteRefreshFailures = (cacheKey: StatusRemoteRefreshCacheKey) => {
+ statusRemoteRefreshFailureCounts.delete(statusRemoteRefreshFailureKey(cacheKey));
+ };
const refreshStatusRemoteCacheEntry = Effect.fn("refreshStatusRemoteCacheEntry")(function* (
cacheKey: StatusRemoteRefreshCacheKey,
) {
- yield* fetchRemoteForStatus(cacheKey.gitCommonDir, cacheKey.remoteName);
- return true as const;
+ return yield* fetchRemoteForStatus(cacheKey.gitCommonDir, cacheKey.remoteName).pipe(
+ Effect.tap(() => Effect.sync(() => clearStatusRemoteRefreshFailures(cacheKey))),
+ Effect.tapError(() => Effect.sync(() => recordStatusRemoteRefreshFailure(cacheKey))),
+ Effect.as(true as const),
+ );
});
const statusRemoteRefreshCache = yield* Cache.makeWith(refreshStatusRemoteCacheEntry, {
capacity: STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY,
- // Keep successful refreshes warm and briefly back off failed refreshes to avoid retry storms.
- timeToLive: (exit) =>
+ // A failed background fetch is intentionally cached and exponentially
+ // backed off. Status reads swallow this failure and use the last fetched
+ // refs, so repeated thread mounts cannot turn a slow or unavailable remote
+ // into a repository-wide Git subprocess storm.
+ timeToLive: (exit, cacheKey) =>
Exit.isSuccess(exit)
? STATUS_UPSTREAM_REFRESH_INTERVAL
- : STATUS_UPSTREAM_REFRESH_FAILURE_COOLDOWN,
+ : statusUpstreamRefreshFailureCooldown(
+ statusRemoteRefreshFailureCounts.get(statusRemoteRefreshFailureKey(cacheKey)) ?? 1,
+ ),
});
const refreshStatusUpstreamIfStale = Effect.fn("refreshStatusUpstreamIfStale")(function* (
@@ -1273,42 +1475,6 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
};
});
- const readBranchRecency = Effect.fn("readBranchRecency")(function* (cwd: string) {
- const branchRecency = yield* executeGit(
- "GitVcsDriver.readBranchRecency",
- cwd,
- [
- "for-each-ref",
- "--format=%(refname:short)%09%(committerdate:unix)",
- "refs/heads",
- "refs/remotes",
- ],
- {
- timeoutMs: 15_000,
- allowNonZeroExit: true,
- },
- );
-
- const branchLastCommit = new Map<string, number>();
- if (branchRecency.exitCode !== 0) {
- return branchLastCommit;
- }
-
- for (const line of branchRecency.stdout.split("\n")) {
- if (line.length === 0) {
- continue;
- }
- const [name, lastCommitRaw] = line.split("\t");
- if (!name) {
- continue;
- }
- const lastCommit = Number.parseInt(lastCommitRaw ?? "0", 10);
- branchLastCommit.set(name, Number.isFinite(lastCommit) ? lastCommit : 0);
- }
-
- return branchLastCommit;
- });
-
const readStatusDetailsLocal = Effect.fn("readStatusDetailsLocal")(function* (cwd: string) {
const statusResult = yield* executeGitWithStableDiagnostics(
"GitVcsDriver.statusDetails.status",
@@ -1987,257 +2153,283 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
Effect.map((trimmed) => (trimmed.length > 0 ? trimmed : null)),
);
- const listRefs: GitVcsDriver.GitVcsDriver["Service"]["listRefs"] = Effect.fn("listRefs")(
- function* (input) {
- const branchRecencyPromise = readBranchRecency(input.cwd).pipe(
- Effect.orElseSucceed(() => new Map<string, number>()),
- );
- const localBranchResult = yield* executeGitWithStableDiagnostics(
- "GitVcsDriver.listRefs.branchNoColor",
- input.cwd,
- ["branch", "--no-color", "--no-column"],
- {
- timeoutMs: 10_000,
+ const readGitRefsSnapshot = Effect.fn("readGitRefsSnapshot")(function* (gitCommonDir: string) {
+ const fetchCwd =
+ path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
+ const gitDirArgs = ["--git-dir", gitCommonDir] as const;
+ const [refsResult, defaultRefResult, worktreeListResult, remoteNamesResult] = yield* Effect.all(
+ [
+ executeGitWithStableDiagnostics(
+ "GitVcsDriver.listRefs.snapshotRefs",
+ fetchCwd,
+ [
+ ...gitDirArgs,
+ "for-each-ref",
+ "--format=%(refname)%09%(committerdate:unix)%09%(symref)",
+ "refs/heads",
+ "refs/remotes",
+ ],
+ {
+ timeoutMs: 30_000,
+ maxOutputBytes: 16 * 1024 * 1024,
+ fallbackErrorDetail: "Git ref snapshot enumeration failed.",
+ },
+ ),
+ executeGit(
+ "GitVcsDriver.listRefs.defaultRef",
+ fetchCwd,
+ [...gitDirArgs, "symbolic-ref", "refs/remotes/origin/HEAD"],
+ {
+ timeoutMs: 5_000,
+ allowNonZeroExit: true,
+ },
+ ),
+ executeGit(
+ "GitVcsDriver.listRefs.worktreeList",
+ fetchCwd,
+ [...gitDirArgs, "worktree", "list", "--porcelain", "-z"],
+ {
+ timeoutMs: 30_000,
+ allowNonZeroExit: true,
+ maxOutputBytes: 16 * 1024 * 1024,
+ },
+ ),
+ executeGit("GitVcsDriver.listRefs.remoteNames", fetchCwd, [...gitDirArgs, "remote"], {
+ timeoutMs: 5_000,
allowNonZeroExit: true,
- },
- ).pipe(
- Effect.catchTags({
- GitCommandError: (error) =>
- isMissingGitCwdError(error)
- ? Effect.succeed({
- exitCode: ChildProcessSpawner.ExitCode(128),
- stdout: "",
- stderr: "fatal: not a git repository",
- stdoutTruncated: false,
- stderrTruncated: false,
- })
- : Effect.fail(error),
}),
- );
+ ],
+ { concurrency: 2 },
+ );
- if (localBranchResult.exitCode !== 0) {
- const stderr = localBranchResult.stderr.trim();
- if (isNonRepositoryGitStderr(stderr)) {
- return {
- refs: [],
- isRepo: false,
- hasPrimaryRemote: false,
- nextCursor: null,
- totalCount: 0,
- };
- }
- return yield* new GitCommandError({
- ...gitCommandContext({
- operation: "GitVcsDriver.listRefs",
- cwd: input.cwd,
- args: ["branch", "--no-color", "--no-column"],
- }),
- detail: "Git branch listing failed.",
- exitCode: localBranchResult.exitCode,
- stdoutLength: localBranchResult.stdout.length,
- stderrLength: localBranchResult.stderr.length,
+ const remoteNames =
+ remoteNamesResult.exitCode === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
+ if (remoteNamesResult.exitCode !== 0 && remoteNamesResult.stderr.trim().length > 0) {
+ yield* Effect.logWarning(
+ `GitVcsDriver.listRefs: remote name lookup returned code ${remoteNamesResult.exitCode} for ${gitCommonDir}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
+ );
+ }
+ const defaultBranch =
+ defaultRefResult.exitCode === 0
+ ? defaultRefResult.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
+ : null;
+ const parsedWorktreeEntries =
+ worktreeListResult.exitCode === 0
+ ? [...parseWorktreeBranchPaths(worktreeListResult.stdout)].map(
+ ([branchName, worktreePath]) =>
+ [branchName, path.normalize(path.resolve(worktreePath))] as const,
+ )
+ : [];
+ 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 }> = [];
+
+ for (const line of refsResult.stdout.split("\n")) {
+ if (line.length === 0) continue;
+ const [fullRefName, lastCommitRaw, symbolicTarget] = line.split("\t");
+ if (!fullRefName || symbolicTarget) continue;
+ const parsedLastCommit = Number.parseInt(lastCommitRaw ?? "0", 10);
+ const lastCommit = Number.isFinite(parsedLastCommit) ? parsedLastCommit : 0;
+
+ if (fullRefName.startsWith("refs/heads/")) {
+ const name = fullRefName.slice("refs/heads/".length);
+ localBranches.push({
+ ref: {
+ name,
+ current: false,
+ isRemote: false,
+ isDefault: name === defaultBranch,
+ worktreePath: worktreeMap.get(name) ?? null,
+ },
+ lastCommit,
});
+ continue;
}
+ if (!fullRefName.startsWith("refs/remotes/")) continue;
+
+ const name = fullRefName.slice("refs/remotes/".length);
+ const parsedRemoteRef = parseRemoteRefWithRemoteNames(name, remoteNames);
+ const remoteBranch: VcsRef = {
+ name,
+ current: false,
+ isRemote: true,
+ isDefault:
+ defaultBranch !== null &&
+ parsedRemoteRef?.remoteName === "origin" &&
+ parsedRemoteRef.branchName === defaultBranch,
+ worktreePath: null,
+ ...(parsedRemoteRef ? { remoteName: parsedRemoteRef.remoteName } : {}),
+ };
+ remoteBranches.push({ ref: remoteBranch, lastCommit });
+ }
- const remoteBranchResultEffect = executeGit(
- "GitVcsDriver.listRefs.remoteBranches",
- input.cwd,
- ["branch", "--no-color", "--no-column", "--remotes"],
- {
- timeoutMs: 10_000,
- allowNonZeroExit: true,
- },
- ).pipe(
- Effect.catchTags({
- GitCommandError: (error) =>
- Effect.logWarning(
- "Git remote ref lookup failed; falling back to an empty remote ref list.",
- {
- operation: error.operation,
- command: error.command,
- cwd: error.cwd,
- detail: error.detail,
- cause: error,
- },
- ).pipe(
- Effect.as({
- exitCode: ChildProcessSpawner.ExitCode(1),
- stdout: "",
- stderr: "",
- stdoutTruncated: false,
- stderrTruncated: false,
- } satisfies GitVcsDriver.ExecuteGitResult),
- ),
- }),
- );
-
- const remoteNamesResultEffect = executeGit(
- "GitVcsDriver.listRefs.remoteNames",
- input.cwd,
- ["remote"],
- {
- timeoutMs: 5_000,
- allowNonZeroExit: true,
- },
- ).pipe(
- Effect.catchTags({
- GitCommandError: (error) =>
- Effect.logWarning(
- "Git remote name lookup failed; falling back to an empty remote name list.",
- {
- operation: error.operation,
- command: error.command,
- cwd: error.cwd,
- detail: error.detail,
- cause: error,
- },
- ).pipe(
- Effect.as({
- exitCode: ChildProcessSpawner.ExitCode(1),
- stdout: "",
- stderr: "",
- stdoutTruncated: false,
- stderrTruncated: false,
- } satisfies GitVcsDriver.ExecuteGitResult),
- ),
- }),
- );
+ const byRecencyThenName = (
+ left: { readonly ref: VcsRef; readonly lastCommit: number },
+ right: { readonly ref: VcsRef; readonly lastCommit: number },
+ ) =>
+ left.lastCommit !== right.lastCommit
+ ? right.lastCommit - left.lastCommit
+ : left.ref.name.localeCompare(right.ref.name);
- const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =
- yield* Effect.all(
- [
- executeGit(
- "GitVcsDriver.listRefs.defaultRef",
- input.cwd,
- ["symbolic-ref", "refs/remotes/origin/HEAD"],
- {
- timeoutMs: 5_000,
- allowNonZeroExit: true,
- },
- ),
- executeGit(
- "GitVcsDriver.listRefs.worktreeList",
- input.cwd,
- ["worktree", "list", "--porcelain"],
- {
- timeoutMs: 5_000,
- allowNonZeroExit: true,
- },
- ),
- remoteBranchResultEffect,
- remoteNamesResultEffect,
- branchRecencyPromise,
- ],
- { concurrency: "unbounded" },
- );
+ return {
+ localBranches: localBranches.toSorted(byRecencyThenName).map(({ ref }) => ref),
+ remoteBranches: remoteBranches.toSorted(byRecencyThenName).map(({ ref }) => ref),
+ hasPrimaryRemote: remoteNames.includes("origin"),
+ } satisfies GitRefsSnapshot;
+ });
- const remoteNames =
- remoteNamesResult.exitCode === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
- if (remoteBranchResult.exitCode !== 0 && remoteBranchResult.stderr.trim().length > 0) {
- yield* Effect.logWarning(
- `GitVcsDriver.listRefs: remote refName lookup returned code ${remoteBranchResult.exitCode} for ${input.cwd}: ${remoteBranchResult.stderr.trim()}. Falling back to an empty remote refName list.`,
- );
+ const listRefsEpochByCommonDir = new Map<string, number>();
+ let listRefsEpochSequence = 0;
+ const bumpListRefsEpoch = (gitCommonDir: string): number => {
+ const nextEpoch = ++listRefsEpochSequence;
+ listRefsEpochByCommonDir.delete(gitCommonDir);
+ listRefsEpochByCommonDir.set(gitCommonDir, nextEpoch);
+ if (listRefsEpochByCommonDir.size > LIST_REFS_SNAPSHOT_CACHE_CAPACITY) {
+ const oldestKey = listRefsEpochByCommonDir.keys().next().value;
+ if (oldestKey !== undefined) {
+ listRefsEpochByCommonDir.delete(oldestKey);
}
- if (remoteNamesResult.exitCode !== 0 && remoteNamesResult.stderr.trim().length > 0) {
- yield* Effect.logWarning(
- `GitVcsDriver.listRefs: remote name lookup returned code ${remoteNamesResult.exitCode} for ${input.cwd}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
- );
+ }
+ return nextEpoch;
+ };
+ const listRefsGenerationByCommonDir = new Map<string, number>();
+ let listRefsGenerationSequence = 0;
+ const setListRefsGeneration = (gitCommonDir: string, generation: number): number => {
+ listRefsGenerationByCommonDir.delete(gitCommonDir);
+ listRefsGenerationByCommonDir.set(gitCommonDir, generation);
+ if (listRefsGenerationByCommonDir.size > LIST_REFS_SNAPSHOT_CACHE_CAPACITY) {
+ const oldestKey = listRefsGenerationByCommonDir.keys().next().value;
+ if (oldestKey !== undefined) {
+ listRefsGenerationByCommonDir.delete(oldestKey);
}
-
- const defaultBranch =
- defaultRef.exitCode === 0
- ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
- : null;
-
- const worktreeMap = new Map<string, string>();
- if (worktreeList.exitCode === 0) {
- let currentPath: string | null = null;
- for (const line of worktreeList.stdout.split("\n")) {
- if (line.startsWith("worktree ")) {
- const candidatePath = line.slice("worktree ".length);
- const exists = yield* fileSystem.stat(candidatePath).pipe(
- Effect.map(() => true),
- Effect.orElseSucceed(() => false),
+ }
+ return generation;
+ };
+ const currentListRefsGeneration = (gitCommonDir: string): number => {
+ const current = listRefsGenerationByCommonDir.get(gitCommonDir);
+ return current === undefined
+ ? setListRefsGeneration(gitCommonDir, ++listRefsGenerationSequence)
+ : setListRefsGeneration(gitCommonDir, current);
+ };
+ const bumpListRefsGeneration = (gitCommonDir: string): number =>
+ setListRefsGeneration(gitCommonDir, ++listRefsGenerationSequence);
+ const listRefsSnapshotCache = yield* Cache.makeWith(
+ (cacheKey: GitRefsSnapshotCacheKey) => readGitRefsSnapshot(cacheKey.gitCommonDir),
+ {
+ capacity: LIST_REFS_SNAPSHOT_CACHE_CAPACITY,
+ timeToLive: (exit) => (Exit.isSuccess(exit) ? LIST_REFS_SNAPSHOT_CACHE_TTL : Duration.zero),
+ },
+ );
+ const listRefsRefreshSnapshotCache = yield* Cache.makeWith(
+ (cacheKey: GitRefsRefreshCacheKey) =>
+ Effect.suspend(() => {
+ const epoch = bumpListRefsEpoch(cacheKey.gitCommonDir);
+ return Cache.get(
+ listRefsSnapshotCache,
+ new GitRefsSnapshotCacheKey({ gitCommonDir: cacheKey.gitCommonDir, epoch }),
+ );
+ }),
+ {
+ capacity: LIST_REFS_SNAPSHOT_CACHE_CAPACITY,
+ timeToLive: (exit) =>
+ Exit.isSuccess(exit) ? LIST_REFS_REFRESH_COALESCE_TTL : LIST_REFS_REFRESH_FAILURE_COOLDOWN,
+ },
+ );
+ const resolveListRefsSnapshot = Effect.fn("resolveListRefsSnapshot")(function* (
+ gitCommonDir: string,
+ refresh: boolean,
+ ) {
+ while (true) {
+ const generation = currentListRefsGeneration(gitCommonDir);
+ const currentEpoch = listRefsEpochByCommonDir.get(gitCommonDir);
+ const snapshot =
+ refresh || currentEpoch === undefined
+ ? // The refresh cache owns the complete snapshot read, rather than only the
+ // epoch bump. Slow repositories therefore remain singleflight for the
+ // entire Git scan even when more refresh requests arrive after the
+ // coalescing TTL would otherwise have elapsed.
+ yield* Cache.get(
+ listRefsRefreshSnapshotCache,
+ new GitRefsRefreshCacheKey({ gitCommonDir, generation }),
+ )
+ : yield* Cache.get(
+ listRefsSnapshotCache,
+ new GitRefsSnapshotCacheKey({ gitCommonDir, epoch: currentEpoch }),
);
- currentPath = exists ? candidatePath : null;
- } else if (line.startsWith("branch refs/heads/") && currentPath) {
- worktreeMap.set(line.slice("branch refs/heads/".length), currentPath);
- } else if (line === "") {
- currentPath = null;
- }
- }
+ if (currentListRefsGeneration(gitCommonDir) === generation) {
+ return snapshot;
}
+ }
+ });
+ const invalidateListRefsSnapshot = Effect.fn("invalidateListRefsSnapshot")(function* (
+ cwd: string,
+ ) {
+ const repositoryPathsCacheKey = normalizeRepositoryPathsCacheKey(cwd);
+ const repositoryPaths = yield* Cache.get(repositoryPathsCache, repositoryPathsCacheKey);
+ if (repositoryPaths === null) return;
+ const previousGeneration = currentListRefsGeneration(repositoryPaths.gitCommonDir);
+ bumpListRefsGeneration(repositoryPaths.gitCommonDir);
+ bumpListRefsEpoch(repositoryPaths.gitCommonDir);
+ yield* Cache.invalidate(
+ listRefsRefreshSnapshotCache,
+ new GitRefsRefreshCacheKey({
+ gitCommonDir: repositoryPaths.gitCommonDir,
+ generation: previousGeneration,
+ }),
+ );
+ yield* Cache.invalidate(repositoryPathsRefreshCache, repositoryPathsCacheKey);
+ yield* Cache.invalidate(repositoryPathsCache, repositoryPathsCacheKey);
+ });
- const localBranches = Arr.filterMap(localBranchResult.stdout.split("\n"), (line) => {
- const refName = parseBranchLine(line);
- return refName === null
- ? Result.failVoid
- : Result.succeed({
- name: refName.name,
- current: refName.current,
- isRemote: false,
- isDefault: refName.name === defaultBranch,
- worktreePath: worktreeMap.get(refName.name) ?? null,
- });
- }).toSorted((a, b) => {
- const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;
- const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;
- if (aPriority !== bPriority) return aPriority - bPriority;
-
- const aLastCommit = branchLastCommit.get(a.name) ?? 0;
- const bLastCommit = branchLastCommit.get(b.name) ?? 0;
- if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
- return a.name.localeCompare(b.name);
- });
-
- const remoteBranches =
- remoteBranchResult.exitCode === 0
- ? Arr.filterMap(remoteBranchResult.stdout.split("\n"), (line) => {
- const refName = parseBranchLine(line);
- if (refName === null) {
- return Result.failVoid;
- }
- const parsedRemoteRef = parseRemoteRefWithRemoteNames(refName.name, remoteNames);
- const remoteBranch: {
- name: string;
- current: boolean;
- isRemote: boolean;
- remoteName?: string;
- isDefault: boolean;
- worktreePath: string | null;
- } = {
- name: refName.name,
- current: false,
- isRemote: true,
- // origin/HEAD's target is the repo default even when no local
- // copy of the default branch exists.
- isDefault:
- defaultBranch !== null &&
- parsedRemoteRef?.remoteName === "origin" &&
- parsedRemoteRef.branchName === defaultBranch,
- worktreePath: null,
- };
- if (parsedRemoteRef) {
- remoteBranch.remoteName = parsedRemoteRef.remoteName;
- }
- return Result.succeed(remoteBranch);
- }).toSorted((a, b) => {
- const aLastCommit = branchLastCommit.get(a.name) ?? 0;
- const bLastCommit = branchLastCommit.get(b.name) ?? 0;
- if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
- return a.name.localeCompare(b.name);
- })
- : [];
+ const listRefs: GitVcsDriver.GitVcsDriver["Service"]["listRefs"] = Effect.fn("listRefs")(
+ function* (input) {
+ const repositoryPaths = yield* resolveRepositoryPaths(input.cwd, input.refresh === true).pipe(
+ Effect.catchTags({
+ GitCommandError: (error) =>
+ isMissingGitCwdError(error) ? Effect.succeed(null) : Effect.fail(error),
+ }),
+ );
+ if (repositoryPaths === null) {
+ return {
+ refs: [],
+ isRepo: false,
+ hasPrimaryRemote: false,
+ nextCursor: null,
+ totalCount: 0,
+ };
+ }
+ const snapshot = yield* resolveListRefsSnapshot(
+ repositoryPaths.gitCommonDir,
+ input.refresh === true,
+ );
+ const hasCurrentWorktreeBranch =
+ repositoryPaths.worktreeRoot !== null &&
+ snapshot.localBranches.some((ref) => ref.worktreePath === repositoryPaths.worktreeRoot);
+ const localBranches = snapshot.localBranches.map((ref) => ({
+ ...ref,
+ current: hasCurrentWorktreeBranch
+ ? ref.worktreePath === repositoryPaths.worktreeRoot
+ : ref.name === repositoryPaths.currentBranch,
+ }));
const combinedBranches = input.includeMatchingRemoteRefs
- ? [...localBranches, ...remoteBranches]
- : dedupeRemoteBranchesWithLocalMatches([...localBranches, ...remoteBranches]);
+ ? [...localBranches, ...snapshot.remoteBranches]
+ : dedupeRemoteBranchesWithLocalMatches([...localBranches, ...snapshot.remoteBranches]);
// Keep current/default refs on the first page even when the default
// only exists as origin/<default> (remote refs sort after all locals).
- const allBranches = combinedBranches.toSorted((a, b) => {
- const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;
- const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;
- return aPriority - bPriority;
+ const allBranches = combinedBranches.toSorted((left, right) => {
+ const leftPriority = left.current ? 0 : left.isDefault ? 1 : 2;
+ const rightPriority = right.current ? 0 : right.isDefault ? 1 : 2;
+ return leftPriority - rightPriority;
});
const branchesForKind =
input.refKind === "local"
@@ -2254,7 +2446,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
return {
refs: [...refs.refs],
isRepo: true,
- hasPrimaryRemote: remoteNames.includes("origin"),
+ hasPrimaryRemote: snapshot.hasPrimaryRemote,
nextCursor: refs.nextCursor,
totalCount: refs.totalCount,
};
@@ -2548,6 +2740,25 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
}),
);
+ const withListRefsInvalidation = <A, E>(
+ cwd: string,
+ effect: Effect.Effect<A, E>,
+ ): Effect.Effect<A, E> =>
+ effect.pipe(Effect.ensuring(invalidateListRefsSnapshot(cwd).pipe(Effect.ignore)));
+ const initRepoWithListRefsInvalidation: GitVcsDriver.GitVcsDriver["Service"]["initRepo"] = (
+ input,
+ ) =>
+ initRepo(input).pipe(
+ Effect.ensuring(
+ Effect.gen(function* () {
+ const cacheKey = normalizeRepositoryPathsCacheKey(input.cwd);
+ yield* Cache.invalidate(repositoryPathsRefreshCache, cacheKey);
+ yield* Cache.invalidate(repositoryPathsCache, cacheKey);
+ yield* invalidateListRefsSnapshot(input.cwd).pipe(Effect.ignore);
+ }),
+ ),
+ );
+
return GitVcsDriver.GitVcsDriver.of({
execute,
status,
@@ -2555,27 +2766,31 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
statusDetailsLocal,
statusDetailsRemote,
prepareCommitContext,
- commit,
- pushCurrentBranch,
- pullCurrentBranch,
+ commit: (cwd, subject, body, options) =>
+ withListRefsInvalidation(cwd, commit(cwd, subject, body, options)),
+ pushCurrentBranch: (cwd, fallbackBranch, options) =>
+ withListRefsInvalidation(cwd, pushCurrentBranch(cwd, fallbackBranch, options)),
+ pullCurrentBranch: (cwd) => withListRefsInvalidation(cwd, pullCurrentBranch(cwd)),
readRangeContext,
getReviewDiffPreview,
readConfigValue,
listRefs,
- createWorktree,
- fetchPullRequestBranch,
- ensureRemote,
+ createWorktree: (input) => withListRefsInvalidation(input.cwd, createWorktree(input)),
+ fetchPullRequestBranch: (input) =>
+ withListRefsInvalidation(input.cwd, fetchPullRequestBranch(input)),
+ ensureRemote: (input) => withListRefsInvalidation(input.cwd, ensureRemote(input)),
resolvePrimaryRemoteName,
- fetchRemote,
+ fetchRemote: (input) => withListRefsInvalidation(input.cwd, fetchRemote(input)),
resolveRemoteTrackingCommit,
- fetchRemoteBranch,
- fetchRemoteTrackingBranch,
- setBranchUpstream,
- removeWorktree,
- renameBranch,
- createRef,
- switchRef,
- initRepo,
+ fetchRemoteBranch: (input) => withListRefsInvalidation(input.cwd, fetchRemoteBranch(input)),
+ fetchRemoteTrackingBranch: (input) =>
+ withListRefsInvalidation(input.cwd, fetchRemoteTrackingBranch(input)),
+ setBranchUpstream: (input) => withListRefsInvalidation(input.cwd, setBranchUpstream(input)),
+ removeWorktree: (input) => withListRefsInvalidation(input.cwd, removeWorktree(input)),
+ renameBranch: (input) => withListRefsInvalidation(input.cwd, renameBranch(input)),
+ createRef: (input) => withListRefsInvalidation(input.cwd, createRef(input)),
+ switchRef: (input) => withListRefsInvalidation(input.cwd, switchRef(input)),
+ initRepo: initRepoWithListRefsInvalidation,
listLocalBranchNames,
});
});
diff --git a/apps/web/src/components/BranchToolbarBranchSelector.tsx b/apps/web/src/components/BranchToolbarBranchSelector.tsx
index c4ae50a9e..9b4cbf2b4 100644
--- a/apps/web/src/components/BranchToolbarBranchSelector.tsx
+++ b/apps/web/src/components/BranchToolbarBranchSelector.tsx
@@ -24,6 +24,7 @@ import { useComposerDraftStore, type DraftId } from "../composerDraftStore";
import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
import { readLocalApi } from "../localApi";
import { useOpenPrLink } from "../lib/openPullRequestLink";
+import { shouldLoadNextBranchPageAfterScroll } from "../state/paginatedBranches";
import { usePaginatedBranches } from "../state/queries";
import { useProject, useThread } from "../state/entities";
import { useEnvironmentQuery } from "../state/query";
@@ -230,7 +231,7 @@ export function BranchToolbarBranchSelector({
const refs = branchRefState.refs;
const hasNextPage =
branchRefState.data?.nextCursor !== null && branchRefState.data?.nextCursor !== undefined;
- const isFetchingNextPage = branchRefState.isPending && branchRefState.data !== null;
+ const isFetchingNextPage = branchRefState.isFetchingNextPage;
const isInitialBranchesLoadPending = branchRefState.isPending && branchRefState.data === null;
const currentGitBranch =
branchStatusQuery.data?.refName ?? refs.find((refName) => refName.current)?.name ?? null;
@@ -505,19 +506,16 @@ export function BranchToolbarBranchSelector({
// ---------------------------------------------------------------------------
// Combobox / list plumbing
// ---------------------------------------------------------------------------
- const handleOpenChange = useCallback(
- (open: boolean) => {
- setIsBranchMenuOpen(open);
- if (!open) {
- setBranchQuery("");
- return;
- }
- branchRefState.refresh();
- },
- [branchRefState.refresh],
- );
-
const branchListScrollElementRef = useRef<HTMLElement | null>(null);
+ const previousBranchListScrollTopRef = useRef<number | null>(null);
+ const handleOpenChange = useCallback((open: boolean) => {
+ previousBranchListScrollTopRef.current = null;
+ setIsBranchMenuOpen(open);
+ if (!open) {
+ setBranchQuery("");
+ }
+ }, []);
+
const [showTopBranchScrollFade, setShowTopBranchScrollFade] = useState(false);
const [showBottomBranchScrollFade, setShowBottomBranchScrollFade] = useState(false);
const fetchNextBranchPage = useCallback(() => {
@@ -528,18 +526,24 @@ export function BranchToolbarBranchSelector({
branchRefState.loadNext();
}, [branchRefState.loadNext, hasNextPage, isFetchingNextPage]);
const maybeFetchNextBranchPage = useCallback(() => {
- if (!isBranchMenuOpen || !hasNextPage || isFetchingNextPage) {
- return;
- }
-
const scrollElement = branchListScrollElementRef.current;
if (!scrollElement) {
return;
}
- const distanceFromBottom =
- scrollElement.scrollHeight - scrollElement.scrollTop - scrollElement.clientHeight;
- if (distanceFromBottom > 96) {
+ const previousScrollTop = previousBranchListScrollTopRef.current;
+ previousBranchListScrollTopRef.current = scrollElement.scrollTop;
+ if (
+ !isBranchMenuOpen ||
+ !hasNextPage ||
+ isFetchingNextPage ||
+ !shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop,
+ scrollTop: scrollElement.scrollTop,
+ scrollHeight: scrollElement.scrollHeight,
+ clientHeight: scrollElement.clientHeight,
+ })
+ ) {
return;
}
@@ -589,10 +593,6 @@ export function BranchToolbarBranchSelector({
void branchListRef.current?.scrollToOffset?.({ offset: 0, animated: false });
}, [deferredTrimmedBranchQuery, isBranchMenuOpen]);
- useEffect(() => {
- maybeFetchNextBranchPage();
- }, [refs.length, maybeFetchNextBranchPage]);
-
const triggerLabel = resolveBranchTriggerLabel({
activeWorktreePath,
effectiveEnvMode,
@@ -791,14 +791,10 @@ export function BranchToolbarBranchSelector({
renderItem={({ item, index }) => renderPickerItem(item, index)}
estimatedItemSize={28}
drawDistance={336}
- onEndReached={() => {
- if (hasNextPage && !isFetchingNextPage) {
- fetchNextBranchPage();
- }
- }}
onLayout={() => {
updateBranchListScrollFades();
- maybeFetchNextBranchPage();
+ previousBranchListScrollTopRef.current =
+ branchListScrollElementRef.current?.scrollTop ?? null;
}}
onScroll={() => {
updateBranchListScrollFades();
diff --git a/apps/web/src/connection/storage.ts b/apps/web/src/connection/storage.ts
index 04d237a50..5da93e3f5 100644
--- a/apps/web/src/connection/storage.ts
+++ b/apps/web/src/connection/storage.ts
@@ -105,6 +105,8 @@ function persistenceError(
| "save-server-config"
| "load-vcs-refs"
| "save-vcs-refs"
+ | "remove-vcs-refs"
+ | "clear-vcs-refs"
| "clear-environment",
cause: unknown,
) {
@@ -619,6 +621,18 @@ export const connectionStorageLayer = Layer.effectContext(
: persistenceError("save-vcs-refs", cause),
),
),
+ removeVcsRefs: (environmentId, cwd) =>
+ removeDatabaseValue(
+ database,
+ VCS_REFS_STORE_NAME,
+ vcsRefsCacheKey(environmentId, cwd),
+ ).pipe(Effect.mapError((cause) => persistenceError("remove-vcs-refs", cause))),
+ clearVcsRefs: (environmentId) =>
+ removeDatabaseValuesInRange(
+ database,
+ VCS_REFS_STORE_NAME,
+ IDBKeyRange.bound(`${environmentId}:`, `${environmentId}:\uffff`),
+ ).pipe(Effect.mapError((cause) => persistenceError("clear-vcs-refs", cause))),
removeThread: (environmentId, threadId) =>
removeDatabaseValue(
database,
diff --git a/apps/web/src/state/paginatedBranches.test.ts b/apps/web/src/state/paginatedBranches.test.ts
new file mode 100644
index 000000000..bf229acd3
--- /dev/null
+++ b/apps/web/src/state/paginatedBranches.test.ts
@@ -0,0 +1,111 @@
+import type { VcsListRefsResult } from "@t3tools/contracts";
+import { AsyncResult } from "effect/unstable/reactivity";
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+ isPaginatedBranchesNextPagePending,
+ shouldLoadNextBranchPageAfterScroll,
+} from "./paginatedBranches";
+
+const FIRST_PAGE: VcsListRefsResult = {
+ refs: [],
+ isRepo: true,
+ hasPrimaryRemote: true,
+ nextCursor: 100,
+ totalCount: 150,
+};
+
+const LAST_PAGE: VcsListRefsResult = {
+ ...FIRST_PAGE,
+ nextCursor: null,
+};
+
+describe("paginated branch loading state", () => {
+ it("does not label a first-page background refresh as loading more refs", () => {
+ expect(
+ isPaginatedBranchesNextPagePending([
+ AsyncResult.success(FIRST_PAGE, {
+ waiting: true,
+ }),
+ ]),
+ ).toBe(false);
+ });
+
+ it("only reports loading more while a new cursor has no value", () => {
+ expect(
+ isPaginatedBranchesNextPagePending([
+ AsyncResult.success(FIRST_PAGE),
+ AsyncResult.initial<VcsListRefsResult>(true),
+ ]),
+ ).toBe(true);
+
+ expect(
+ isPaginatedBranchesNextPagePending([
+ AsyncResult.success(FIRST_PAGE),
+ AsyncResult.success(LAST_PAGE),
+ ]),
+ ).toBe(false);
+ });
+});
+
+describe("paginated branch scroll trigger", () => {
+ it("does not load from mount, layout, or an unchanged scroll position", () => {
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: null,
+ scrollTop: 0,
+ scrollHeight: 224,
+ clientHeight: 224,
+ }),
+ ).toBe(false);
+
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: 120,
+ scrollTop: 120,
+ scrollHeight: 344,
+ clientHeight: 224,
+ }),
+ ).toBe(false);
+ });
+
+ it("does not load when scrolling upward near the bottom", () => {
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: 160,
+ scrollTop: 150,
+ scrollHeight: 450,
+ clientHeight: 224,
+ }),
+ ).toBe(false);
+ });
+
+ it("loads only after a downward scroll reaches the end threshold", () => {
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: 0,
+ scrollTop: 100,
+ scrollHeight: 800,
+ clientHeight: 224,
+ }),
+ ).toBe(false);
+
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: 100,
+ scrollTop: 500,
+ scrollHeight: 800,
+ clientHeight: 224,
+ }),
+ ).toBe(true);
+
+ expect(
+ shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop: 499.5,
+ scrollTop: 500,
+ scrollHeight: 800,
+ clientHeight: 224,
+ }),
+ ).toBe(true);
+ });
+});
diff --git a/apps/web/src/state/paginatedBranches.ts b/apps/web/src/state/paginatedBranches.ts
new file mode 100644
index 000000000..41809b2de
--- /dev/null
+++ b/apps/web/src/state/paginatedBranches.ts
@@ -0,0 +1,36 @@
+import type { VcsListRefsResult } from "@t3tools/contracts";
+import * as Option from "effect/Option";
+import { AsyncResult } from "effect/unstable/reactivity";
+
+const DEFAULT_NEXT_PAGE_DISTANCE_PX = 96;
+
+export function isPaginatedBranchesNextPagePending<E>(
+ results: ReadonlyArray<AsyncResult.AsyncResult<VcsListRefsResult, E>>,
+): boolean {
+ const lastResult = results.at(-1);
+ return (
+ results.length > 1 &&
+ lastResult?.waiting === true &&
+ Option.isNone(AsyncResult.value(lastResult))
+ );
+}
+
+export function shouldLoadNextBranchPageAfterScroll({
+ previousScrollTop,
+ scrollTop,
+ scrollHeight,
+ clientHeight,
+ distanceThreshold = DEFAULT_NEXT_PAGE_DISTANCE_PX,
+}: {
+ previousScrollTop: number | null;
+ scrollTop: number;
+ scrollHeight: number;
+ clientHeight: number;
+ distanceThreshold?: number;
+}): boolean {
+ if (previousScrollTop === null || scrollTop <= previousScrollTop) {
+ return false;
+ }
+
+ return scrollHeight - scrollTop - clientHeight <= distanceThreshold;
+}
diff --git a/apps/web/src/state/queries.ts b/apps/web/src/state/queries.ts
index 79737e610..745c9e700 100644
--- a/apps/web/src/state/queries.ts
+++ b/apps/web/src/state/queries.ts
@@ -18,6 +18,7 @@ import { useCallback, useEffect, useMemo, useState } from "react";
import { appAtomRegistry } from "../rpc/atomRegistry";
import { orchestrationEnvironment } from "./orchestration";
+import { isPaginatedBranchesNextPagePending } from "./paginatedBranches";
import { projectEnvironment } from "./projects";
import { useEnvironmentQuery } from "./query";
import { useEnvironmentThread } from "./threads";
@@ -142,6 +143,7 @@ export function usePaginatedBranches(target: VcsRefTarget) {
totalCount: Math.max(...values.map((value) => value.totalCount)),
};
const failed = results.find((result) => result._tag === "Failure");
+ const isFetchingNextPage = isPaginatedBranchesNextPagePending(results);
const error =
failed?._tag === "Failure"
? (() => {
@@ -176,6 +178,7 @@ export function usePaginatedBranches(target: VcsRefTarget) {
refs: data?.refs ?? EMPTY_REFS,
error,
isPending: results.some((result) => result.waiting),
+ isFetchingNextPage,
refresh,
loadNext,
};
diff --git a/packages/client-runtime/src/connection/registry.test.ts b/packages/client-runtime/src/connection/registry.test.ts
index c75cc2fad..9354db9c9 100644
--- a/packages/client-runtime/src/connection/registry.test.ts
+++ b/packages/client-runtime/src/connection/registry.test.ts
@@ -251,6 +251,8 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: (environmentId) =>
Ref.update(shellCache, (current) => {
const next = new Map(current);
diff --git a/packages/client-runtime/src/platform/persistence.ts b/packages/client-runtime/src/platform/persistence.ts
index 8723ac069..14a322bcd 100644
--- a/packages/client-runtime/src/platform/persistence.ts
+++ b/packages/client-runtime/src/platform/persistence.ts
@@ -30,6 +30,8 @@ export class ConnectionPersistenceError extends Schema.TaggedErrorClass<Connecti
"save-server-config",
"load-vcs-refs",
"save-vcs-refs",
+ "remove-vcs-refs",
+ "clear-vcs-refs",
"clear-environment",
]),
message: Schema.String,
@@ -102,6 +104,18 @@ export class EnvironmentCacheStore extends Context.Service<
cwd: string,
refs: VcsListRefsResult,
) => Effect.Effect<void, ConnectionPersistenceError>;
+ readonly removeVcsRefs: (
+ environmentId: EnvironmentId,
+ cwd: string,
+ ) => Effect.Effect<void, ConnectionPersistenceError>;
+ /**
+ * Removes every persisted branch-list snapshot for an environment. Git ref
+ * mutations are repository-wide, and linked worktrees may have cached the
+ * same refs under different working-directory keys.
+ */
+ readonly clearVcsRefs: (
+ environmentId: EnvironmentId,
+ ) => Effect.Effect<void, ConnectionPersistenceError>;
readonly clear: (
environmentId: EnvironmentId,
) => Effect.Effect<void, ConnectionPersistenceError>;
diff --git a/packages/client-runtime/src/state/runtime.ts b/packages/client-runtime/src/state/runtime.ts
index 7bfeb81f5..fb5e9a0ab 100644
--- a/packages/client-runtime/src/state/runtime.ts
+++ b/packages/client-runtime/src/state/runtime.ts
@@ -32,6 +32,17 @@ interface EnvironmentAtomOptions<Input, A, E, R> {
}>;
}
+interface EnvironmentCommandAtomOptions<Input, A, E, R> extends Omit<
+ EnvironmentAtomOptions<Input, A, E, R>,
+ "execute"
+> {
+ readonly execute: (
+ input: Input,
+ registry: AtomRegistry.AtomRegistry,
+ environmentId: EnvironmentIdType,
+ ) => Effect.Effect<A, E, R>;
+}
+
interface EnvironmentQueryAtomOptions<Input, A, E, R> extends EnvironmentAtomOptions<
Input,
A,
@@ -520,13 +531,17 @@ export function createEnvironmentSubscriptionAtomFamily<R, ER, Input, A, E>(
export function createEnvironmentCommand<R, ER, Input, A, E>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
- options: EnvironmentAtomOptions<Input, A, E, EnvironmentSupervisor | R>,
+ options: EnvironmentCommandAtomOptions<Input, A, E, EnvironmentSupervisor | R>,
) {
return createRuntimeCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
- execute: (target) => runInEnvironment(target.environmentId, options.execute(target.input)),
+ execute: (target, registry) =>
+ runInEnvironment(
+ target.environmentId,
+ options.execute(target.input, registry, target.environmentId),
+ ),
});
}
@@ -616,13 +631,36 @@ export function createEnvironmentRpcCommand<R, ER, TTag extends EnvironmentUnary
readonly environmentId: EnvironmentIdType;
readonly input: EnvironmentRpcInput<TTag>;
}>;
+ readonly onSuccess?: (
+ target: {
+ readonly environmentId: EnvironmentIdType;
+ readonly input: EnvironmentRpcInput<TTag>;
+ },
+ registry: AtomRegistry.AtomRegistry,
+ ) => Effect.Effect<void, never, R>;
+ readonly onSettled?: (
+ target: {
+ readonly environmentId: EnvironmentIdType;
+ readonly input: EnvironmentRpcInput<TTag>;
+ },
+ registry: AtomRegistry.AtomRegistry,
+ ) => Effect.Effect<void, never, R>;
},
) {
return createEnvironmentCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
- execute: (input: EnvironmentRpcInput<TTag>) => request(options.tag, input),
+ execute: (input: EnvironmentRpcInput<TTag>, registry, environmentId) => {
+ const target = {
+ environmentId,
+ input,
+ };
+ return request(options.tag, input).pipe(
+ Effect.tap(() => options.onSuccess?.(target, registry) ?? Effect.void),
+ Effect.ensuring(options.onSettled?.(target, registry) ?? Effect.void),
+ );
+ },
});
}
diff --git a/packages/client-runtime/src/state/server.test.ts b/packages/client-runtime/src/state/server.test.ts
index 7ced26f0f..ddc881331 100644
--- a/packages/client-runtime/src/state/server.test.ts
+++ b/packages/client-runtime/src/state/server.test.ts
@@ -152,6 +152,8 @@ describe("server state projection", () => {
saveServerConfig: (_environmentId, config) => Queue.offer(savedConfigs, config),
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
@@ -211,6 +213,8 @@ describe("server state projection", () => {
saveServerConfig: (_environmentId, config) => Queue.offer(savedConfigs, config),
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
diff --git a/packages/client-runtime/src/state/shell-sync.test.ts b/packages/client-runtime/src/state/shell-sync.test.ts
index a4514d5f0..62d2a2c28 100644
--- a/packages/client-runtime/src/state/shell-sync.test.ts
+++ b/packages/client-runtime/src/state/shell-sync.test.ts
@@ -87,6 +87,8 @@ describe("environment shell synchronization", () => {
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
// Cold cache with no HTTP snapshot available → falls back to the
@@ -201,6 +203,8 @@ describe("environment shell synchronization", () => {
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
const snapshotLoader = ShellSnapshotLoader.of({
@@ -270,6 +274,8 @@ describe("environment shell synchronization", () => {
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
const snapshotLoader = ShellSnapshotLoader.of({
diff --git a/packages/client-runtime/src/state/sourceControl.test.ts b/packages/client-runtime/src/state/sourceControl.test.ts
new file mode 100644
index 000000000..393be8e32
--- /dev/null
+++ b/packages/client-runtime/src/state/sourceControl.test.ts
@@ -0,0 +1,169 @@
+import {
+ EnvironmentId,
+ WS_METHODS,
+ type SourceControlPublishRepositoryResult,
+} from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
+
+import {
+ AVAILABLE_CONNECTION_STATE,
+ PrimaryConnectionTarget,
+ type PreparedConnection,
+ type SupervisorConnectionState,
+} from "../connection/model.ts";
+import * as EnvironmentRegistry from "../connection/registry.ts";
+import * as EnvironmentSupervisor from "../connection/supervisor.ts";
+import * as Persistence from "../platform/persistence.ts";
+import { EnvironmentRpcUnavailableError } from "../rpc/client.ts";
+import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
+import type { RpcSession } from "../rpc/session.ts";
+import { createSourceControlEnvironmentAtoms } from "./sourceControl.ts";
+import { vcsRefsCacheStateAtom } from "./vcsRefInvalidation.ts";
+
+const TARGET = new PrimaryConnectionTarget({
+ environmentId: EnvironmentId.make("environment-1"),
+ label: "Test environment",
+ httpBaseUrl: "https://environment.example.test",
+ wsBaseUrl: "wss://environment.example.test",
+});
+
+const PUBLISH_RESULT: SourceControlPublishRepositoryResult = {
+ repository: {
+ provider: "github",
+ nameWithOwner: "t3tools/t3code",
+ url: "https://github.com/t3tools/t3code",
+ sshUrl: "[email protected]:t3tools/t3code.git",
+ },
+ remoteName: "origin",
+ remoteUrl: "[email protected]:t3tools/t3code.git",
+ branch: "main",
+ upstreamBranch: "origin/main",
+ status: "pushed",
+};
+
+function session(client: WsRpcProtocolClient): RpcSession {
+ return {
+ client,
+ initialConfig: Effect.never,
+ ready: Effect.void,
+ probe: Effect.void,
+ closed: Effect.never,
+ };
+}
+
+describe("source control environment atoms", () => {
+ it.effect("invalidates cached refs after successful and failed publishing", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const connectionState: SupervisorConnectionState = {
+ ...AVAILABLE_CONNECTION_STATE,
+ desired: true,
+ network: "online",
+ phase: "connected",
+ attempt: 1,
+ generation: 1,
+ };
+ let publishAttempts = 0;
+ const client = {
+ [WS_METHODS.sourceControlPublishRepository]: () => {
+ publishAttempts += 1;
+ return publishAttempts === 1
+ ? Effect.succeed(PUBLISH_RESULT)
+ : Effect.fail(
+ new EnvironmentRpcUnavailableError({
+ environmentId: TARGET.environmentId,
+ message: "push failed after adding the remote",
+ }),
+ );
+ },
+ } as unknown as WsRpcProtocolClient;
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target: TARGET,
+ state: yield* SubscriptionRef.make(connectionState),
+ session: yield* SubscriptionRef.make(Option.some(session(client))),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+ const run: EnvironmentRegistry.EnvironmentRegistry["Service"]["run"] = (
+ _environmentId,
+ effect,
+ ) => Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
+ const environmentRegistry = EnvironmentRegistry.EnvironmentRegistry.of({
+ run,
+ } as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
+ const removed = new Array<string>();
+ const cache = Persistence.EnvironmentCacheStore.of({
+ loadShell: () => Effect.succeed(Option.none()),
+ saveShell: () => Effect.void,
+ loadThread: () => Effect.succeed(Option.none()),
+ saveThread: () => Effect.void,
+ removeThread: () => Effect.void,
+ loadServerConfig: () => Effect.succeed(Option.none()),
+ saveServerConfig: () => Effect.void,
+ loadVcsRefs: () => Effect.succeed(Option.none()),
+ saveVcsRefs: () => Effect.void,
+ removeVcsRefs: (environmentId, cwd) =>
+ Effect.sync(() => {
+ removed.push(`${environmentId}:${cwd}`);
+ }),
+ clearVcsRefs: (environmentId) =>
+ Effect.sync(() => {
+ removed.push(`${environmentId}:*`);
+ }),
+ clear: () => Effect.void,
+ });
+ const runtime = Atom.runtime(
+ Layer.merge(
+ Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry),
+ Layer.succeed(Persistence.EnvironmentCacheStore, cache),
+ ),
+ );
+ const atoms = createSourceControlEnvironmentAtoms(runtime);
+ const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
+ Effect.sync(() => registry.dispose()),
+ );
+ const state = vcsRefsCacheStateAtom({ environmentId: TARGET.environmentId });
+
+ expect(registry.get(state).revision).toBe(0);
+ const publishResult = yield* Effect.promise(() =>
+ atoms.publishRepository.run(registry, {
+ environmentId: TARGET.environmentId,
+ input: {
+ cwd: "/repo",
+ provider: "github",
+ repository: "t3tools/t3code",
+ visibility: "private",
+ },
+ }),
+ );
+
+ expect(AsyncResult.isSuccess(publishResult)).toBe(true);
+ expect(registry.get(state).revision).toBe(1);
+ expect(removed).toEqual([`${TARGET.environmentId}:*`]);
+
+ const failedPublish = yield* Effect.promise(() =>
+ atoms.publishRepository.run(registry, {
+ environmentId: TARGET.environmentId,
+ input: {
+ cwd: "/repo",
+ provider: "github",
+ repository: "t3tools/t3code",
+ visibility: "private",
+ },
+ }),
+ );
+
+ expect(AsyncResult.isFailure(failedPublish)).toBe(true);
+ expect(registry.get(state).revision).toBe(2);
+ expect(removed).toEqual([`${TARGET.environmentId}:*`, `${TARGET.environmentId}:*`]);
+ }),
+ ),
+ );
+});
diff --git a/packages/client-runtime/src/state/sourceControl.ts b/packages/client-runtime/src/state/sourceControl.ts
index 5bff2fa77..c1598b49e 100644
--- a/packages/client-runtime/src/state/sourceControl.ts
+++ b/packages/client-runtime/src/state/sourceControl.ts
@@ -7,10 +7,12 @@ import {
createEnvironmentRpcQueryAtomFamily,
} from "./runtime.ts";
import type { EnvironmentRegistry } from "../connection/registry.ts";
+import { EnvironmentCacheStore } from "../platform/persistence.ts";
import { vcsCommandConcurrency, vcsCommandScheduler } from "./vcsCommandScheduler.ts";
+import { invalidateCachedVcsRefs } from "./vcsRefInvalidation.ts";
export function createSourceControlEnvironmentAtoms<R, E>(
- runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,
+ runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>,
) {
const commandScheduler = createAtomCommandScheduler();
return {
@@ -36,6 +38,11 @@ export function createSourceControlEnvironmentAtoms<R, E>(
tag: WS_METHODS.sourceControlPublishRepository,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: (target, registry) =>
+ invalidateCachedVcsRefs(registry, {
+ environmentId: target.environmentId,
+ cwd: target.input.cwd,
+ }),
}),
};
}
diff --git a/packages/client-runtime/src/state/threads-sync.test.ts b/packages/client-runtime/src/state/threads-sync.test.ts
index 8d0e4d0a3..43cdc1590 100644
--- a/packages/client-runtime/src/state/threads-sync.test.ts
+++ b/packages/client-runtime/src/state/threads-sync.test.ts
@@ -217,6 +217,8 @@ const makeHarness = Effect.fn("TestEnvironmentThreads.makeHarness")(function* (o
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(Option.none()),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
const threadState = yield* makeEnvironmentThreadState(THREAD_ID).pipe(
diff --git a/packages/client-runtime/src/state/vcs.test.ts b/packages/client-runtime/src/state/vcs.test.ts
index 60a128a5a..0a6264c62 100644
--- a/packages/client-runtime/src/state/vcs.test.ts
+++ b/packages/client-runtime/src/state/vcs.test.ts
@@ -1,12 +1,19 @@
-import { EnvironmentId, WS_METHODS, type VcsListRefsResult } from "@t3tools/contracts";
+import {
+ EnvironmentId,
+ WS_METHODS,
+ type VcsListRefsInput,
+ type VcsListRefsResult,
+} from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as TestClock from "effect/testing/TestClock";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
import {
AVAILABLE_CONNECTION_STATE,
@@ -14,11 +21,23 @@ import {
type PreparedConnection,
type SupervisorConnectionState,
} from "../connection/model.ts";
+import * as EnvironmentRegistry from "../connection/registry.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import * as Persistence from "../platform/persistence.ts";
+import { EnvironmentRpcUnavailableError } from "../rpc/client.ts";
import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
import type { RpcSession } from "../rpc/session.ts";
-import { makeCachedVcsRefsChanges } from "./vcs.ts";
+
+import {
+ commitVcsRefsRefresh,
+ createVcsEnvironmentAtoms,
+ makeCachedVcsRefsChanges,
+} from "./vcs.ts";
+import {
+ invalidateCachedVcsRefs,
+ invalidateVcsRefs,
+ vcsRefsCacheStateAtom,
+} from "./vcsRefInvalidation.ts";
const TARGET = new PrimaryConnectionTarget({
environmentId: EnvironmentId.make("environment-1"),
@@ -73,7 +92,10 @@ function session(client: WsRpcProtocolClient): RpcSession {
};
}
-function cacheWithRefs(refs: Option.Option<VcsListRefsResult>) {
+function cacheWithRefs(
+ refs: Option.Option<VcsListRefsResult>,
+ overrides: Partial<Persistence.EnvironmentCacheStore["Service"]> = {},
+) {
return Persistence.EnvironmentCacheStore.of({
loadShell: () => Effect.succeed(Option.none()),
saveShell: () => Effect.void,
@@ -84,11 +106,345 @@ function cacheWithRefs(refs: Option.Option<VcsListRefsResult>) {
saveServerConfig: () => Effect.void,
loadVcsRefs: () => Effect.succeed(refs),
saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
+ ...overrides,
});
}
describe("cached VCS refs", () => {
+ it("invalidates all ref streams in the mutated environment", () => {
+ const registry = AtomRegistry.make();
+ const environment = {
+ environmentId: TARGET.environmentId,
+ };
+ const otherEnvironment = {
+ environmentId: EnvironmentId.make("environment-2"),
+ };
+
+ expect(registry.get(vcsRefsCacheStateAtom(environment))).toEqual({
+ revision: 0,
+ persistedCacheReadable: true,
+ });
+ expect(registry.get(vcsRefsCacheStateAtom(otherEnvironment))).toEqual({
+ revision: 0,
+ persistedCacheReadable: true,
+ });
+
+ invalidateVcsRefs(registry, environment);
+
+ expect(registry.get(vcsRefsCacheStateAtom(environment))).toEqual({
+ revision: 1,
+ persistedCacheReadable: true,
+ });
+ expect(registry.get(vcsRefsCacheStateAtom(otherEnvironment))).toEqual({
+ revision: 0,
+ persistedCacheReadable: true,
+ });
+ registry.dispose();
+ });
+
+ it.effect("preserves the caller's repository snapshot refresh policy", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const requests = yield* Ref.make<ReadonlyArray<VcsListRefsInput>>([]);
+ const client = {
+ [WS_METHODS.vcsListRefs]: (input: VcsListRefsInput) =>
+ Ref.update(requests, (current) => [...current, input]).pipe(Effect.as(LIVE_REFS)),
+ } as unknown as WsRpcProtocolClient;
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target: TARGET,
+ state: yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE),
+ session: yield* SubscriptionRef.make(Option.some(session(client))),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+
+ yield* Stream.unwrap(
+ makeCachedVcsRefsChanges({
+ cwd: "/repo",
+ limit: 20,
+ query: "release",
+ refKind: "remote",
+ }).pipe(
+ Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cacheWithRefs(Option.none())),
+ ),
+ ).pipe(Stream.runHead);
+
+ expect(yield* Ref.get(requests)).toEqual([
+ {
+ cwd: "/repo",
+ limit: 20,
+ query: "release",
+ refKind: "remote",
+ },
+ ]);
+
+ yield* Stream.unwrap(
+ makeCachedVcsRefsChanges({
+ cwd: "/repo",
+ limit: 20,
+ query: "release",
+ refKind: "remote",
+ refresh: true,
+ }).pipe(
+ Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cacheWithRefs(Option.none())),
+ ),
+ ).pipe(Stream.runHead);
+
+ expect(yield* Ref.get(requests)).toEqual([
+ {
+ cwd: "/repo",
+ limit: 20,
+ query: "release",
+ refKind: "remote",
+ },
+ {
+ cwd: "/repo",
+ limit: 20,
+ query: "release",
+ refKind: "remote",
+ refresh: true,
+ },
+ ]);
+ }),
+ ),
+ );
+
+ it.effect("does not repersist a refresh superseded by ref invalidation", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
+ Effect.sync(() => registry.dispose()),
+ );
+ const saved = yield* Ref.make<ReadonlyArray<VcsListRefsResult>>([]);
+ const clears = yield* Ref.make(0);
+ const revisionsObservedDuringClear = yield* Ref.make<ReadonlyArray<number>>([]);
+ const cache = cacheWithRefs(Option.none(), {
+ saveVcsRefs: (_environmentId, _cwd, refs) =>
+ Ref.update(saved, (current) => [...current, refs]),
+ clearVcsRefs: () =>
+ Effect.all([
+ Ref.update(clears, (count) => count + 1),
+ Ref.update(revisionsObservedDuringClear, (current) => [
+ ...current,
+ registry.get(vcsRefsCacheStateAtom(TARGET)).revision,
+ ]),
+ ]).pipe(Effect.asVoid),
+ });
+
+ yield* invalidateCachedVcsRefs(registry, {
+ environmentId: TARGET.environmentId,
+ cwd: "/repo-worktree",
+ }).pipe(Effect.provideService(Persistence.EnvironmentCacheStore, cache));
+
+ expect(
+ yield* commitVcsRefsRefresh(registry, cache, {
+ environmentId: TARGET.environmentId,
+ cwd: "/repo",
+ refs: CACHED_REFS,
+ expectedRevision: 0,
+ persist: true,
+ }),
+ ).toBe(false);
+
+ expect(yield* Ref.get(saved)).toEqual([]);
+ expect(yield* Ref.get(clears)).toBe(1);
+ expect(yield* Ref.get(revisionsObservedDuringClear)).toEqual([0]);
+ expect(registry.get(vcsRefsCacheStateAtom(TARGET))).toEqual({
+ revision: 1,
+ persistedCacheReadable: true,
+ });
+
+ expect(
+ yield* commitVcsRefsRefresh(registry, cache, {
+ environmentId: TARGET.environmentId,
+ cwd: "/repo",
+ refs: LIVE_REFS,
+ expectedRevision: 1,
+ persist: true,
+ }),
+ ).toBe(true);
+ expect(yield* Ref.get(saved)).toEqual([LIVE_REFS]);
+ }),
+ ),
+ );
+
+ it.effect("invalidates persisted refs when ref-affecting commands settle", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const expectedError = new EnvironmentRpcUnavailableError({
+ environmentId: TARGET.environmentId,
+ message: "pull failed after fetching refs",
+ });
+ const client = {
+ [WS_METHODS.vcsPull]: () => Effect.fail(expectedError),
+ [WS_METHODS.vcsRefreshStatus]: () => Effect.void,
+ } as unknown as WsRpcProtocolClient;
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target: TARGET,
+ state: yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE),
+ session: yield* SubscriptionRef.make(Option.some(session(client))),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+ const run: EnvironmentRegistry.EnvironmentRegistry["Service"]["run"] = (
+ _environmentId,
+ effect,
+ ) => Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
+ const environmentRegistry = EnvironmentRegistry.EnvironmentRegistry.of({
+ run,
+ } as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
+ const clears = yield* Ref.make(0);
+ const runtime = Atom.runtime(
+ Layer.merge(
+ Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry),
+ Layer.succeed(
+ Persistence.EnvironmentCacheStore,
+ cacheWithRefs(Option.none(), {
+ clearVcsRefs: () => Ref.update(clears, (count) => count + 1),
+ }),
+ ),
+ ),
+ );
+ const atoms = createVcsEnvironmentAtoms(runtime);
+ const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
+ Effect.sync(() => registry.dispose()),
+ );
+
+ const result = yield* Effect.promise(() =>
+ atoms.pull.run(registry, {
+ environmentId: TARGET.environmentId,
+ input: { cwd: "/repo" },
+ }),
+ );
+
+ expect(AsyncResult.isFailure(result)).toBe(true);
+ expect(yield* Ref.get(clears)).toBe(1);
+ expect(registry.get(vcsRefsCacheStateAtom(TARGET)).revision).toBe(1);
+
+ const refreshResult = yield* Effect.promise(() =>
+ atoms.refreshStatus.run(registry, {
+ environmentId: TARGET.environmentId,
+ input: { cwd: "/repo" },
+ }),
+ );
+
+ expect(AsyncResult.isSuccess(refreshResult)).toBe(true);
+ expect(yield* Ref.get(clears)).toBe(2);
+ expect(registry.get(vcsRefsCacheStateAtom(TARGET)).revision).toBe(2);
+ }),
+ ),
+ );
+
+ it.effect("suppresses persisted snapshots after an environment-wide clear fails", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
+ Effect.sync(() => registry.dispose()),
+ );
+ const persisted = yield* Ref.make<Option.Option<VcsListRefsResult>>(
+ Option.some(CACHED_REFS),
+ );
+ const loads = yield* Ref.make(0);
+ const clearAttempts = yield* Ref.make(0);
+ const cache = cacheWithRefs(Option.none(), {
+ loadVcsRefs: () =>
+ Ref.update(loads, (count) => count + 1).pipe(Effect.andThen(Ref.get(persisted))),
+ saveVcsRefs: (_environmentId, _cwd, refs) => Ref.set(persisted, Option.some(refs)),
+ clearVcsRefs: () =>
+ Ref.updateAndGet(clearAttempts, (count) => count + 1).pipe(
+ Effect.flatMap((attempt) =>
+ attempt === 1
+ ? Effect.fail(
+ new Persistence.ConnectionPersistenceError({
+ operation: "clear-vcs-refs",
+ message: "storage unavailable",
+ }),
+ )
+ : Ref.set(persisted, Option.none()),
+ ),
+ ),
+ });
+
+ yield* invalidateCachedVcsRefs(registry, {
+ environmentId: TARGET.environmentId,
+ cwd: "/repo",
+ }).pipe(Effect.provideService(Persistence.EnvironmentCacheStore, cache));
+
+ const state = registry.get(vcsRefsCacheStateAtom(TARGET));
+ expect(state).toEqual({
+ revision: 1,
+ persistedCacheReadable: false,
+ });
+
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target: TARGET,
+ state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
+ session: yield* SubscriptionRef.make(Option.none<RpcSession>()),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+ const refs = yield* Stream.unwrap(
+ makeCachedVcsRefsChanges(
+ { cwd: "/repo", limit: 100 },
+ state.revision,
+ registry,
+ state.persistedCacheReadable,
+ ).pipe(
+ Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cache),
+ ),
+ ).pipe(Stream.runHead, Effect.forkChild({ startImmediately: true }));
+
+ yield* Effect.yieldNow;
+ expect(yield* Ref.get(loads)).toBe(0);
+ yield* Fiber.interrupt(refs);
+ expect(registry.get(vcsRefsCacheStateAtom(TARGET))).toEqual(state);
+
+ expect(
+ yield* commitVcsRefsRefresh(registry, cache, {
+ environmentId: TARGET.environmentId,
+ cwd: "/repo",
+ refs: LIVE_REFS,
+ expectedRevision: state.revision,
+ persist: true,
+ }),
+ ).toBe(true);
+ const recoveredState = registry.get(vcsRefsCacheStateAtom(TARGET));
+ expect(recoveredState).toEqual({
+ revision: 1,
+ persistedCacheReadable: true,
+ });
+ expect(yield* Ref.get(clearAttempts)).toBe(2);
+
+ const recoveredRefs = yield* Stream.unwrap(
+ makeCachedVcsRefsChanges(
+ { cwd: "/repo", limit: 100 },
+ recoveredState.revision,
+ registry,
+ recoveredState.persistedCacheReadable,
+ ).pipe(
+ Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cache),
+ ),
+ ).pipe(Stream.runHead);
+
+ expect(Option.getOrThrow(recoveredRefs)).toEqual(LIVE_REFS);
+ expect(yield* Ref.get(loads)).toBe(1);
+ }),
+ ),
+ );
+
it.effect("loads an unfiltered branch list without a connection", () =>
Effect.scoped(
Effect.gen(function* () {
@@ -116,11 +472,12 @@ describe("cached VCS refs", () => {
),
);
- it.effect("continues polling after a transient live failure", () =>
+ it.effect("retries a transient live failure while connected", () =>
Effect.scoped(
Effect.gen(function* () {
const expectedError = new Error("Could not list Git refs.");
const calls = yield* Ref.make(0);
+ const connectionState = yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE);
const client = {
[WS_METHODS.vcsListRefs]: () =>
Ref.updateAndGet(calls, (count) => count + 1).pipe(
@@ -131,7 +488,7 @@ describe("cached VCS refs", () => {
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
- state: yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE),
+ state: connectionState,
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
@@ -142,10 +499,7 @@ describe("cached VCS refs", () => {
const result = Stream.unwrap(
makeCachedVcsRefsChanges({ cwd: "/repo", limit: 100 }).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
- Effect.provideService(
- Persistence.EnvironmentCacheStore,
- cacheWithRefs(Option.some(CACHED_REFS)),
- ),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cacheWithRefs(Option.none())),
),
).pipe(Stream.runHead);
const fiber = yield* Effect.forkChild(result);
@@ -155,22 +509,78 @@ describe("cached VCS refs", () => {
}
expect(yield* Ref.get(calls)).toBe(1);
- yield* TestClock.adjust("5 seconds");
+ yield* TestClock.adjust("1 second");
expect(Option.getOrThrow(yield* Fiber.join(fiber))).toEqual(LIVE_REFS);
+ expect(yield* Ref.get(calls)).toBe(2);
}).pipe(Effect.provide(TestClock.layer())),
),
);
- it.effect("revalidates connected refs every five seconds", () =>
+ it.effect("cancels an in-flight refresh when the connection generation changes", () =>
Effect.scoped(
Effect.gen(function* () {
const calls = yield* Ref.make(0);
+ const interruptions = yield* Ref.make(0);
+ const connectionState = yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE);
const client = {
[WS_METHODS.vcsListRefs]: () =>
Ref.updateAndGet(calls, (count) => count + 1).pipe(
- Effect.map((count) => (count === 1 ? CACHED_REFS : LIVE_REFS)),
+ Effect.flatMap((count) =>
+ count === 1
+ ? Effect.never.pipe(
+ Effect.onInterrupt(() =>
+ Ref.update(interruptions, (interruptions) => interruptions + 1),
+ ),
+ )
+ : Effect.succeed(LIVE_REFS),
+ ),
),
} as unknown as WsRpcProtocolClient;
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target: TARGET,
+ state: connectionState,
+ session: yield* SubscriptionRef.make(Option.some(session(client))),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+
+ const result = Stream.unwrap(
+ makeCachedVcsRefsChanges({ cwd: "/repo", limit: 100 }).pipe(
+ Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
+ Effect.provideService(Persistence.EnvironmentCacheStore, cacheWithRefs(Option.none())),
+ ),
+ ).pipe(Stream.runHead);
+ const fiber = yield* Effect.forkChild(result);
+
+ for (let attempt = 0; attempt < 100 && (yield* Ref.get(calls)) < 1; attempt += 1) {
+ yield* Effect.yieldNow;
+ }
+ yield* SubscriptionRef.set(connectionState, AVAILABLE_CONNECTION_STATE);
+ for (let attempt = 0; attempt < 100 && (yield* Ref.get(interruptions)) < 1; attempt += 1) {
+ yield* Effect.yieldNow;
+ }
+ expect(yield* Ref.get(interruptions)).toBe(1);
+
+ yield* SubscriptionRef.set(connectionState, {
+ ...CONNECTED_CONNECTION_STATE,
+ generation: 2,
+ });
+ expect(Option.getOrThrow(yield* Fiber.join(fiber))).toEqual(LIVE_REFS);
+ expect(yield* Ref.get(calls)).toBe(2);
+ }),
+ ),
+ );
+
+ it.effect("does not poll refs while the connection remains stable", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const calls = yield* Ref.make(0);
+ const client = {
+ [WS_METHODS.vcsListRefs]: () =>
+ Ref.update(calls, (count) => count + 1).pipe(Effect.as(CACHED_REFS)),
+ } as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(CONNECTED_CONNECTION_STATE),
@@ -180,26 +590,28 @@ describe("cached VCS refs", () => {
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
- const results = Stream.unwrap(
+ const stream = Stream.unwrap(
makeCachedVcsRefsChanges({ cwd: "/repo", limit: 100 }).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
Effect.provideService(Persistence.EnvironmentCacheStore, cacheWithRefs(Option.none())),
),
- ).pipe(Stream.take(2), Stream.runCollect);
- const fiber = yield* Effect.forkChild(results);
+ ).pipe(Stream.runDrain);
+ const fiber = yield* Effect.forkChild(stream);
for (let attempt = 0; attempt < 100 && (yield* Ref.get(calls)) < 1; attempt += 1) {
yield* Effect.yieldNow;
}
expect(yield* Ref.get(calls)).toBe(1);
- yield* TestClock.adjust("5 seconds");
- expect(Array.from(yield* Fiber.join(fiber))).toEqual([CACHED_REFS, LIVE_REFS]);
+ yield* TestClock.adjust("1 minute");
+ yield* Effect.yieldNow;
+ expect(yield* Ref.get(calls)).toBe(1);
+ yield* Fiber.interrupt(fiber);
}).pipe(Effect.provide(TestClock.layer())),
),
);
- it.effect("does not emit persisted refs before a live refresh", () =>
+ it.effect("emits persisted refs before a live refresh", () =>
Effect.scoped(
Effect.gen(function* () {
const client = {
@@ -223,9 +635,9 @@ describe("cached VCS refs", () => {
cacheWithRefs(Option.some(CACHED_REFS)),
),
),
- ).pipe(Stream.runHead);
+ ).pipe(Stream.take(2), Stream.runCollect);
- expect(Option.getOrThrow(refs)).toEqual(LIVE_REFS);
+ expect(refs).toEqual([CACHED_REFS, LIVE_REFS]);
}),
),
);
diff --git a/packages/client-runtime/src/state/vcs.ts b/packages/client-runtime/src/state/vcs.ts
index 4ef94c261..a0d4510be 100644
--- a/packages/client-runtime/src/state/vcs.ts
+++ b/packages/client-runtime/src/state/vcs.ts
@@ -6,12 +6,14 @@ import {
WS_METHODS,
} from "@t3tools/contracts";
import { applyGitStatusStreamEvent } from "@t3tools/shared/git";
+import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Result from "effect/Result";
+import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
-import { Atom } from "effect/unstable/reactivity";
+import { Atom, AtomRegistry } from "effect/unstable/reactivity";
import { createEnvironmentRpcCommand, createEnvironmentSubscriptionAtomFamily } from "./runtime.ts";
import type { EnvironmentRegistry } from "../connection/registry.ts";
@@ -21,9 +23,19 @@ import { EnvironmentCacheStore } from "../platform/persistence.ts";
import { request, subscribe, type EnvironmentRpcInput } from "../rpc/client.ts";
import { followStreamInEnvironment } from "./runtime.ts";
import { vcsCommandConcurrency, vcsCommandScheduler } from "./vcsCommandScheduler.ts";
+import {
+ invalidateCachedVcsRefs,
+ vcsRefsCacheStateAtom,
+ withVcsRefsPersistenceLock,
+} from "./vcsRefInvalidation.ts";
const OFFLINE_BRANCH_LIST_LIMIT = 100;
-const VCS_REFS_REVALIDATE_INTERVAL = "5 seconds";
+const VCS_REFS_IDLE_TTL_MS = 30_000;
+const VCS_REFS_RETRY_SCHEDULE = Schedule.exponential("1 second").pipe(
+ Schedule.modifyDelay(({ duration }) =>
+ Effect.succeed(Duration.min(duration, Duration.seconds(30))),
+ ),
+);
function canUseVcsRefsCache(input: VcsListRefsInput): boolean {
return (
@@ -35,6 +47,66 @@ function canUseVcsRefsCache(input: VcsListRefsInput): boolean {
);
}
+export const commitVcsRefsRefresh = Effect.fn("CachedVcsRefsState.commitRefresh")(function* (
+ registry: AtomRegistry.AtomRegistry,
+ cache: EnvironmentCacheStore["Service"],
+ input: {
+ readonly environmentId: EnvironmentId;
+ readonly cwd: string;
+ readonly refs: VcsListRefsResult;
+ readonly expectedRevision: number;
+ readonly persist: boolean;
+ },
+) {
+ return yield* withVcsRefsPersistenceLock(
+ input.environmentId,
+ Effect.gen(function* () {
+ const stateAtom = vcsRefsCacheStateAtom({ environmentId: input.environmentId });
+ const state = registry.get(stateAtom);
+ if (state.revision !== input.expectedRevision) {
+ return false;
+ }
+ let persistedCacheReadable = state.persistedCacheReadable;
+ if (input.persist) {
+ if (!persistedCacheReadable) {
+ persistedCacheReadable = yield* cache.clearVcsRefs(input.environmentId).pipe(
+ Effect.as(true),
+ Effect.catch((error) =>
+ Effect.logWarning("Could not recover invalidated cached Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId: input.environmentId,
+ cwd: input.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
+ Effect.as(false),
+ ),
+ ),
+ );
+ }
+ yield* cache.saveVcsRefs(input.environmentId, input.cwd, input.refs).pipe(
+ Effect.catch((error) =>
+ Effect.logWarning("Could not persist cached Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId: input.environmentId,
+ cwd: input.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
+ ),
+ ),
+ );
+ if (persistedCacheReadable !== state.persistedCacheReadable) {
+ registry.update(stateAtom, (current) =>
+ current.revision === input.expectedRevision
+ ? { ...current, persistedCacheReadable }
+ : current,
+ );
+ }
+ }
+ return true;
+ }),
+ );
+});
+
/**
* Retains the last unfiltered branch-list response for the new-task picker.
* Filtered or paginated lists intentionally stay live-only: treating a
@@ -43,54 +115,59 @@ function canUseVcsRefsCache(input: VcsListRefsInput): boolean {
*/
export const makeCachedVcsRefsChanges = Effect.fn("CachedVcsRefsState.makeChanges")(function* (
input: VcsListRefsInput,
+ expectedRevision?: number,
+ registry?: AtomRegistry.AtomRegistry,
+ persistedCacheReadable = true,
) {
const supervisor = yield* EnvironmentSupervisor;
const cache = yield* EnvironmentCacheStore;
const environmentId = supervisor.target.environmentId;
const useCache = canUseVcsRefsCache(input);
- const cached = useCache
- ? yield* cache.loadVcsRefs(environmentId, input.cwd).pipe(
- Effect.catch((error) =>
- Effect.logWarning("Could not load cached Git refs.").pipe(
- Effect.annotateLogs({
- environmentId,
- cwd: input.cwd,
- ...safeErrorLogAttributes(error),
- }),
- Effect.as(Option.none<VcsListRefsResult>()),
+ const cached =
+ useCache && persistedCacheReadable
+ ? yield* cache.loadVcsRefs(environmentId, input.cwd).pipe(
+ Effect.catch((error) =>
+ Effect.logWarning("Could not load cached Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId,
+ cwd: input.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
+ Effect.as(Option.none<VcsListRefsResult>()),
+ ),
),
- ),
- )
- : Option.none<VcsListRefsResult>();
+ )
+ : Option.none<VcsListRefsResult>();
const refresh = Effect.fn("CachedVcsRefsState.refresh")(function* () {
const refs = yield* request(WS_METHODS.vcsListRefs, input).pipe(
Effect.provideService(EnvironmentSupervisor, supervisor),
);
- if (useCache) {
- yield* cache.saveVcsRefs(environmentId, input.cwd, refs).pipe(
- Effect.catch((error) =>
- Effect.logWarning("Could not persist cached Git refs.").pipe(
- Effect.annotateLogs({
- environmentId,
- cwd: input.cwd,
- ...safeErrorLogAttributes(error),
- }),
- ),
+ const persist = cache.saveVcsRefs(environmentId, input.cwd, refs).pipe(
+ Effect.catch((error) =>
+ Effect.logWarning("Could not persist cached Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId,
+ cwd: input.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
),
- );
+ ),
+ );
+ if (expectedRevision === undefined || registry === undefined) {
+ if (useCache) yield* persist;
+ return Option.some(refs);
}
- return refs;
+ const committed = yield* commitVcsRefsRefresh(registry, cache, {
+ environmentId,
+ cwd: input.cwd,
+ refs,
+ expectedRevision,
+ persist: useCache,
+ });
+ return committed ? Option.some(refs) : Option.none<VcsListRefsResult>();
});
- const cachedRefs = Stream.fromEffect(
- SubscriptionRef.get(supervisor.state).pipe(
- Effect.flatMap((connection) =>
- connection.phase === "connected"
- ? Effect.succeed(Option.none<VcsListRefsResult>())
- : Effect.succeed(cached),
- ),
- ),
- ).pipe(
+ const cachedRefs = Stream.fromEffect(Effect.succeed(cached)).pipe(
Stream.filterMap((refs) =>
Option.match(refs, {
onNone: () => Result.failVoid,
@@ -107,24 +184,20 @@ export const makeCachedVcsRefsChanges = Effect.fn("CachedVcsRefsState.makeChange
Stream.switchMap((generation) =>
generation === null
? Stream.empty
- : Stream.tick(VCS_REFS_REVALIDATE_INTERVAL).pipe(
- Stream.mapEffect(
- () =>
- refresh().pipe(
- Effect.map(Option.some),
- Effect.catch((error) =>
- Effect.logWarning("Could not refresh Git refs.").pipe(
- Effect.annotateLogs({
- environmentId,
- cwd: input.cwd,
- ...safeErrorLogAttributes(error),
- }),
- Effect.as(Option.none<VcsListRefsResult>()),
- ),
- ),
+ : Stream.fromEffect(
+ refresh().pipe(
+ Effect.tapError((error) =>
+ Effect.logWarning("Could not refresh Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId,
+ cwd: input.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
),
- { concurrency: 1 },
+ ),
),
+ ).pipe(
+ Stream.retry(VCS_REFS_RETRY_SCHEDULE),
Stream.filterMap((refs) =>
Option.match(refs, {
onNone: () => Result.failVoid,
@@ -138,8 +211,26 @@ export const makeCachedVcsRefsChanges = Effect.fn("CachedVcsRefsState.makeChange
return Stream.concat(cachedRefs, refreshedRefs);
});
-export function cachedVcsRefsChanges(environmentId: EnvironmentId, input: VcsListRefsInput) {
- return followStreamInEnvironment(environmentId, Stream.unwrap(makeCachedVcsRefsChanges(input)));
+export function cachedVcsRefsChanges(
+ environmentId: EnvironmentId,
+ input: VcsListRefsInput,
+ expectedRevision: number,
+ persistedCacheReadable: boolean,
+) {
+ return followStreamInEnvironment(
+ environmentId,
+ Stream.unwrap(
+ Effect.gen(function* () {
+ const registry = yield* AtomRegistry.AtomRegistry;
+ return yield* makeCachedVcsRefsChanges(
+ input,
+ expectedRevision,
+ registry,
+ persistedCacheReadable,
+ );
+ }),
+ ),
+ );
}
export function createVcsEnvironmentAtoms<R, E>(
@@ -149,9 +240,17 @@ export function createVcsEnvironmentAtoms<R, E>(
Atom.family((inputKey: string) => {
const input = JSON.parse(inputKey) as VcsListRefsInput;
return runtime
- .atom(cachedVcsRefsChanges(environmentId, input))
+ .atom((get) => {
+ const state = get(vcsRefsCacheStateAtom({ environmentId }));
+ return cachedVcsRefsChanges(
+ environmentId,
+ input,
+ state.revision,
+ state.persistedCacheReadable,
+ );
+ })
.pipe(
- Atom.setIdleTTL(5 * 60_000),
+ Atom.setIdleTTL(VCS_REFS_IDLE_TTL_MS),
Atom.withLabel(`environment-data:vcs:list-refs:${environmentId}:${inputKey}`),
);
}),
@@ -160,6 +259,14 @@ export function createVcsEnvironmentAtoms<R, E>(
readonly environmentId: EnvironmentId;
readonly input: VcsListRefsInput;
}) => listRefsByEnvironment(target.environmentId)(JSON.stringify(target.input));
+ const invalidateRefs = (
+ target: { readonly environmentId: EnvironmentId; readonly input: { readonly cwd: string } },
+ registry: AtomRegistry.AtomRegistry,
+ ) =>
+ invalidateCachedVcsRefs(registry, {
+ environmentId: target.environmentId,
+ cwd: target.input.cwd,
+ });
return {
listRefs,
@@ -181,42 +288,49 @@ export function createVcsEnvironmentAtoms<R, E>(
tag: WS_METHODS.vcsPull,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
refreshStatus: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:refresh-status",
tag: WS_METHODS.vcsRefreshStatus,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
createWorktree: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:create-worktree",
tag: WS_METHODS.vcsCreateWorktree,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
removeWorktree: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:remove-worktree",
tag: WS_METHODS.vcsRemoveWorktree,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
createRef: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:create-ref",
tag: WS_METHODS.vcsCreateRef,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
switchRef: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:switch-ref",
tag: WS_METHODS.vcsSwitchRef,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
init: createEnvironmentRpcCommand(runtime, {
label: "environment-data:vcs:init",
tag: WS_METHODS.vcsInit,
scheduler: vcsCommandScheduler,
concurrency: vcsCommandConcurrency,
+ onSettled: invalidateRefs,
}),
};
}
diff --git a/packages/client-runtime/src/state/vcsAction.test.ts b/packages/client-runtime/src/state/vcsAction.test.ts
index dac852c16..b936246dc 100644
--- a/packages/client-runtime/src/state/vcsAction.test.ts
+++ b/packages/client-runtime/src/state/vcsAction.test.ts
@@ -1,5 +1,6 @@
import {
EnvironmentId,
+ WS_METHODS,
type GitActionProgressEvent,
type GitRunStackedActionResult,
} from "@t3tools/contracts";
@@ -7,11 +8,23 @@ import { describe, expect, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
+import * as SubscriptionRef from "effect/SubscriptionRef";
import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
-import type { EnvironmentRegistry } from "../connection/registry.ts";
+import {
+ AVAILABLE_CONNECTION_STATE,
+ PrimaryConnectionTarget,
+ type PreparedConnection,
+ type SupervisorConnectionState,
+} from "../connection/model.ts";
+import * as EnvironmentRegistry from "../connection/registry.ts";
+import * as EnvironmentSupervisor from "../connection/supervisor.ts";
+import * as Persistence from "../platform/persistence.ts";
+import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
+import type { RpcSession } from "../rpc/session.ts";
import type { AtomCommandResult } from "./runtime.ts";
import {
applyVcsActionProgressEvent,
@@ -28,6 +41,7 @@ import {
VcsActionTargetKeyParseError,
VcsActionUnavailableError,
} from "./vcsAction.ts";
+import { vcsRefsCacheStateAtom } from "./vcsRefInvalidation.ts";
const actionId = "action-123";
const action = "commit_push" as const;
@@ -59,10 +73,44 @@ const result: GitRunStackedActionResult = {
},
};
+const target = new PrimaryConnectionTarget({
+ environmentId,
+ label: "Test environment",
+ httpBaseUrl: "https://environment.example.test",
+ wsBaseUrl: "wss://environment.example.test",
+});
+
+function session(client: WsRpcProtocolClient): RpcSession {
+ return {
+ client,
+ initialConfig: Effect.never,
+ ready: Effect.void,
+ probe: Effect.void,
+ closed: Effect.never,
+ };
+}
+
function progress<T extends GitActionProgressEvent>(event: T): T {
return event;
}
+function cacheStore(onClearVcsRefs: (environmentId: EnvironmentId) => void) {
+ return Persistence.EnvironmentCacheStore.of({
+ loadShell: () => Effect.succeed(Option.none()),
+ saveShell: () => Effect.void,
+ loadThread: () => Effect.succeed(Option.none()),
+ saveThread: () => Effect.void,
+ removeThread: () => Effect.void,
+ loadServerConfig: () => Effect.succeed(Option.none()),
+ saveServerConfig: () => Effect.void,
+ loadVcsRefs: () => Effect.succeed(Option.none()),
+ saveVcsRefs: () => Effect.void,
+ removeVcsRefs: () => Effect.void,
+ clearVcsRefs: (environmentId) => Effect.sync(() => onClearVcsRefs(environmentId)),
+ clear: () => Effect.void,
+ });
+}
+
describe("vcsActionState", () => {
it("preserves malformed target key diagnostics and the native cause without copying the key", () => {
const key = "not-json-with-credential=do-not-log";
@@ -417,7 +465,7 @@ describe("vcsActionState", () => {
it("keys mutation ownership by environment and cwd", () => {
const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<
- EnvironmentRegistry,
+ EnvironmentRegistry.EnvironmentRegistry | Persistence.EnvironmentCacheStore,
never
>;
const manager = createVcsActionManager(runtime);
@@ -437,7 +485,7 @@ describe("vcsActionState", () => {
it("retains the incomplete target and operation when tracking is unavailable", async () => {
const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<
- EnvironmentRegistry,
+ EnvironmentRegistry.EnvironmentRegistry | Persistence.EnvironmentCacheStore,
never
>;
const manager = createVcsActionManager(runtime);
@@ -469,7 +517,7 @@ describe("vcsActionState", () => {
it("tracks finite mutations without letting an older completion clear newer state", async () => {
const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<
- EnvironmentRegistry,
+ EnvironmentRegistry.EnvironmentRegistry | Persistence.EnvironmentCacheStore,
never
>;
const manager = createVcsActionManager(runtime);
@@ -520,4 +568,111 @@ describe("vcsActionState", () => {
registry.dispose();
});
+
+ it.effect("invalidates persisted refs after successful and failed stacked actions", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const connectionState: SupervisorConnectionState = {
+ ...AVAILABLE_CONNECTION_STATE,
+ desired: true,
+ network: "online",
+ phase: "connected",
+ attempt: 1,
+ generation: 1,
+ };
+ const targetKey = { environmentId, cwd };
+ const successfulActionId = "invalidate-success";
+ const failedActionId = "invalidate-failure";
+ const successfulTransportActionId = createVcsActionTransportId(
+ targetKey,
+ successfulActionId,
+ );
+ const failedTransportActionId = createVcsActionTransportId(targetKey, failedActionId);
+ const client = {
+ [WS_METHODS.gitRunStackedAction]: (input: { readonly actionId: string }) =>
+ input.actionId === successfulTransportActionId
+ ? Stream.make(
+ progress({
+ kind: "action_finished",
+ actionId: successfulTransportActionId,
+ cwd,
+ action,
+ result,
+ }),
+ )
+ : Stream.make(
+ progress({
+ kind: "action_failed",
+ actionId: failedTransportActionId,
+ cwd,
+ action,
+ phase: "push",
+ message: "push failed after creating the branch",
+ }),
+ ),
+ } as unknown as WsRpcProtocolClient;
+ const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
+ target,
+ state: yield* SubscriptionRef.make(connectionState),
+ session: yield* SubscriptionRef.make(Option.some(session(client))),
+ prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
+ connect: Effect.void,
+ disconnect: Effect.void,
+ retryNow: Effect.void,
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
+ const run: EnvironmentRegistry.EnvironmentRegistry["Service"]["run"] = (
+ _environmentId,
+ effect,
+ ) => Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
+ const runStream: EnvironmentRegistry.EnvironmentRegistry["Service"]["runStream"] = (
+ _environmentId,
+ stream,
+ ) => Stream.provideService(stream, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
+ const environmentRegistry = EnvironmentRegistry.EnvironmentRegistry.of({
+ run,
+ runStream,
+ } as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
+ const removed = new Array<string>();
+ const runtime = Atom.runtime(
+ Layer.merge(
+ Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry),
+ Layer.succeed(
+ Persistence.EnvironmentCacheStore,
+ cacheStore((removedEnvironmentId) => {
+ removed.push(`${removedEnvironmentId}:*`);
+ }),
+ ),
+ ),
+ );
+ const manager = createVcsActionManager(runtime);
+ const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
+ Effect.sync(() => registry.dispose()),
+ );
+ const state = vcsRefsCacheStateAtom({ environmentId });
+
+ expect(registry.get(state).revision).toBe(0);
+ const successfulResult = yield* Effect.promise(() =>
+ manager.runStackedAction(targetKey).run(registry, {
+ actionId: successfulActionId,
+ action,
+ }),
+ );
+
+ expect(AsyncResult.isSuccess(successfulResult)).toBe(true);
+ expect(registry.get(state).revision).toBe(1);
+ expect(removed).toEqual([`${environmentId}:*`]);
+
+ const failedResult = yield* Effect.promise(() =>
+ manager.runStackedAction(targetKey).run(registry, {
+ actionId: failedActionId,
+ action,
+ }),
+ );
+
+ expect(AsyncResult.isFailure(failedResult)).toBe(true);
+ expect(registry.get(state).revision).toBe(2);
+ expect(removed).toEqual([`${environmentId}:*`, `${environmentId}:*`]);
+ }),
+ ),
+ );
});
diff --git a/packages/client-runtime/src/state/vcsAction.ts b/packages/client-runtime/src/state/vcsAction.ts
index f2cba39cf..f0c3791e3 100644
--- a/packages/client-runtime/src/state/vcsAction.ts
+++ b/packages/client-runtime/src/state/vcsAction.ts
@@ -16,6 +16,7 @@ import * as Stream from "effect/Stream";
import { AsyncResult, Atom, type AtomRegistry } from "effect/unstable/reactivity";
import type { EnvironmentRegistry } from "../connection/registry.ts";
+import { EnvironmentCacheStore } from "../platform/persistence.ts";
import { runStream } from "../rpc/client.ts";
import {
createRuntimeCommand,
@@ -24,6 +25,7 @@ import {
type AtomCommandResult,
} from "./runtime.ts";
import { vcsCommandScheduler } from "./vcsCommandScheduler.ts";
+import { invalidateCachedVcsRefs } from "./vcsRefInvalidation.ts";
export const VcsActionOperation = Schema.Literals([
"refresh_status",
@@ -403,7 +405,7 @@ export function applyVcsActionProgressEvent(
}
export function createVcsActionManager<R, E>(
- runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,
+ runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>,
) {
const runStackedActionCommands = new Map<
string,
@@ -425,7 +427,7 @@ export function createVcsActionManager<R, E>(
const target = targetKey === null ? null : parseVcsActionTargetKey(targetKey);
const stateAtom = targetKey === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(targetKey);
const command = createRuntimeCommand<
- EnvironmentRegistry | R,
+ EnvironmentRegistry | EnvironmentCacheStore | R,
E,
RunVcsStackedActionInput,
GitRunStackedActionResult,
@@ -489,6 +491,7 @@ export function createVcsActionManager<R, E>(
}),
},
).pipe(
+ Effect.ensuring(invalidateCachedVcsRefs(registry, target)),
Effect.tapError((error) =>
Effect.sync(() => {
const current = registry.get(stateAtom);
diff --git a/packages/client-runtime/src/state/vcsRefInvalidation.ts b/packages/client-runtime/src/state/vcsRefInvalidation.ts
new file mode 100644
index 000000000..ff9de7bd1
--- /dev/null
+++ b/packages/client-runtime/src/state/vcsRefInvalidation.ts
@@ -0,0 +1,83 @@
+import type { EnvironmentId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as PartitionedSemaphore from "effect/PartitionedSemaphore";
+import { Atom, type AtomRegistry } from "effect/unstable/reactivity";
+
+import { safeErrorLogAttributes } from "../errors/safeLog.ts";
+import { EnvironmentCacheStore } from "../platform/persistence.ts";
+
+export interface VcsRefsInvalidationTarget {
+ readonly environmentId: EnvironmentId;
+}
+
+export interface CachedVcsRefsInvalidationTarget extends VcsRefsInvalidationTarget {
+ readonly cwd: string;
+}
+
+export interface VcsRefsCacheState {
+ readonly revision: number;
+ readonly persistedCacheReadable: boolean;
+}
+
+const stateByEnvironment = Atom.family((environmentId: EnvironmentId) =>
+ Atom.make<VcsRefsCacheState>({
+ revision: 0,
+ persistedCacheReadable: true,
+ }).pipe(Atom.keepAlive, Atom.withLabel(`environment-data:vcs:list-refs-state:${environmentId}`)),
+);
+const persistenceLock = PartitionedSemaphore.makeUnsafe<EnvironmentId>({ permits: 1 });
+
+export function vcsRefsCacheStateAtom(target: VcsRefsInvalidationTarget) {
+ return stateByEnvironment(target.environmentId);
+}
+
+export function invalidateVcsRefs(
+ registry: AtomRegistry.AtomRegistry,
+ target: VcsRefsInvalidationTarget,
+ persistedCacheReadable?: boolean,
+): void {
+ registry.update(vcsRefsCacheStateAtom(target), (state) => ({
+ revision: state.revision + 1,
+ persistedCacheReadable: persistedCacheReadable ?? state.persistedCacheReadable,
+ }));
+}
+
+export function withVcsRefsPersistenceLock<A, E, R>(
+ environmentId: EnvironmentId,
+ effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> {
+ return persistenceLock.withPermit(environmentId)(effect);
+}
+
+/**
+ * Clears persisted snapshots and then restarts live ref streams while holding
+ * the same lock used by generation-checked refresh writes. Clearing first
+ * prevents the restarted stream from rehydrating the invalidated snapshot. A
+ * refresh that wins the lock is cleared afterward; one that loses observes the
+ * new revision and cannot repersist its pre-mutation result.
+ */
+export const invalidateCachedVcsRefs = Effect.fn("VcsRefsState.invalidateCached")(function* (
+ registry: AtomRegistry.AtomRegistry,
+ target: CachedVcsRefsInvalidationTarget,
+) {
+ const cache = yield* EnvironmentCacheStore;
+ yield* withVcsRefsPersistenceLock(
+ target.environmentId,
+ Effect.gen(function* () {
+ const persistedCacheReadable = yield* cache.clearVcsRefs(target.environmentId).pipe(
+ Effect.as(true),
+ Effect.catch((error) =>
+ Effect.logWarning("Could not remove invalidated cached Git refs.").pipe(
+ Effect.annotateLogs({
+ environmentId: target.environmentId,
+ cwd: target.cwd,
+ ...safeErrorLogAttributes(error),
+ }),
+ Effect.as(false),
+ ),
+ ),
+ );
+ invalidateVcsRefs(registry, target, persistedCacheReadable);
+ }),
+ );
+});
diff --git a/packages/contracts/src/git.ts b/packages/contracts/src/git.ts
index aa5cdf843..2e0552740 100644
--- a/packages/contracts/src/git.ts
+++ b/packages/contracts/src/git.ts
@@ -127,6 +127,7 @@ export const VcsListRefsInput = Schema.Struct({
cursor: Schema.optional(NonNegativeInt),
includeMatchingRemoteRefs: Schema.optional(Schema.Boolean),
refKind: Schema.optional(Schema.Literals(["all", "local", "remote"])),
+ refresh: Schema.optional(Schema.Boolean),
limit: Schema.optional(
PositiveInt.check(Schema.isLessThanOrEqualTo(GIT_LIST_BRANCHES_MAX_LIMIT)),
),