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

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

fix(server): reverting to a checkpoint restores skip-worktree files (#36308)

Julius Marminge committed Nov 13, 2026 at 12:09 UTC 1a4a29998be205ad8fbb8dd6eefc2a730f025ca5
2 files changed +161 -10
apps/server/src/vcs/GitVcsDriver.test.ts
+81
@@ -1273,6 +1273,87 @@ it.effect("restores a checkpoint before the first commit without staging its fil
1273 }).pipe(Effect.scoped, Effect.provide(layerGitContract)),
1274 );
1275
1276 +it.effect("restores edits to skip-worktree files whose checkpoint content matches HEAD", () =>
1277 + Effect.gen(function* () {
1278 + const fileSystem = yield* FileSystem.FileSystem;
1279 + const path = yield* Path.Path;
1280 + const driver = yield* GitVcsDriver.makeVcsDriverShape();
1281 + const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-skip-worktree-restore-" });
1282 + const { git, checkpointRef } = yield* makeCheckpointFixture(driver, cwd);
1283 + const skippedPath = path.join(cwd, "skipped.txt");
1284 + yield* fileSystem.writeFileString(skippedPath, "original\n");
1285 + yield* git(["add", "skipped.txt"]);
1286 + yield* git(["commit", "-m", "add skipped file"]);
1287 + yield* git(["update-index", "--skip-worktree", "skipped.txt"]);
1288 + yield* driver.checkpoints.captureCheckpoint({ cwd, checkpointRef });
1289 + yield* fileSystem.writeFileString(skippedPath, "later\n");
1290 +
1291 + assert.isTrue(
1292 + yield* driver.checkpoints.restoreCheckpoint({ cwd, checkpointRef, fallbackToHead: false }),
1293 + );
1294 +
1295 + assert.strictEqual(yield* fileSystem.readFileString(skippedPath), "original\n");
1296 + }).pipe(Effect.scoped, Effect.provide(layerGitContract)),
1297 +);
1298 +
1299 +it.effect("sparse restore rewrites manual skip-worktree files and keeps exclusions absent", () =>
1300 + Effect.gen(function* () {
1301 + const fs = yield* FileSystem.FileSystem;
1302 + const path = yield* Path.Path;
1303 + const liveProcess = yield* VcsProcess.VcsProcess;
1304 + // One byte per chunk, so the index listing splits inside every record.
1305 + const driver = yield* GitVcsDriver.makeVcsDriverShape().pipe(
1306 + Effect.provideService(VcsProcess.VcsProcess, {
1307 + run: (input) => {
1308 + const onStdoutChunk = input.onStdoutChunk;
1309 + return liveProcess.run(
1310 + onStdoutChunk === undefined
1311 + ? input
1312 + : {
1313 + ...input,
1314 + onStdoutChunk: (chunk) => {
1315 + for (let index = 0; index < chunk.length; index++)
1316 + onStdoutChunk(chunk.subarray(index, index + 1));
1317 + },
1318 + },
1319 + );
1320 + },
1321 + }),
1322 + );
1323 + const cwd = yield* fs.makeTempDirectoryScoped({ prefix: "t3-sparse-restore-" });
1324 + const { git, checkpointRef } = yield* makeCheckpointFixture(driver, cwd);
1325 + for (const name of ["in/normal", "in/skipped", "in/s space", "out/deep/absent", "out/stray"]) {
1326 + yield* fs.makeDirectory(path.dirname(path.join(cwd, name)), { recursive: true });
1327 + yield* fs.writeFileString(path.join(cwd, name), "original\n");
1328 + }
1329 + yield* git(["add", "."]);
1330 + yield* git(["commit", "-m", "sparse fixture"]);
1331 + yield* git(["sparse-checkout", "set", "--cone", "--sparse-index", "in"]);
1332 + // Keeps Git from clearing the bit on files that are present.
1333 + yield* git(["config", "sparse.expectFilesOutsideOfPatterns", "true"]);
1334 + yield* git(["update-index", "--skip-worktree", "in/skipped", "in/s space"]);
1335 + const captureCwd = path.join(cwd, "in");
1336 + yield* driver.checkpoints.captureCheckpoint({ cwd: captureCwd, checkpointRef });
1337 + yield* fs.writeFileString(path.join(cwd, "in/skipped"), "later\n");
1338 + yield* fs.writeFileString(path.join(cwd, "in/s space"), "later\n");
1339 + yield* fs.writeFileString(path.join(cwd, "in/normal"), "later\n");
1340 +
1341 + for (const restoreCwd of [captureCwd, cwd]) {
1342 + assert.isTrue(
1343 + yield* driver.checkpoints.restoreCheckpoint({
1344 + cwd: restoreCwd,
1345 + checkpointRef,
1346 + fallbackToHead: false,
1347 + }),
1348 + );
1349 + assert.strictEqual(yield* fs.readFileString(path.join(cwd, "in/skipped")), "original\n");
1350 + assert.strictEqual(yield* fs.readFileString(path.join(cwd, "in/s space")), "original\n");
1351 + assert.strictEqual(yield* fs.readFileString(path.join(cwd, "in/normal")), "original\n");
1352 + assert.isFalse(yield* fs.exists(path.join(cwd, "out")));
1353 + }
1354 + }).pipe(Effect.scoped, Effect.provide(layerGitContract)),
1355 +);
1356 +
1357 // The real VCS process, spawning `command` wherever the driver runs git.
1358 const vcsProcessSpawning = (command: string) =>
1359 Layer.effect(
apps/server/src/vcs/GitVcsDriver.ts
+80 -10
@@ -1390,20 +1390,90 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* (
1390 });
1391 // An empty index and checkpoint have nothing for git restore's pathspec to match.
1392 if (tracked.stdout.length > 0) {
1393 + const sparseConfig = yield* execute({
1394 + operation,
1395 + cwd: input.cwd,
1396 + args: ["config", "--bool", "core.sparseCheckout"],
1397 + allowNonZeroExit: true,
1398 + });
1399 + const sparseCheckout = sparseConfig.stdout.trim() === "true";
1400 + const restore = [...longPaths, "restore", "--source", commitOid, "--worktree", "--staged"];
1401 + // restore leaves skip-worktree paths alone. Outside a sparse checkout every such bit was
1402 + // set by hand and capture recorded the file, so override them all.
1403 yield* execute({
1404 operation,
1405 cwd: input.cwd,
1396 - args: [
1397 - ...longPaths,
1398 - "restore",
1399 - "--source",
1400 - commitOid,
1401 - "--worktree",
1402 - "--staged",
1403 - "--",
1404 - ".",
1405 - ],
1406 + args: [...restore, ...(sparseCheckout ? [] : ["--ignore-skip-worktree-bits"]), "--", "."],
1407 });
1408 + if (sparseCheckout) {
1409 + // Sparse exclusions stay excluded; only skip-worktree paths the rules select are manual.
1410 + const manual = yield* Effect.gen(function* () {
1411 + const skipped: string[] = [];
1412 + let recordStart = true;
1413 + let keep = false;
1414 + let record: Uint8Array[] = [];
1415 + yield* vcsProcess.run({
1416 + operation,
1417 + command: "git",
1418 + cwd: input.cwd,
1419 + args: ["ls-files", "--full-name", "--sparse", "-v", "-z", "--", "."],
1420 + maxOutputBytes: 4_096,
1421 + outputMode: "truncate",
1422 + // The index can be huge; keep only the "S "/"s " records of the NUL-delimited list.
1423 + onStdoutChunk: (chunk) => {
1424 + let start = 0;
1425 + while (start < chunk.length) {
1426 + const end = chunk.indexOf(0, start);
1427 + if (recordStart) {
1428 + keep = chunk[start] === 83 || chunk[start] === 115;
1429 + record = [];
1430 + }
1431 + if (keep) {
1432 + record.push(Buffer.from(chunk.subarray(start, end === -1 ? undefined : end)));
1433 + if (end !== -1) {
1434 + const entry = Buffer.concat(record).subarray(2);
1435 + record = [];
1436 + // Sparse directory entries are exclusions; stdin cannot carry non-UTF-8.
1437 + if (entry.at(-1) !== 47 && NodeBuffer.isUtf8(entry))
1438 + skipped.push(entry.toString("utf8"));
1439 + }
1440 + }
1441 + recordStart = end !== -1;
1442 + if (!recordStart) break;
1443 + start = end + 1;
1444 + }
1445 + },
1446 + });
1447 + if (skipped.length === 0) return skipped;
1448 + const stdin = skipped.join("\0") + "\0";
1449 + // check-rules echoes a subset of its input, so the input size bounds its output.
1450 + const rules = yield* execute({
1451 + operation,
1452 + cwd: input.cwd,
1453 + args: ["sparse-checkout", "check-rules", "-z"],
1454 + stdin,
1455 + maxOutputBytes: Buffer.byteLength(stdin),
1456 + outputMode: "error",
1457 + });
1458 + return rules.stdout.split("\0").filter((entry) => entry.length > 0);
1459 + }).pipe(
1460 + // A Git without ls-files --sparse or check-rules keeps the plain restore's result.
1461 + Effect.orElseSucceed((): string[] => []),
1462 + );
1463 + if (manual.length > 0) {
1464 + yield* execute({
1465 + operation,
1466 + cwd: input.cwd,
1467 + args: [
1468 + ...restore,
1469 + "--ignore-skip-worktree-bits",
1470 + "--pathspec-from-file=-",
1471 + "--pathspec-file-nul",
1472 + ],
1473 + stdin: manual.map((entry) => `:(top,literal)${entry}\0`).join(""),
1474 + });
1475 + }
1476 + }
1477 }
1478 // Restoring away the last tracked file can remove a nested workspace directory.
1479 const recreateWorkspace = fileSystem.makeDirectory(input.cwd, { recursive: true }).pipe(