Skip to content

Commit 4331437

Browse files
committed
fix(server): support worktrees from empty repositories
1 parent d5b921c commit 4331437

4 files changed

Lines changed: 184 additions & 25 deletions

File tree

‎apps/server/src/git/GitWorkflowService.test.ts‎

Lines changed: 42 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,48 @@ import * as GitWorkflowService from "./GitWorkflowService.ts";
1212
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
1313
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
1414

15+
function realGitLayer(prefix: string) {
16+
return GitWorkflowService.layer.pipe(
17+
Layer.provide(
18+
Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
19+
resolve: () => Effect.succeed({ kind: "git" } as VcsDriverRegistry.VcsDriverHandle),
20+
}),
21+
),
22+
Layer.provide(Layer.mock(GitManager.GitManager)({})),
23+
Layer.provideMerge(GitVcsDriver.layer),
24+
Layer.provideMerge(VcsProcess.layer),
25+
Layer.provideMerge(
26+
ServerConfig.layerTest(process.cwd(), { prefix }).pipe(Layer.provide(NodeServices.layer)),
27+
),
28+
Layer.provideMerge(NodeServices.layer),
29+
);
30+
}
31+
1532
it.layer(NodeServices.layer)("GitWorkflowService", (it) => {
33+
it.effect("finds a ref only once the repository has a commit", () =>
34+
Effect.gen(function* () {
35+
const fileSystem = yield* FileSystem.FileSystem;
36+
const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-any-ref-" });
37+
const workflow = yield* GitWorkflowService.GitWorkflowService;
38+
const driver = yield* GitVcsDriver.GitVcsDriver;
39+
const git = (args: string[]) => driver.execute({ operation: "test.setupRepo", cwd, args });
40+
yield* git(["init", "-b", "main"]);
41+
assert.isFalse(yield* workflow.hasAnyRef(cwd));
42+
yield* git([
43+
"-c",
44+
"user.email=t@t",
45+
"-c",
46+
"user.name=t",
47+
"commit",
48+
"--allow-empty",
49+
"-m",
50+
"init",
51+
]);
52+
yield* git(["checkout", "--orphan", "unborn"]);
53+
assert.isTrue(yield* workflow.hasAnyRef(cwd));
54+
}).pipe(Effect.scoped, Effect.provide(realGitLayer("t3-any-ref-"))),
55+
);
56+
1657
it.effect("finds a name among the refs of every namespace", () =>
1758
Effect.gen(function* () {
1859
const fileSystem = yield* FileSystem.FileSystem;
@@ -33,26 +74,6 @@ it.layer(NodeServices.layer)("GitWorkflowService", (it) => {
3374
(refName) => workflow.hasRefNamed({ cwd, refName }),
3475
);
3576
assert.deepEqual(found, [true, true, true, true, false, false]);
36-
}).pipe(
37-
Effect.scoped,
38-
Effect.provide(
39-
GitWorkflowService.layer.pipe(
40-
Layer.provide(
41-
Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
42-
resolve: () => Effect.succeed({ kind: "git" } as VcsDriverRegistry.VcsDriverHandle),
43-
}),
44-
),
45-
Layer.provide(Layer.mock(GitManager.GitManager)({})),
46-
Layer.provideMerge(GitVcsDriver.layer),
47-
Layer.provideMerge(VcsProcess.layer),
48-
Layer.provideMerge(
49-
ServerConfig.layerTest(process.cwd(), { prefix: "t3-ref-named-" }).pipe(
50-
Layer.provide(NodeServices.layer),
51-
),
52-
),
53-
Layer.provideMerge(NodeServices.layer),
54-
),
55-
),
56-
),
77+
}).pipe(Effect.scoped, Effect.provide(realGitLayer("t3-ref-named-"))),
5778
);
5879
});

