Skip to content

Commit 11a099f

Browse files
committed
fix(server): support worktrees from empty repositories
1 parent 87ea18c commit 11a099f

4 files changed

Lines changed: 185 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: 13 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>;
@@ -346,6 +347,18 @@ export const make = Effect.gen(function* () {
346347
Effect.map((result) => result.stdout.trim().length > 0),
347348
);
348349
}),
350+
hasAnyRef: Effect.fn("GitWorkflowService.hasAnyRef")(function (cwd) {
351+
return ensureGitCommand("GitWorkflowService.hasAnyRef", cwd).pipe(
352+
Effect.andThen(
353+
git.execute({
354+
operation: "GitWorkflowService.hasAnyRef",
355+
cwd,
356+
args: ["for-each-ref", "--count=1", "--format=%(refname)"],
357+
}),
358+
),
359+
Effect.map((result) => result.stdout.trim().length > 0),
360+
);
361+
}),
349362
status: Effect.fn("GitWorkflowService.status")(function (input) {
350363
return detectGitRepositoryForStatus("GitWorkflowService.status", input.cwd).pipe(
351364
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
@@ -198,7 +198,7 @@ function makeHarness(options: HarnessOptions = {}) {
198198
fetchWorktreeBaseCommit:
199199
options.fetchWorktreeBaseCommit ??
200200
(() => Effect.succeed({ commitSha: "remote-main-sha", remoteRefName: "origin/main" })),
201-
hasCommit: options.hasCommit ?? (() => Effect.succeed(false)),
201+
hasCommit: options.hasCommit ?? (({ refName }) => Effect.succeed(refName === "HEAD")),
202202
resolveWorktreeBaseRemote: () => Effect.succeed({ remoteName: "origin", branchName: "main" }),
203203
remoteExists: options.remoteExists ?? (() => Effect.succeed(true)),
204204
remoteBranchExists: () => Effect.succeed(true),
@@ -1018,6 +1018,106 @@ it.effect("runs a Scratch scheduled task saved with a worktree in its own folder
10181018
}).pipe(Effect.provide(harness.layer));
10191019
});
10201020

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