feat(desktop): show existing disk worktrees in Open Workspace modal

apps/desktop/src/lib/trpc/routers/workspaces/procedures/create.ts

@@ -34,7 +34,7 @@ import {
 	sanitizeBranchName,
 	worktreeExists,
 } from "../utils/git";
-import { loadSetupConfig } from "../utils/setup";
+import { copySupersetConfigToWorktree, loadSetupConfig } from "../utils/setup";
 import { initializeWorkspaceWorktree } from "../utils/workspace-init";
 
 interface CreateWorkspaceFromWorktreeParams {
@@ -615,6 +615,170 @@ export const createCreateProcedures = () => {
 				};
 			}),
 
+		openExternalWorktree: publicProcedure
+			.input(
+				z.object({
+					projectId: z.string(),
+					worktreePath: z.string(),
+					branch: z.string(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				const project = getProject(input.projectId);
+				if (!project) {
+					throw new Error(`Project ${input.projectId} not found`);
+				}
+
+				const exists = await worktreeExists(
+					project.mainRepoPath,
+					input.worktreePath,
+				);
+				if (!exists) {
+					throw new Error("Worktree no longer exists on disk");
+				}
+
+				const existingWorktree = localDb
+					.select()
+					.from(worktrees)
+					.where(
+						and(
+							eq(worktrees.projectId, input.projectId),
+							eq(worktrees.path, input.worktreePath),
+						),
+					)
+					.get();
+
+				if (existingWorktree) {
+					// Failed init can leave gitStatus null, which shows "Setup incomplete" UI
+					if (!existingWorktree.gitStatus) {
+						localDb
+							.update(worktrees)
+							.set({
+								gitStatus: {
+									branch: existingWorktree.branch,
+									needsRebase: false,
+									lastRefreshed: Date.now(),
+								},
+							})
+							.where(eq(worktrees.id, existingWorktree.id))
+							.run();
+					}
+
+					const existingWorkspace = localDb
+						.select()
+						.from(workspaces)
+						.where(
+							and(
+								eq(workspaces.worktreeId, existingWorktree.id),
+								isNull(workspaces.deletingAt),
+							),
+						)
+						.get();
+
+					if (existingWorkspace) {
+						touchWorkspace(existingWorkspace.id);
+						setLastActiveWorkspace(existingWorkspace.id);
+						return {
+							workspace: existingWorkspace,
+							initialCommands: null,
+							worktreePath: existingWorktree.path,
+							projectId: project.id,
+							wasExisting: true,
+						};
+					}
+
+					const maxTabOrder = getMaxWorkspaceTabOrder(input.projectId);
+					const workspace = localDb
+						.insert(workspaces)
+						.values({
+							projectId: input.projectId,
+							worktreeId: existingWorktree.id,
+							type: "worktree",
+							branch: existingWorktree.branch,
+							name: existingWorktree.branch,
+							tabOrder: maxTabOrder + 1,
+						})
+						.returning()
+						.get();
+
+					setLastActiveWorkspace(workspace.id);
+					activateProject(project);
+
+					copySupersetConfigToWorktree(
+						project.mainRepoPath,
+						existingWorktree.path,
+					);
+					const setupConfig = loadSetupConfig(project.mainRepoPath);
+
+					track("workspace_opened", {
+						workspace_id: workspace.id,
+						project_id: project.id,
+						type: "worktree",
+						source: "external_import",
+					});
+
+					return {
+						workspace,
+						initialCommands: setupConfig?.setup || null,
+						worktreePath: existingWorktree.path,
+						projectId: project.id,
+						wasExisting: false,
+					};
+				}
+
+				const defaultBranch = project.defaultBranch || "main";
+				const worktree = localDb
+					.insert(worktrees)
+					.values({
+						projectId: input.projectId,
+						path: input.worktreePath,
+						branch: input.branch,
+						baseBranch: defaultBranch,
+						gitStatus: {
+							branch: input.branch,
+							needsRebase: false,
+							lastRefreshed: Date.now(),
+						},
+					})
+					.returning()
+					.get();
+
+				const maxTabOrder = getMaxWorkspaceTabOrder(input.projectId);
+				const workspace = localDb
+					.insert(workspaces)
+					.values({
+						projectId: input.projectId,
+						worktreeId: worktree.id,
+						type: "worktree",
+						branch: input.branch,
+						name: input.branch,
+						tabOrder: maxTabOrder + 1,
+					})
+					.returning()
+					.get();
+
+				setLastActiveWorkspace(workspace.id);
+				activateProject(project);
+
+				copySupersetConfigToWorktree(project.mainRepoPath, input.worktreePath);
+				const setupConfig = loadSetupConfig(project.mainRepoPath);
+
+				track("workspace_created", {
+					workspace_id: workspace.id,
+					project_id: project.id,
+					branch: input.branch,
+					source: "external_import",
+				});
+
+				return {
+					workspace,
+					initialCommands: setupConfig?.setup || null,
+					worktreePath: input.worktreePath,
+					projectId: project.id,
+					wasExisting: false,
+				};
+			}),
+
 		createFromPr: publicProcedure
 			.input(
 				z.object({

apps/desktop/src/lib/trpc/routers/workspaces/procedures/git-status.ts

@@ -13,6 +13,7 @@ import {
 	checkNeedsRebase,
 	fetchDefaultBranch,
 	getDefaultBranch,
+	listExternalWorktrees,
 	refreshDefaultBranch,
 } from "../utils/git";
 import { fetchGitHubPRStatus } from "../utils/github";
@@ -166,5 +167,38 @@ export const createGitStatusProcedures = () => {
 					};
 				});
 			}),
+
+		getExternalWorktrees: publicProcedure
+			.input(z.object({ projectId: z.string() }))
+			.query(async ({ input }) => {
+				const project = getProject(input.projectId);
+				if (!project) {
+					return [];
+				}
+
+				const allWorktrees = await listExternalWorktrees(project.mainRepoPath);
+
+				const trackedWorktrees = localDb
+					.select({ path: worktrees.path })
+					.from(worktrees)
+					.where(eq(worktrees.projectId, input.projectId))
+					.all();
+				const trackedPaths = new Set(trackedWorktrees.map((wt) => wt.path));
+
+				return allWorktrees
+					.filter((wt) => {
+						if (wt.path === project.mainRepoPath) return false;
+						if (wt.isBare) return false;
+						if (wt.isDetached) return false;
+						if (!wt.branch) return false;
+						if (trackedPaths.has(wt.path)) return false;
+						return true;
+					})
+					.map((wt) => ({
+						path: wt.path,
+						// biome-ignore lint/style/noNonNullAssertion: filtered above
+						branch: wt.branch!,
+					}));
+			}),
 	});
 };

apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts

@@ -720,6 +720,59 @@ export async function worktreeExists(
 	}
 }
 
+export interface ExternalWorktree {
+	path: string;
+	branch: string | null;
+	isDetached: boolean;
+	isBare: boolean;
+}
+
+export async function listExternalWorktrees(
+	mainRepoPath: string,
+): Promise<ExternalWorktree[]> {
+	try {
+		const git = simpleGit(mainRepoPath);
+		const output = await git.raw(["worktree", "list", "--porcelain"]);
+
+		const result: ExternalWorktree[] = [];
+		let current: Partial<ExternalWorktree> = {};
+
+		for (const line of output.split("\n")) {
+			if (line.startsWith("worktree ")) {
+				if (current.path) {
+					result.push({
+						path: current.path,
+						branch: current.branch ?? null,
+						isDetached: current.isDetached ?? false,
+						isBare: current.isBare ?? false,
+					});
+				}
+				current = { path: line.slice("worktree ".length) };
+			} else if (line.startsWith("branch refs/heads/")) {
+				current.branch = line.slice("branch refs/heads/".length);
+			} else if (line === "detached") {
+				current.isDetached = true;
+			} else if (line === "bare") {
+				current.isBare = true;
+			}
+		}
+
+		if (current.path) {
+			result.push({
+				path: current.path,
+				branch: current.branch ?? null,
+				isDetached: current.isDetached ?? false,
+				isBare: current.isBare ?? false,
+			});
+		}
+
+		return result;
+	} catch (error) {
+		console.error(`Failed to list external worktrees: ${error}`);
+		throw error;
+	}
+}
+
 /**
  * Checks if a branch is already checked out in a worktree.
  * @param mainRepoPath - Path to the main repository