@devries-cameron20 / t3code-1 / commits / fa42465ff6
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): removing a worktree on Windows no longer deletes what its junctions point to (#21099)

Co-authored-by: sheehanmunim <80079528+sheehanmunim@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>

Dara Adedeji committed Oct 21, 2026 at 14:18 UTC fa42465ff6484cad4301e65c40dbf68668fd05a5
5 files changed +271 -35
apps/server/src/storageCleanup.test.ts
+6 -1
@@ -276,7 +276,12 @@ const cleanupFixture = (
276 ...git,
277 execute: (input) =>
278 Effect.gen(function* () {
279 - if (editBeforeRemoval && input.args.includes("remove"))
279 + // Before Git's own clean check: inside `git worktree remove`, or on
280 + // Windows the same status check the removal makes before deleting.
281 + if (
282 + editBeforeRemoval &&
283 + (input.args.includes("remove") || input.args.includes("--porcelain"))
284 + )
285 yield* fs.writeFileString(`${worktree}/tracked.txt`, "late edit\n");
286 return yield* git.execute(input);
287 }),
apps/server/src/storageCleanup.ts
+10 -14
@@ -46,6 +46,7 @@ import * as Settings from "./serverSettings.ts";
46 import * as TerminalManager from "./terminal/Manager.ts";
47 import { isFilesystemRoot, managedWorktreesDirectories } from "./worktreesDirectory.ts";
48 import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
49 +import { removeLinkedWorktree } from "./vcs/worktreeRemoval.ts";
50 import { withWorkspaceLease } from "./workspace/workspaceLease.ts";
51 import * as HostProcess from "@t3tools/shared/HostProcess";
52 import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
@@ -1013,20 +1014,15 @@ const make = Effect.gen(function* () {
1014 const changes = yield* localChangesReason(worktreePath, settings);
1015 if (changes !== null) return keep(changes);
1016 }
1016 - yield* cleanupGit(
1017 - project.workspaceRoot,
1018 - [
1019 - "-c",
1020 - "status.showUntrackedFiles=normal",
1021 - "worktree",
1022 - "remove",
1023 - // Git requires force for submodules; recursive checks above cannot make removal atomic.
1024 - ...(submodules.force ? ["--force"] : []),
1025 - "--",
1026 - worktreePath,
1027 - ],
1028 - "git worktree remove",
1029 - );
1017 + yield* removeLinkedWorktree({
1018 + operation: "StorageCleanup.cleanupGit",
1019 + cwd: project.workspaceRoot,
1020 + worktreePath,
1021 + // Git requires force for submodules; recursive checks above cannot make removal atomic.
1022 + force: submodules.force,
1023 + execute: git.execute,
1024 + run: (args) => cleanupGit(project.workspaceRoot, [...args], "git worktree remove"),
1025 + });
1026 entries.push({ ...entry, outcome: "removed", reason: sentence(removalReason), bytes });
1027 yield* gitManager.invalidateStatus(project.workspaceRoot);
1028 // Preserve branch and path: ProviderTurnStartService recreates the checkout
apps/server/src/vcs/GitVcsDriverCore.test.ts
+67
@@ -3416,6 +3416,73 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
3416 }),
3417 );
3418
3419 + it.effect("force-removes a worktree without deleting what its junctions point to", () =>
3420 + Effect.gen(function* () {
3421 + const cwd = yield* makeTmpDir();
3422 + const { initialBranch } = yield* initRepoWithCommit(cwd);
3423 + yield* writeTextFile(cwd, ".gitignore", "node_modules\n");
3424 + yield* git(cwd, ["add", ".gitignore"]);
3425 + yield* git(cwd, ["commit", "-m", "ignore node_modules"]);
3426 + const fileSystem = yield* FileSystem.FileSystem;
3427 + const pathService = yield* Path.Path;
3428 + const outside = yield* makeTmpDir("git-worktree-link-target-");
3429 + yield* writeTextFile(outside, "keep.txt", "keep\n");
3430 + const worktreePath = pathService.join(yield* makeTmpDir("git-worktrees-"), "linked");
3431 + const driver = yield* GitVcsDriver.GitVcsDriver;
3432 + yield* driver.createWorktree({
3433 + cwd,
3434 + path: worktreePath,
3435 + refName: initialBranch,
3436 + newRefName: "feature/linked",
3437 + });
3438 + // Junctions on Windows, the way pnpm links packages; symlinks elsewhere.
3439 + NodeFS.mkdirSync(pathService.join(worktreePath, "node_modules"));
3440 + NodeFS.symlinkSync(
3441 + outside,
3442 + pathService.join(worktreePath, "node_modules", "dep"),
3443 + "junction",
3444 + );
3445 + NodeFS.symlinkSync(outside, pathService.join(worktreePath, "shared"), "junction");
3446 +
3447 + yield* driver.removeWorktree({ cwd, path: worktreePath, force: true });
3448 +
3449 + assert.deepEqual(NodeFS.readdirSync(pathService.dirname(worktreePath)), []);
3450 + assert.equal(
3451 + yield* fileSystem.readFileString(pathService.join(outside, "keep.txt")),
3452 + "keep\n",
3453 + );
3454 + }),
3455 + );
3456 +
3457 + it.effect("keeps the junctions of a worktree that git refuses to remove", () =>
3458 + Effect.gen(function* () {
3459 + const cwd = yield* makeTmpDir();
3460 + const { initialBranch } = yield* initRepoWithCommit(cwd);
3461 + yield* writeTextFile(cwd, ".gitignore", "node_modules\n");
3462 + yield* git(cwd, ["add", ".gitignore"]);
3463 + yield* git(cwd, ["commit", "-m", "ignore node_modules"]);
3464 + const pathService = yield* Path.Path;
3465 + const outside = yield* makeTmpDir("git-worktree-link-target-");
3466 + const worktreePath = pathService.join(yield* makeTmpDir("git-worktrees-"), "linked");
3467 + const driver = yield* GitVcsDriver.GitVcsDriver;
3468 + yield* driver.createWorktree({
3469 + cwd,
3470 + path: worktreePath,
3471 + refName: initialBranch,
3472 + newRefName: "feature/linked",
3473 + });
3474 + const link = pathService.join(worktreePath, "node_modules");
3475 + NodeFS.symlinkSync(outside, link, "junction");
3476 + yield* writeTextFile(worktreePath, "notes.txt", "draft\n");
3477 +
3478 + const result = yield* Effect.result(driver.removeWorktree({ cwd, path: worktreePath }));
3479 +
3480 + assert.isTrue(Result.isFailure(result));
3481 + assert.isTrue(NodeFS.lstatSync(link).isSymbolicLink());
3482 + assert.deepEqual(NodeFS.readdirSync(pathService.dirname(worktreePath)), ["linked"]);
3483 + }),
3484 + );
3485 +
3486 it.effect("prunes stale registrations when removing an already-gone worktree", () =>
3487 Effect.gen(function* () {
3488 const cwd = yield* makeTmpDir();
apps/server/src/vcs/GitVcsDriverCore.ts
+24 -20
@@ -42,6 +42,7 @@ import { gitCommandDuration, gitCommandsTotal, withMetrics } from "../observabil
42 import * as GitVcsDriver from "./GitVcsDriver.ts";
43 import { removeEmptyDirectory } from "./removeEmptyDirectory.ts";
44 import { explicitBareRepositoryEnv, gitConfigEnv } from "./VcsProcess.ts";
45 +import { removeLinkedWorktree } from "./worktreeRemoval.ts";
46 import { resolveWorktreesDirectory } from "../worktreesDirectory.ts";
47 import {
48 parseRemoteNames,
@@ -4172,25 +4173,24 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
4173 const removeWorktree: GitVcsDriver.GitVcsDriver["Service"]["removeWorktree"] = Effect.fn(
4174 "removeWorktree",
4175 )(function* (input) {
4175 - // Git also accepts a worktree's short name, which can match a different
4176 - // folder than the path resolved against `input.cwd`. Resolve it once so Git
4177 - // and the leftover cleanup below act on the same directory.
4176 + // Git also matches a worktree by its short name, which can name a different
4177 + // folder than this path. Resolving it once keeps Git, the Windows deletion
4178 + // in removeLinkedWorktree, and the leftover cleanup below on one directory.
4179 const target = path.resolve(input.cwd, input.path);
4179 - // Git refuses to remove a worktree with untracked files unless forced, but
4180 - // its check honors `status.showUntrackedFiles=no` and would delete them.
4181 - const args = ["-c", "status.showUntrackedFiles=normal", "worktree", "remove"];
4182 - if (input.force) {
4183 - args.push("--force");
4184 - }
4185 - args.push("--", target);
4186 - const result = yield* executeGitWithStableDiagnostics(
4187 - "GitVcsDriver.removeWorktree",
4188 - input.cwd,
4189 - args,
4190 - {
4191 - timeoutMs: WORKTREE_REMOVE_TIMEOUT_MS,
4192 - allowNonZeroExit: true,
4193 - },
4180 + const result = yield* removeLinkedWorktree({
4181 + operation: "GitVcsDriver.removeWorktree",
4182 + cwd: input.cwd,
4183 + worktreePath: target,
4184 + force: input.force === true,
4185 + execute,
4186 + run: (args) =>
4187 + executeGitWithStableDiagnostics("GitVcsDriver.removeWorktree", input.cwd, args, {
4188 + timeoutMs: WORKTREE_REMOVE_TIMEOUT_MS,
4189 + allowNonZeroExit: true,
4190 + }).pipe(Effect.map((result) => ({ ...result, args }))),
4191 + }).pipe(
4192 + Effect.provideService(FileSystem.FileSystem, fileSystem),
4193 + Effect.provideService(Path.Path, path),
4194 );
4195 if (result.exitCode === 0) {
4196 // Git for Windows never descends into NTFS junctions, such as pnpm's
@@ -4222,7 +4222,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
4222 // than an error.
4223 const alreadyGone =
4224 isMissingWorktreeStderr(result.stderr) &&
4225 - !(yield* fileSystem.exists(input.path).pipe(Effect.orElseSucceed(() => false)));
4225 + !(yield* fileSystem.exists(target).pipe(Effect.orElseSucceed(() => false)));
4226 if (alreadyGone) {
4227 yield* pruneWorktrees({ cwd: input.cwd });
4228 return;
@@ -4231,7 +4231,11 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
4231 `GitVcsDriver.removeWorktree: git worktree remove exited with code ${result.exitCode} for ${input.path} (stderr length ${result.stderr.length}).`,
4232 );
4233 return yield* new GitCommandError({
4234 - ...gitCommandContext({ operation: "GitVcsDriver.removeWorktree", cwd: input.cwd, args }),
4234 + ...gitCommandContext({
4235 + operation: "GitVcsDriver.removeWorktree",
4236 + cwd: input.cwd,
4237 + args: result.args,
4238 + }),
4239 detail: "git worktree remove failed",
4240 ...(result.exitCode === null ? {} : { exitCode: result.exitCode }),
4241 stdoutLength: result.stdout.length,
apps/server/src/vcs/worktreeRemoval.ts new
+164
@@ -0,0 +1,164 @@
1 +import { GitCommandError } from "@t3tools/contracts";
2 +import * as HostProcess from "@t3tools/shared/HostProcess";
3 +import * as Effect from "effect/Effect";
4 +import * as FileSystem from "effect/FileSystem";
5 +import * as Option from "effect/Option";
6 +import * as Path from "effect/Path";
7 +
8 +import type * as GitVcsDriver from "./GitVcsDriver.ts";
9 +
10 +const INDEX_LIST_MAX_BYTES = 64 * 1024 * 1024;
11 +
12 +/**
13 + * Removes the linked worktree at `worktreePath` by running `git worktree
14 + * remove` through `run`.
15 + *
16 + * Git for Windows before 2.54 follows NTFS junctions while it deletes a
17 + * worktree, and deletes what they point to, such as a shared node_modules.
18 + * Later versions skip junctions but leave them, and the folders holding them,
19 + * behind. On Windows, Git therefore never deletes the files: this makes the
20 + * checks `git worktree remove` makes before deleting (builtin/worktree.c),
21 + * deletes the folder with Node's `rm`, which unlinks junctions without
22 + * following them, and then has Git drop the now-missing worktree's metadata.
23 + * Git elsewhere only unlinks links, so other hosts run Git as before.
24 + */
25 +export const removeLinkedWorktree = Effect.fn("WorktreeRemoval.removeLinkedWorktree")(function* <
26 + A,
27 + E,
28 + R,
29 +>(input: {
30 + readonly operation: string;
31 + readonly cwd: string;
32 + readonly worktreePath: string;
33 + readonly force: boolean;
34 + readonly execute: GitVcsDriver.GitVcsDriver["Service"]["execute"];
35 + readonly run: (args: ReadonlyArray<string>) => Effect.Effect<A, E, R>;
36 +}) {
37 + const fileSystem = yield* FileSystem.FileSystem;
38 + const path = yield* Path.Path;
39 + const worktreePath = input.worktreePath;
40 + const gitFile = path.join(worktreePath, ".git");
41 + // Git refuses to remove a worktree with untracked files unless forced, but
42 + // its check honors `status.showUntrackedFiles=no` and would delete them.
43 + const statusConfig = ["-c", "status.showUntrackedFiles=normal"];
44 + const linked =
45 + (yield* HostProcess.isWindows) &&
46 + (yield* fileSystem.stat(gitFile).pipe(
47 + Effect.map((info) => info.type === "File"),
48 + Effect.orElseSucceed(() => false),
49 + ));
50 + if (!linked) {
51 + return yield* input.run([
52 + ...statusConfig,
53 + "worktree",
54 + "remove",
55 + ...(input.force ? ["--force"] : []),
56 + "--",
57 + worktreePath,
58 + ]);
59 + }
60 +
61 + // Git's own refusals, worded the way it prints them.
62 + const refuse = (message: string, cause?: unknown) =>
63 + new GitCommandError({
64 + operation: input.operation,
65 + command: "git worktree remove",
66 + cwd: input.cwd,
67 + detail: `fatal: ${message}`,
68 + ...(cause === undefined ? {} : { cause }),
69 + });
70 + const gitOutput = (cwd: string, args: ReadonlyArray<string>, env?: NodeJS.ProcessEnv) =>
71 + input
72 + .execute({
73 + operation: input.operation,
74 + cwd,
75 + args,
76 + maxOutputBytes: INDEX_LIST_MAX_BYTES,
77 + ...(env === undefined ? {} : { env }),
78 + })
79 + .pipe(Effect.map((result) => result.stdout));
80 + const samePath = (left: string, right: string) =>
81 + Effect.all([fileSystem.realPath(left), fileSystem.realPath(right)]).pipe(
82 + Effect.map(([a, b]) => a.toLowerCase() === b.toLowerCase()),
83 + Effect.orElseSucceed(() => false),
84 + );
85 +
86 + // A registered worktree of this repository: its `.git` file names an admin
87 + // directory under the common `worktrees/`, whose `gitdir` points back.
88 + const notAWorktree = refuse(`'${worktreePath}' is not a working tree`);
89 + const adminDir = path.resolve(
90 + worktreePath,
91 + (yield* gitOutput(worktreePath, ["rev-parse", "--absolute-git-dir"]).pipe(
92 + Effect.mapError(() => notAWorktree),
93 + )).trim(),
94 + );
95 + const commonDir = path.resolve(
96 + input.cwd,
97 + (yield* gitOutput(input.cwd, ["rev-parse", "--git-common-dir"])).trim(),
98 + );
99 + const pointsBack = yield* fileSystem.readFileString(path.join(adminDir, "gitdir")).pipe(
100 + Effect.flatMap((gitdir) => samePath(path.resolve(adminDir, gitdir.trim()), gitFile)),
101 + Effect.orElseSucceed(() => false),
102 + );
103 + if (!pointsBack || !(yield* samePath(path.dirname(adminDir), path.join(commonDir, "worktrees"))))
104 + return yield* notAWorktree;
105 + // Git counts the file's existence as a lock. T3 passes at most one
106 + // `--force`, which never removes a locked worktree. Anything but a
107 + // confirmed absence refuses.
108 + const lockFile = path.join(adminDir, "locked");
109 + const locked = yield* fileSystem.stat(lockFile).pipe(
110 + Effect.as(true),
111 + Effect.catch((error) =>
112 + error.reason._tag === "NotFound"
113 + ? Effect.succeed(false)
114 + : Effect.fail(refuse(`cannot inspect the lock of '${worktreePath}'`, error)),
115 + ),
116 + );
117 + if (locked) {
118 + const reason = (yield* fileSystem.readFileString(lockFile).pipe(Effect.option)).pipe(
119 + Option.map((text) => text.trim()),
120 + Option.getOrElse(() => ""),
121 + );
122 + return yield* refuse(
123 + reason === ""
124 + ? "cannot remove a locked working tree;\nuse 'remove -f -f' to override or unlock first"
125 + : `cannot remove a locked working tree, lock reason: ${reason}\nuse 'remove -f -f' to override or unlock first`,
126 + );
127 + }
128 + if (!input.force) {
129 + // Bound like Git's own check, so `core.worktree` can't point it elsewhere.
130 + const boundEnv = { GIT_DIR: gitFile, GIT_WORK_TREE: worktreePath };
131 + const submodules = refuse("working trees containing submodules cannot be moved or removed");
132 + // An unreadable path counts as present, so a doubt refuses.
133 + const present = (target: string) =>
134 + fileSystem.exists(target).pipe(Effect.orElseSucceed(() => true));
135 + if (yield* present(path.join(adminDir, "modules"))) return yield* submodules;
136 + const index = yield* gitOutput(worktreePath, ["ls-files", "--stage", "-z"], boundEnv);
137 + for (const entry of index.split("\0")) {
138 + if (!entry.startsWith("160000 ")) continue;
139 + const submodule = entry.slice(entry.indexOf("\t") + 1);
140 + if (yield* present(path.join(worktreePath, submodule, ".git"))) return yield* submodules;
141 + }
142 + const status = yield* gitOutput(
143 + worktreePath,
144 + [...statusConfig, "status", "--porcelain", "--ignore-submodules=none"],
145 + boundEnv,
146 + );
147 + if (status !== "")
148 + return yield* refuse(
149 + `'${worktreePath}' contains modified or untracked files, use --force to delete it`,
150 + );
151 + }
152 +
153 + // A file held open can stop the delete partway. Putting `.git` back, when
154 + // that works, leaves a worktree that a retry can remove.
155 + const gitFileContents = yield* fileSystem
156 + .readFileString(gitFile)
157 + .pipe(Effect.mapError(() => notAWorktree));
158 + yield* fileSystem.remove(worktreePath, { recursive: true }).pipe(
159 + Effect.tapError(() => fileSystem.writeFileString(gitFile, gitFileContents).pipe(Effect.ignore)),
160 + Effect.mapError((cause) => refuse(`failed to delete '${worktreePath}'`, cause)),
161 + );
162 + // The folder is gone, so Git only drops the worktree's metadata.
163 + return yield* input.run(["worktree", "remove", "--force", "--force", "--", worktreePath]);
164 +});