From 699b19b5d607afe68ce45a4cd6944928e47e53b2 Mon Sep 17 00:00:00 2001 From: Mohamed Boudra Date: Thu, 19 Nov 2026 04:49:24 +0100 Subject: [PATCH] feat(server): branch off a pull request and list every git worktree A workspace.create worktree source with action "branch-off" and a checkoutSource used to check the pull request out, because core took any change request as a checkout. Branch-off now fetches the pull request's head into a remote-tracking ref (origin/ for a same-repo head, paseo-pr-/ otherwise) and starts the new branch there, with no upstream and no remote added. A request with no action still checks the pull request out, as older clients expect. checkout.worktrees.list returns all git worktrees of the repository, not only the ones Paseo created, so the New workspace screen can offer any of them. Bare and prunable entries are left out. Hosts advertise both through server_info.features: worktreeRefActions and checkoutWorktreeList. Older hosts ignore the branch-off action on a pull request, so the app must gate on the flag. --- packages/client/src/daemon-client.ts | 18 ++++ packages/protocol/src/messages.ts | 36 +++++++ .../authorization/operation-permissions.ts | 2 + .../resolve-worktree-creation-intent.test.ts | 3 + .../resolve-worktree-creation-intent.ts | 52 +++++++++- packages/server/src/server/session.ts | 2 + .../session/checkout/checkout-session.ts | 19 ++++ .../server/src/server/websocket-server.ts | 4 + ...rkspace-create-worktree-source.e2e.test.ts | 37 +++++++ .../src/server/worktree-core.posix.test.ts | 97 +++++++++++++++++++ packages/server/src/server/worktree-core.ts | 11 ++- .../server/src/utils/worktree.posix.test.ts | 40 ++++++++ packages/server/src/utils/worktree.ts | 77 ++++++++++++--- 13 files changed, 380 insertions(+), 18 deletions(-) diff --git a/packages/client/src/daemon-client.ts b/packages/client/src/daemon-client.ts index e677fbe3b0..04af82f604 100644 --- a/packages/client/src/daemon-client.ts +++ b/packages/client/src/daemon-client.ts @@ -68,6 +68,7 @@ import type { GitSetupOptions, CheckoutStatusResponse, CheckoutCommit, + CheckoutWorktree, ParsedDiffFile, CheckoutCommitResponse, CheckoutMergeResponse, @@ -5133,6 +5134,23 @@ export class DaemonClient { return { baseRef: payload.baseRef, commits: payload.commits }; } + /** Every git worktree of the repository `cwd` is in, whoever created it. */ + async listCheckoutWorktrees(cwd: string, requestId?: string): Promise { + const payload = + await this.sendNamespacedCorrelatedSessionRequest<"checkout.worktrees.list.response">({ + requestId, + message: { + type: "checkout.worktrees.list.request", + cwd, + }, + timeout: 60000, + }); + if (payload.error) { + throw new Error(payload.error.message); + } + return payload.worktrees; + } + async getCommitFileDiff( cwd: string, sha: string, diff --git a/packages/protocol/src/messages.ts b/packages/protocol/src/messages.ts index e62cf8357e..1691cded54 100644 --- a/packages/protocol/src/messages.ts +++ b/packages/protocol/src/messages.ts @@ -2612,6 +2612,12 @@ export const CheckoutCommitsListRequestSchema = z.object({ requestId: z.string(), }); +export const CheckoutWorktreesListRequestSchema = z.object({ + type: z.literal("checkout.worktrees.list.request"), + cwd: z.string(), + requestId: z.string(), +}); + export const CheckoutCommitFileDiffRequestSchema = z.object({ type: z.literal("checkout.commits.file_diff.request"), cwd: z.string(), @@ -3654,6 +3660,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [ CheckoutForgeSetAutoMergeRequestSchema, CheckoutGithubSetAutoMergeRequestSchema, CheckoutCommitsListRequestSchema, + CheckoutWorktreesListRequestSchema, CheckoutCommitFileDiffRequestSchema, CheckoutForgeGetCheckDetailsRequestSchema, CheckoutGithubGetCheckDetailsRequestSchema, @@ -3945,6 +3952,11 @@ export const ServerInfoStatusPayloadSchema = z terminalCollection: z.boolean().optional(), // COMPAT(workspaceBaseBranch): added after v0.11.2, remove gate after 2027-10-14. workspaceBaseBranch: z.boolean().optional(), + // COMPAT(checkoutWorktreeList): added after v0.16.2, remove gate after 2027-11-19. + checkoutWorktreeList: z.boolean().optional(), + // COMPAT(worktreeRefActions): added after v0.16.2, remove gate after 2027-11-19. + // Hosts without it check out a change request even when asked to branch off it. + worktreeRefActions: z.boolean().optional(), // COMPAT(workspaceSetupRun): added in v0.8.0, remove gate after 2027-09-02. workspaceSetupRun: z.boolean().optional(), // COMPAT(workspaceTerminals): added in v0.8.0, remove gate after 2027-09-05. @@ -6088,6 +6100,26 @@ export const CheckoutCommitsListResponseSchema = z.object({ }), }); +export const CheckoutWorktreeSchema = z.object({ + path: z.string(), + // null when HEAD is detached + branchName: z.string().nullable(), + head: z.string().nullable(), + createdAt: z.string(), // ISO 8601 + // true for the worktree the request's cwd is in + containsCwd: z.boolean(), +}); + +export const CheckoutWorktreesListResponseSchema = z.object({ + type: z.literal("checkout.worktrees.list.response"), + payload: z.object({ + cwd: z.string(), + worktrees: z.array(CheckoutWorktreeSchema), + error: CheckoutErrorSchema.nullable(), + requestId: z.string(), + }), +}); + export const CheckoutCommitFileDiffResponseSchema = z.object({ type: z.literal("checkout.commits.file_diff.response"), payload: z.object({ @@ -7588,6 +7620,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [ CheckoutForgeSetAutoMergeResponseSchema, CheckoutGithubSetAutoMergeResponseSchema, CheckoutCommitsListResponseSchema, + CheckoutWorktreesListResponseSchema, CheckoutCommitFileDiffResponseSchema, CheckoutForgeGetCheckDetailsResponseSchema, CheckoutGithubGetCheckDetailsResponseSchema, @@ -7972,6 +8005,9 @@ export type CheckoutCommitFile = z.infer; export type CheckoutCommit = z.infer; export type CheckoutCommitsListRequest = z.infer; export type CheckoutCommitsListResponse = z.infer; +export type CheckoutWorktree = z.infer; +export type CheckoutWorktreesListRequest = z.infer; +export type CheckoutWorktreesListResponse = z.infer; export type CheckoutCommitFileDiffRequest = z.infer; export type CheckoutCommitFileDiffResponse = z.infer; export type ParsedDiffFile = z.infer; diff --git a/packages/server/src/server/authorization/operation-permissions.ts b/packages/server/src/server/authorization/operation-permissions.ts index 2015316b07..2214f6bb5e 100644 --- a/packages/server/src/server/authorization/operation-permissions.ts +++ b/packages/server/src/server/authorization/operation-permissions.ts @@ -53,6 +53,7 @@ const INBOUND_PERMISSION = { "chat/wait": "workspace.read", "checkout.commits.file_diff.request": "workspace.read", "checkout.commits.list.request": "workspace.read", + "checkout.worktrees.list.request": "workspace.read", "checkout.discard_changes.request": "workspace.write", "checkout.forge.get_check_details.request": "workspace.read", "checkout.forge.set_auto_merge.request": "workspace.write", @@ -303,6 +304,7 @@ const OUTBOUND_PERMISSION = { "chat/wait/response": "workspace.read", "checkout.commits.file_diff.response": "workspace.read", "checkout.commits.list.response": "workspace.read", + "checkout.worktrees.list.response": "workspace.read", "checkout.discard_changes.response": "workspace.write", "checkout.forge.get_check_details.response": "workspace.read", "checkout.forge.set_auto_merge.response": "workspace.write", diff --git a/packages/server/src/server/resolve-worktree-creation-intent.test.ts b/packages/server/src/server/resolve-worktree-creation-intent.test.ts index 8d44b9ba80..18c805c724 100644 --- a/packages/server/src/server/resolve-worktree-creation-intent.test.ts +++ b/packages/server/src/server/resolve-worktree-creation-intent.test.ts @@ -6,6 +6,7 @@ import { CheckoutSourceForgeMismatchError, MissingCheckoutTargetError, resolveWorktreeCreationIntent, + type ResolveWorktreeCreationIntentDeps, UnsupportedForgeCheckoutTargetError, } from "./resolve-worktree-creation-intent.js"; @@ -19,6 +20,7 @@ interface ResolverHarness { forgeService: ForgeService; headRefLookups: GitHubHeadRefLookup[]; resolveDefaultBranch: (repoRoot: string) => Promise; + fetchRef: ResolveWorktreeCreationIntentDeps["fetchRef"]; } function createResolverHarness(overrides?: { @@ -86,6 +88,7 @@ function createResolverHarness(overrides?: { forgeService, headRefLookups, resolveDefaultBranch: async () => "main", + fetchRef: async () => {}, }; } diff --git a/packages/server/src/server/resolve-worktree-creation-intent.ts b/packages/server/src/server/resolve-worktree-creation-intent.ts index 34d587da03..639b0bb839 100644 --- a/packages/server/src/server/resolve-worktree-creation-intent.ts +++ b/packages/server/src/server/resolve-worktree-creation-intent.ts @@ -1,5 +1,5 @@ import type { ForgeService, PullRequestCheckoutTarget } from "../services/forge-service.js"; -import type { WorktreeSource } from "../utils/worktree.js"; +import type { WorktreeCheckoutRef, WorktreeSource } from "../utils/worktree.js"; export type WorktreeCreationIntent = Exclude< WorktreeSource, @@ -29,6 +29,14 @@ export interface ResolveWorktreeCreationIntentDeps { forge: string; forgeService: ForgeService; resolveDefaultBranch: (repoRoot: string) => Promise; + /** Fetches the first ref a remote serves into a local ref. */ + fetchRef: (input: FetchRefInput) => Promise; +} + +export interface FetchRefInput { + repoRoot: string; + sources: WorktreeCheckoutRef[]; + destination: string; } export class MissingCheckoutTargetError extends Error { @@ -70,9 +78,13 @@ export async function resolveWorktreeCreationIntent( deps: ResolveWorktreeCreationIntentDeps, ): Promise { if (input.action === "branch-off") { + const changeRequest = resolveInputChangeRequest(input); + const baseBranch = changeRequest + ? await fetchChangeRequestHead({ input, changeRequest, repoRoot, deps }) + : input.refName?.trim() || (await resolveDefaultBranch(repoRoot, deps)); return { kind: "branch-off", - baseBranch: input.refName?.trim() || (await resolveDefaultBranch(repoRoot, deps)), + baseBranch, branchName: input.branchName ?? input.worktreeSlug ?? "worktree", }; } @@ -126,6 +138,34 @@ export async function resolveWorktreeCreationIntent( }; } +/** + * Brings a change request's head into a remote-tracking ref, so a new branch can start from it + * without checking the change request out. A same-repository head lands where `git fetch` puts + * the branch; any other head lands under `paseo-pr-`, the remote a checkout of the same + * change request pushes to. + */ +async function fetchChangeRequestHead(params: { + input: ResolveWorktreeCreationIntentInput; + changeRequest: { number: number; forge?: string }; + repoRoot: string; + deps: ResolveWorktreeCreationIntentDeps; +}): Promise { + const { input, changeRequest, repoRoot, deps } = params; + assertCheckoutSourceMatchesResolvedForge(changeRequest, deps); + const checkout = await resolvePrCheckoutIntent({ + refName: input.refName, + changeRequestNumber: changeRequest.number, + repoRoot, + deps, + }); + const headBranch = checkout.headRef.startsWith("refs/") ? "head" : checkout.headRef; + const destination = checkout.trackOriginHead + ? `refs/remotes/origin/${headBranch}` + : `refs/remotes/paseo-pr-${changeRequest.number}/${headBranch}`; + await deps.fetchRef({ repoRoot, sources: checkout.checkoutRefs, destination }); + return destination; +} + interface PrCheckoutIntentParams { refName?: string; changeRequestNumber: number; @@ -163,9 +203,11 @@ function assertCheckoutSourceMatchesResolvedForge( } } -async function resolvePrCheckoutIntent( - params: PrCheckoutIntentParams, -): Promise> { +async function resolvePrCheckoutIntent(params: PrCheckoutIntentParams): Promise< + Extract & { + checkoutRefs: WorktreeCheckoutRef[]; + } +> { const { deps } = params; const service = deps.forgeService; const checkoutTarget = await resolvePrCheckoutTarget(params); diff --git a/packages/server/src/server/session.ts b/packages/server/src/server/session.ts index 2bdad76ba3..7158750e2c 100644 --- a/packages/server/src/server/session.ts +++ b/packages/server/src/server/session.ts @@ -3322,6 +3322,8 @@ export class Session { return this.checkoutSession.handleStatusRequest(msg); case "checkout.commits.list.request": return this.checkoutSession.handleCommitsListRequest(msg); + case "checkout.worktrees.list.request": + return this.checkoutSession.handleWorktreesListRequest(msg); case "checkout.commits.file_diff.request": return this.checkoutSession.handleCommitFileDiffRequest(msg, this.delivery.requestSignal); case "validate_branch_request": diff --git a/packages/server/src/server/session/checkout/checkout-session.ts b/packages/server/src/server/session/checkout/checkout-session.ts index 1611356bc8..8f180a36c4 100644 --- a/packages/server/src/server/session/checkout/checkout-session.ts +++ b/packages/server/src/server/session/checkout/checkout-session.ts @@ -11,6 +11,7 @@ import type { CheckoutRefreshRequest, CheckoutRenameBranchRequest, CheckoutStatusRequest, + CheckoutWorktreesListRequest, SessionInboundMessage, SessionOutboundMessage, SubscribeCheckoutDiffRequest, @@ -54,6 +55,7 @@ import { } from "../../../utils/checkout-git.js"; import { runGitCommand } from "../../../utils/run-git-command.js"; import { expandTilde } from "../../../utils/path.js"; +import { listGitWorktrees } from "../../../utils/worktree.js"; import type { GitMetadataGenerator } from "./git-metadata-generator.js"; /** @@ -290,6 +292,23 @@ export class CheckoutSession { } } + async handleWorktreesListRequest(msg: CheckoutWorktreesListRequest): Promise { + const { cwd, requestId } = msg; + + try { + const worktrees = await listGitWorktrees({ cwd: expandTilde(cwd) }); + this.host.emit({ + type: "checkout.worktrees.list.response", + payload: { cwd, worktrees, error: null, requestId }, + }); + } catch (error) { + this.host.emit({ + type: "checkout.worktrees.list.response", + payload: { cwd, worktrees: [], error: toCheckoutError(error), requestId }, + }); + } + } + async handleCommitFileDiffRequest( msg: CheckoutCommitFileDiffRequest, signal: AbortSignal, diff --git a/packages/server/src/server/websocket-server.ts b/packages/server/src/server/websocket-server.ts index 2e6e299837..7596c15631 100644 --- a/packages/server/src/server/websocket-server.ts +++ b/packages/server/src/server/websocket-server.ts @@ -2057,6 +2057,10 @@ export class VoiceAssistantWebSocketServer { // COMPAT(backgroundAgents): added in v0.15.0; remove gate after 2027-05-03. backgroundAgents: true, workspaceBaseBranch: true, + // COMPAT(checkoutWorktreeList): added after v0.16.2, remove gate after 2027-11-19. + checkoutWorktreeList: true, + // COMPAT(worktreeRefActions): added after v0.16.2, remove gate after 2027-11-19. + worktreeRefActions: true, // COMPAT(directorySync): added in v0.3.x, remove gate after 2027-02-12. directorySync: true, // COMPAT(workspaceLabels): added in v0.5.0, remove after 2027-08-14. diff --git a/packages/server/src/server/workspace-create-worktree-source.e2e.test.ts b/packages/server/src/server/workspace-create-worktree-source.e2e.test.ts index cd9ec71d83..22f3ac4e08 100644 --- a/packages/server/src/server/workspace-create-worktree-source.e2e.test.ts +++ b/packages/server/src/server/workspace-create-worktree-source.e2e.test.ts @@ -73,6 +73,43 @@ test("workspace.create worktree source forwards action=checkout + refName into t } }, 180000); +test("checkout.worktrees.list returns git worktrees Paseo did not create", async () => { + const daemon = await createTestPaseoDaemon(); + const { repoDir, tempRoot } = createGitRepoWithBranch(); + const manualPath = path.join(tempRoot, "manual"); + execFileSync("git", ["worktree", "add", "-b", "feature/manual", manualPath], { + cwd: repoDir, + stdio: "pipe", + }); + const client = new DaemonClient({ + url: `ws://127.0.0.1:${daemon.port}/ws`, + appVersion: "0.1.82", + }); + + try { + await client.connect(); + const created = await client.createWorkspace({ + source: { kind: "worktree", cwd: repoDir, action: "branch-off", branchName: "feature/paseo" }, + }); + expect(created.error).toBeNull(); + + const worktrees = await client.listCheckoutWorktrees(repoDir); + + expect(worktrees.map(({ branchName, containsCwd }) => ({ branchName, containsCwd }))).toEqual( + expect.arrayContaining([ + { branchName: "main", containsCwd: true }, + { branchName: "feature/manual", containsCwd: false }, + { branchName: "feature/paseo", containsCwd: false }, + ]), + ); + expect(worktrees).toHaveLength(3); + } finally { + await client.close().catch(() => undefined); + await daemon.close(); + await rm(tempRoot, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }); + } +}, 180000); + test.each([false, true])( "workspace.create opens worktree.terminals (setup service: %s)", async (withSetupService) => { diff --git a/packages/server/src/server/worktree-core.posix.test.ts b/packages/server/src/server/worktree-core.posix.test.ts index 7a7a342732..8778a4d7ed 100644 --- a/packages/server/src/server/worktree-core.posix.test.ts +++ b/packages/server/src/server/worktree-core.posix.test.ts @@ -379,6 +379,10 @@ function getBranchUpstream(cwd: string): string | null { return result.status === 0 ? result.stdout.trim() : null; } +function git(cwd: string, ...args: string[]): string { + return execFileSync("git", args, { cwd, stdio: "pipe" }).toString().trim(); +} + function getGitConfigValue(cwd: string, key: string): string | null { const result = spawnSync("git", ["config", "--get", key], { cwd, @@ -1450,6 +1454,99 @@ describe.skipIf(isPlatform("win32"))("worktree-core POSIX-only", () => { ).rejects.toBeInstanceOf(UnknownBranchError); }); + test("branches off a same-repo pull request's head without checking it out", async () => { + const { tempDir, repoDir, remoteDir, paseoHome } = createSameRepoGitHubPrRemoteRepo(); + cleanupPaths.push(tempDir); + // The head branch has never been fetched, so creation has to fetch it. + execFileSync("git", ["update-ref", "-d", "refs/remotes/origin/daemon-shutdown-diagnostics"], { + cwd: repoDir, + stdio: "pipe", + }); + const github = { + ...createGitHubServiceStub(), + getPullRequestCheckoutTarget: async () => ({ + number: 1790, + baseRefName: "main", + headRefName: "daemon-shutdown-diagnostics", + headOwnerLogin: "getpaseo", + headRepositorySshUrl: remoteDir, + headRepositoryUrl: remoteDir, + isCrossRepository: false, + }), + }; + + const result = await createCoreWorktree( + { + cwd: repoDir, + action: "branch-off", + checkoutSource: { kind: "change_request", forge: "github", number: 1790 }, + branchName: "follow-up", + paseoHome, + }, + createCoreDeps({ github }), + ); + + const prHead = execFileSync("git", [ + `--git-dir=${remoteDir}`, + "rev-parse", + "refs/pull/1790/head", + ]) + .toString() + .trim(); + expect(result.intent).toEqual({ + kind: "branch-off", + baseBranch: "refs/remotes/origin/daemon-shutdown-diagnostics", + branchName: "follow-up", + }); + expect(result.worktree.branchName).toBe("follow-up"); + expect(git(result.worktree.worktreePath, "rev-parse", "HEAD")).toBe(prHead); + expect(getBranchUpstream(result.worktree.worktreePath)).toBeNull(); + expect(result.worktree.comparisonBaseRef).toBe( + "refs/remotes/origin/daemon-shutdown-diagnostics", + ); + expect(git(repoDir, "branch", "--list", "daemon-shutdown-diagnostics")).toBe(""); + }); + + test("branches off a fork pull request's head without checking it out", async () => { + const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo(); + cleanupPaths.push(tempDir); + const github = { + ...createGitHubServiceStub(), + getPullRequestCheckoutTarget: async () => ({ + number: 526, + baseRefName: "main", + headRefName: "main", + headOwnerLogin: "therainisme", + headRepositorySshUrl: headRemoteDir, + headRepositoryUrl: headRemoteDir, + isCrossRepository: true, + }), + }; + + const result = await createCoreWorktree( + { + cwd: repoDir, + action: "branch-off", + checkoutSource: { kind: "change_request", forge: "github", number: 526 }, + branchName: "follow-up", + paseoHome, + }, + createCoreDeps({ github }), + ); + + const readme = readFileSync(path.join(result.worktree.worktreePath, "README.md"), "utf8"); + expect(result.intent).toEqual({ + kind: "branch-off", + baseBranch: "refs/remotes/paseo-pr-526/main", + branchName: "follow-up", + }); + expect(result.worktree.branchName).toBe("follow-up"); + expect(readme.replace(/\r\n/g, "\n")).toBe("fork pr main branch\n"); + expect(getBranchUpstream(result.worktree.worktreePath)).toBeNull(); + expect(git(repoDir, "branch", "--list", "therainisme/main")).toBe(""); + expect(getGitConfigValue(repoDir, "remote.paseo-pr-526.url")).toBeNull(); + }); + test("creates the agent-create worktree input shape", async () => { const { tempDir, repoDir, paseoHome } = createGitRepo(); cleanupPaths.push(tempDir); diff --git a/packages/server/src/server/worktree-core.ts b/packages/server/src/server/worktree-core.ts index cc6c9fdbd6..4cde76cc94 100644 --- a/packages/server/src/server/worktree-core.ts +++ b/packages/server/src/server/worktree-core.ts @@ -5,6 +5,7 @@ import { createNameId } from "mnemonic-id"; import type { ForgeService } from "../services/forge-service.js"; import { createWorktree, + fetchFirstAvailableRef, resolveDefaultWorktreePath, slugify, validateBranchSlug, @@ -76,7 +77,11 @@ async function createWorktreeCoreWithPriority( githubPrNumber: input.githubPrNumber, worktreeSlug: requestedWorktreeSlug, }; - } else if (input.checkoutSource !== undefined || input.githubPrNumber !== undefined) { + } else if ( + input.action !== "branch-off" && + (input.checkoutSource !== undefined || input.githubPrNumber !== undefined) + ) { + // A change request with no action is checked out, as clients did before `action` existed. intentInput = { checkoutSource: input.checkoutSource, githubPrNumber: input.githubPrNumber, @@ -88,6 +93,8 @@ async function createWorktreeCoreWithPriority( intentInput = { action: "branch-off", refName: input.refName, + checkoutSource: input.checkoutSource, + githubPrNumber: input.githubPrNumber, branchName: requestedBranchName, worktreeSlug, }; @@ -98,6 +105,8 @@ async function createWorktreeCoreWithPriority( forge: forge.forge, forgeService: forge.service, resolveDefaultBranch: (root) => resolveDefaultBranch(root, deps), + fetchRef: ({ repoRoot: cwd, sources, destination }) => + fetchFirstAvailableRef({ cwd, sources, destination }), }); let normalizedSlug: string; diff --git a/packages/server/src/utils/worktree.posix.test.ts b/packages/server/src/utils/worktree.posix.test.ts index 5ee2ec5b1a..561b562ee2 100644 --- a/packages/server/src/utils/worktree.posix.test.ts +++ b/packages/server/src/utils/worktree.posix.test.ts @@ -13,6 +13,7 @@ import { getWorktreeTeardownCommands, isServiceScript, isPaseoOwnedWorktreeCwd, + listGitWorktrees, listPaseoWorktrees, readPaseoConfig, resolveWorktreeRuntimeEnv, @@ -1695,6 +1696,45 @@ describe.skipIf(isPlatform("win32"))("worktree POSIX-only", () => { expect(remaining.map((worktree) => worktree.path)).toEqual([second.worktreePath]); }); + it("lists every git worktree of the repository, not only Paseo's", async () => { + const paseoWorktree = await createLegacyWorktreeForTest({ + branchName: "feature/paseo", + cwd: repoDir, + baseBranch: "main", + worktreeSlug: "alpha", + paseoHome, + }); + const manualPath = join(tempDir, "manual"); + execFileSync("git", ["worktree", "add", "-b", "feature/manual", manualPath], { + cwd: repoDir, + }); + const detachedPath = join(tempDir, "detached"); + execFileSync("git", ["worktree", "add", "--detach", detachedPath], { cwd: repoDir }); + const removedPath = join(tempDir, "removed"); + execFileSync("git", ["worktree", "add", "-b", "feature/removed", removedPath], { + cwd: repoDir, + }); + rmSync(removedPath, { recursive: true, force: true }); + + const fromProject = await listGitWorktrees({ cwd: repoDir }); + const fromPaseoWorktree = await listGitWorktrees({ cwd: paseoWorktree.worktreePath }); + + const [mainWorktree, ...linkedWorktrees] = fromProject.map( + ({ path, branchName, containsCwd }) => ({ path, branchName, containsCwd }), + ); + expect(mainWorktree).toEqual({ path: repoDir, branchName: "main", containsCwd: true }); + expect(linkedWorktrees.sort((a, b) => a.path.localeCompare(b.path))).toEqual( + [ + { path: paseoWorktree.worktreePath, branchName: "feature/paseo", containsCwd: false }, + { path: manualPath, branchName: "feature/manual", containsCwd: false }, + { path: detachedPath, branchName: null, containsCwd: false }, + ].sort((a, b) => a.path.localeCompare(b.path)), + ); + expect( + fromPaseoWorktree.filter((worktree) => worktree.containsCwd).map(({ path }) => path), + ).toEqual([paseoWorktree.worktreePath]); + }); + it("deletes a paseo worktree even when given a subdirectory path", async () => { const created = await createLegacyWorktreeForTest({ branchName: "main", diff --git a/packages/server/src/utils/worktree.ts b/packages/server/src/utils/worktree.ts index 98c48e460c..0ad1e4c867 100644 --- a/packages/server/src/utils/worktree.ts +++ b/packages/server/src/utils/worktree.ts @@ -1071,9 +1071,18 @@ async function resolveMetadataOwnedWorktree( type ParsedPaseoWorktreeInfo = Omit; +interface ParsedWorktreeEntry extends ParsedPaseoWorktreeInfo { + /** A bare repository or a worktree whose directory is gone; nothing can work there. */ + unusable?: true; +} + function parseWorktreeList(output: string): ParsedPaseoWorktreeInfo[] { - const entries: ParsedPaseoWorktreeInfo[] = []; - let current: ParsedPaseoWorktreeInfo | null = null; + return parseWorktreeEntries(output).map(({ unusable: _unusable, ...entry }) => entry); +} + +function parseWorktreeEntries(output: string): ParsedWorktreeEntry[] { + const entries: ParsedWorktreeEntry[] = []; + let current: ParsedWorktreeEntry | null = null; for (const line of output.split("\n")) { if (line.startsWith("worktree ")) { @@ -1093,6 +1102,8 @@ function parseWorktreeList(output: string): ParsedPaseoWorktreeInfo[] { current.branchName = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref; } else if (line.startsWith("HEAD ")) { current.head = line.slice("HEAD ".length).trim(); + } else if (line === "bare" || line.startsWith("prunable")) { + current.unusable = true; } else if (line.trim().length === 0) { if (current.path) { entries.push(current); @@ -1120,6 +1131,47 @@ async function resolveWorktreeCreatedAtIso(worktreePath: string): Promise { + const { stdout } = await runGitCommand(["worktree", "list", "--porcelain"], { + cwd, + envOverlay: READ_ONLY_GIT_ENV, + }); + const { stdout: toplevel } = await runGitCommand(["rev-parse", "--show-toplevel"], { + cwd, + envOverlay: READ_ONLY_GIT_ENV, + }); + const cwdWorktree = await normalizePathForOwnership(toplevel.trim()); + const worktrees: GitWorktree[] = []; + for (const entry of parseWorktreeEntries(stdout)) { + if (entry.unusable) continue; + const path = await normalizePathForOwnership(entry.path); + worktrees.push({ + path, + branchName: entry.branchName ?? null, + head: entry.head ?? null, + createdAt: await resolveWorktreeCreatedAtIso(path), + containsCwd: path === cwdWorktree, + }); + } + return worktrees; +} + export async function listPaseoWorktrees({ cwd, paseoHome, @@ -1675,10 +1727,10 @@ async function resolveWorktreeSourcePlan({ const normalizedBaseRefName = normalizeRequiredBaseBranch(source.baseRefName); const changeRequestNumber = source.kind === "checkout-github-pr" ? source.githubPrNumber : source.changeRequestNumber; - await fetchWorktreeCheckoutRefs({ + await fetchFirstAvailableRef({ cwd, - localBranchName, - checkoutRefs: source.checkoutRefs ?? [ + destination: `refs/heads/${localBranchName}`, + sources: source.checkoutRefs ?? [ { remoteName: "origin", remoteRef: `refs/pull/${changeRequestNumber}/head` }, ], }); @@ -1777,21 +1829,22 @@ async function configureWorktreePushRemote(options: { } } -async function fetchWorktreeCheckoutRefs(options: { +/** Fetches the first of `sources` a remote serves into the local ref `destination`. */ +export async function fetchFirstAvailableRef(options: { cwd: string; - localBranchName: string; - checkoutRefs: WorktreeCheckoutRef[]; + sources: WorktreeCheckoutRef[]; + destination: string; }): Promise { let lastResult: | Awaited> | { stderr: string; stdout: string; exitCode: number | null } | null = null; - for (const checkoutRef of options.checkoutRefs) { + for (const checkoutRef of options.sources) { lastResult = await runGitCommand( [ "fetch", checkoutRef.remoteName ?? "origin", - `+${checkoutRef.remoteRef}:refs/heads/${options.localBranchName}`, + `+${checkoutRef.remoteRef}:${options.destination}`, "--force", ], { @@ -1804,11 +1857,11 @@ async function fetchWorktreeCheckoutRefs(options: { return; } } - const attemptedRefs = options.checkoutRefs + const attemptedRefs = options.sources .map((checkoutRef) => `${checkoutRef.remoteName ?? "origin"} ${checkoutRef.remoteRef}`) .join(", "); throw new Error( - `Unable to fetch change request refs for worktree branch ${options.localBranchName}: ${attemptedRefs}${lastResult?.stderr ? `\n${lastResult.stderr}` : ""}`, + `Unable to fetch change request refs into ${options.destination}: ${attemptedRefs}${lastResult?.stderr ? `\n${lastResult.stderr}` : ""}`, ); }