‎apps/server/src/git/GitWorkflowService.ts‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,7 @@ export class GitWorkflowService extends Context.Service<
4646
readonly cwd: string;
4747
readonly refName: string;
4848
}) => Effect.Effect<boolean, GitCommandError>;
49+
readonly hasAnyRef: (cwd: string) => Effect.Effect<boolean, GitCommandError>;
4950
readonly status: (
5051
input: VcsStatusInput,
5152
) => Effect.Effect<VcsStatusResult, GitManagerServiceError>;
@@ -343,6 +344,17 @@ export const make = Effect.gen(function* () {
343344
),
344345
Effect.map((result) => result.stdout.trim().length > 0),
345346
),
347+
hasAnyRef: (cwd) =>
348+
ensureGitCommand("GitWorkflowService.hasAnyRef", cwd).pipe(
349+
Effect.andThen(
350+
git.execute({
351+
operation: "GitWorkflowService.hasAnyRef",
352+
cwd,
353+
args: ["for-each-ref", "--count=1", "--format=%(refname)"],
354+
}),
355+
),
356+
Effect.map((result) => result.stdout.trim().length > 0),
357+
),
346358
status: (input) =>
347359
detectGitRepositoryForStatus("GitWorkflowService.status", input.cwd).pipe(
348360
Effect.flatMap((isGitRepository) =>

‎apps/server/src/orchestration-v2/ThreadLaunchService.test.ts‎

Lines changed: 101 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -197,7 +197,7 @@ function makeHarness(options: HarnessOptions = {}) {
197197
fetchWorktreeBaseCommit:
198198
options.fetchWorktreeBaseCommit ??
199199
(() => Effect.succeed({ commitSha: "remote-main-sha", remoteRefName: "origin/main" })),
200-
hasCommit: options.hasCommit ?? (() => Effect.succeed(false)),
200+
hasCommit: options.hasCommit ?? (({ refName }) => Effect.succeed(refName === "HEAD")),
201201
resolveWorktreeBaseRemote: () => Effect.succeed({ remoteName: "origin", branchName: "main" }),
202202
remoteExists: options.remoteExists ?? (() => Effect.succeed(true)),
203203
remoteBranchExists: () => Effect.succeed(true),
@@ -1017,6 +1017,106 @@ it.effect("runs a Scratch scheduled task saved with a worktree in its own folder
10171017
}).pipe(Effect.provide(harness.layer));
10181018
});
10191019

1020+
it.effect(
1021+
"runs a new worktree thread in the project folder when the repository has no commits",
1022+
() =>
1023+
Effect.gen(function* () {
1024+
const harness = makeHarness({
1025+
hasCommit: () => Effect.succeed(false),
1026+
git: { hasAnyRef: () => Effect.succeed(false) },
1027+
});
1028+
yield* Effect.gen(function* () {
1029+
const launches = yield* ThreadLaunch.ThreadLaunchService;
1030+
const threads = yield* ThreadManagement.ThreadManagementService;
1031+
const input = launchInput({
1032+
command: "command:launch:empty-repo",
1033+
thread: "thread:launch:empty-repo",
1034+
message: "Build the feature",
1035+
workspace: { type: "worktree", baseRef: "main" },
1036+
});
1037+
const launched = yield* launches.launch(input);
1038+
yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
1039+
Stream.takeUntil(
1040+
(stored) =>
1041+
stored.commandId === CommandId.make(`${input.commandId}:release`) &&
1042+
stored.event.type === "run.updated",
1043+
),
1044+
Stream.runDrain,
1045+
);
1046+
const { thread, runs } = yield* threads.getThreadProjection(launched.threadId);
1047+
assert.isNull(thread.worktreePath);
1048+
assert.isNull(thread.branch);
1049+
assert.equal(harness.createWorktree.mock.calls.length, 0);
1050+
// The orchestrator reads a worktree preparation without a worktree as
1051+
// failed setup and holds the queue behind it.
1052+
assert.deepEqual(runs[0]?.workspacePreparation, { type: "root" });
1053+
}).pipe(Effect.provide(harness.layer));
1054+
}),
1055+
);
1056+
1057+
it.effect.each([
1058+
{
1059+
name: "the base is fetched from origin",
1060+
startFromOrigin: true,
1061+
hasAnyRef: false,
1062+
baseRef: "main",
1063+
requestedBaseHasCommit: false,
1064+
},
1065+
{
1066+
name: "another ref has a commit",
1067+
startFromOrigin: false,
1068+
hasAnyRef: true,
1069+
baseRef: "main",
1070+
requestedBaseHasCommit: false,
1071+
},
1072+
{
1073+
name: "the requested base is a commit by SHA",
1074+
startFromOrigin: false,
1075+
hasAnyRef: false,
1076+
baseRef: "requested-base-sha",
1077+
requestedBaseHasCommit: true,
1078+
},
1079+
])("keeps the worktree when HEAD has no commit but $name", (testCase) =>
1080+
Effect.gen(function* () {
1081+
const harness = makeHarness({
1082+
hasCommit: ({ refName }) =>
1083+
Effect.succeed(
1084+
refName === "remote-main-sha" ||
1085+
(testCase.requestedBaseHasCommit === true && refName === testCase.baseRef),
1086+
),
1087+
git: { hasAnyRef: () => Effect.succeed(testCase.hasAnyRef) },
1088+
});
1089+
yield* Effect.gen(function* () {
1090+
const launches = yield* ThreadLaunch.ThreadLaunchService;
1091+
const threads = yield* ThreadManagement.ThreadManagementService;
1092+
const input = launchInput({
1093+
command: `command:launch:empty-repo-${testCase.startFromOrigin}`,
1094+
thread: `thread:launch:empty-repo-${testCase.startFromOrigin}`,
1095+
message: "Build the feature",
1096+
workspace: {
1097+
type: "worktree",
1098+
baseRef: testCase.baseRef,
1099+
startFromOrigin: testCase.startFromOrigin,
1100+
},
1101+
});
1102+
const launched = yield* launches.launch(input);
1103+
yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
1104+
Stream.takeUntil(
1105+
(stored) =>
1106+
stored.commandId === CommandId.make(`${input.commandId}:release`) &&
1107+
stored.event.type === "run.updated",
1108+
),
1109+
Stream.runDrain,
1110+
);
1111+
assert.equal(harness.createWorktree.mock.calls.length, 1);
1112+
assert.equal(
1113+
harness.createWorktree.mock.calls[0]?.[0]?.refName,
1114+
testCase.startFromOrigin ? "remote-main-sha" : testCase.baseRef,
1115+
);
1116+
}).pipe(Effect.provide(harness.layer));
1117+
}),
1118+
);
1119+
10201120
it.effect.each(["stable", "upstream/release"])(
10211121
"launches from %s with the fetched commit and remote PR base",
10221122
(baseRef) =>

‎apps/server/src/orchestration-v2/ThreadLaunchService.ts‎

Lines changed: 29 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -283,6 +283,30 @@ const make = Effect.gen(function* () {
283283
});
284284
});
285285

286+
const hasNoCommitToCheckOut = Effect.fn("ThreadLaunchService.hasNoCommitToCheckOut")(
287+
function* (
288+
projectId: ProjectId,
289+
strategy: Extract<ThreadLaunchWorkspaceStrategy, { readonly type: "worktree" }>,
290+
) {
291+
const project = Option.getOrUndefined(yield* projects.getById(projectId));
292+
if (project === undefined) return false;
293+
const cwd = project.workspaceRoot;
294+
// A base SHA can be checkoutable even when the repository has no refs.
295+
if (
296+
(yield* git.hasCommit({ cwd, refName: "HEAD" })) ||
297+
(yield* git.hasCommit({ cwd, refName: strategy.baseRef })) ||
298+
(yield* git.hasAnyRef(cwd))
299+
)
300+
return false;
301+
// Provisioning fetches the base first, which may bring the first commit.
302+
return !(
303+
strategy.startFromOrigin === true &&
304+
(yield* git.resolveWorktreeBaseRemote({ cwd, refName: strategy.baseRef })) !== null
305+
);
306+
},
307+
Effect.orElseSucceed(() => false),
308+
);
309+
286310
const prepareInBackground = Effect.fn("ThreadLaunchService.prepareInBackground")(function* (
287311
input: PreparationInput,
288312
threadId: ThreadId,
@@ -801,11 +825,13 @@ const make = Effect.gen(function* () {
801825

802826
const launch: ThreadLaunchService["Service"]["launch"] = Effect.fn("ThreadLaunchService.launch")(
803827
function* (request) {
804-
// Scratch has no Git repository. Normalize before folder allocation so
805-
// durable preparation and retries use the thread's own Scratch folder.
828+
// Scratch has no Git repository, and `git worktree add` needs a commit to
829+
// start from. Normalize before folder allocation so durable preparation
830+
// and retries use the thread's own folder.
806831
const input: ThreadLaunchInput =
807832
request.workspaceStrategy.type === "worktree" &&
808-
(yield* managedFolders.isScratchProject(request.projectId))
833+
((yield* managedFolders.isScratchProject(request.projectId)) ||
834+
(yield* hasNoCommitToCheckOut(request.projectId, request.workspaceStrategy)))
809835
? { ...request, workspaceStrategy: { type: "root" } }
810836
: request;
811837
yield* ProjectCloneTracker.rejectCommandsDuringClone(cloneTracker, {

0 commit comments

Comments
 (0)