feat (desktop): allow deleting on workspaces page

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

@@ -294,5 +294,159 @@ export const createDeleteProcedures = () => {
 
 				return { success: true, terminalWarning };
 			}),
+
+		// Check if a closed worktree (no active workspace) can be deleted
+		canDeleteWorktree: publicProcedure
+			.input(
+				z.object({
+					worktreeId: z.string(),
+					skipGitChecks: z.boolean().optional(),
+				}),
+			)
+			.query(async ({ input }) => {
+				const worktree = getWorktree(input.worktreeId);
+
+				if (!worktree) {
+					return {
+						canDelete: false,
+						reason: "Worktree not found",
+						worktree: null,
+						hasChanges: false,
+						hasUnpushedCommits: false,
+					};
+				}
+
+				const project = getProject(worktree.projectId);
+
+				if (!project) {
+					return {
+						canDelete: false,
+						reason: "Project not found",
+						worktree,
+						hasChanges: false,
+						hasUnpushedCommits: false,
+					};
+				}
+
+				if (input.skipGitChecks) {
+					return {
+						canDelete: true,
+						reason: null,
+						worktree,
+						warning: null,
+						hasChanges: false,
+						hasUnpushedCommits: false,
+					};
+				}
+
+				try {
+					const exists = await worktreeExists(
+						project.mainRepoPath,
+						worktree.path,
+					);
+
+					if (!exists) {
+						return {
+							canDelete: true,
+							reason: null,
+							worktree,
+							warning:
+								"Worktree not found in git (may have been manually removed)",
+							hasChanges: false,
+							hasUnpushedCommits: false,
+						};
+					}
+
+					const [hasChanges, unpushedCommits] = await Promise.all([
+						hasUncommittedChanges(worktree.path),
+						hasUnpushedCommits(worktree.path),
+					]);
+
+					return {
+						canDelete: true,
+						reason: null,
+						worktree,
+						warning: null,
+						hasChanges,
+						hasUnpushedCommits: unpushedCommits,
+					};
+				} catch (error) {
+					return {
+						canDelete: false,
+						reason: `Failed to check worktree status: ${error instanceof Error ? error.message : String(error)}`,
+						worktree,
+						hasChanges: false,
+						hasUnpushedCommits: false,
+					};
+				}
+			}),
+
+		// Delete a closed worktree (no active workspace) by worktree ID
+		deleteWorktree: publicProcedure
+			.input(z.object({ worktreeId: z.string() }))
+			.mutation(async ({ input }) => {
+				const worktree = getWorktree(input.worktreeId);
+
+				if (!worktree) {
+					return { success: false, error: "Worktree not found" };
+				}
+
+				const project = getProject(worktree.projectId);
+
+				if (!project) {
+					return { success: false, error: "Project not found" };
+				}
+
+				// Acquire project lock to prevent racing with concurrent operations
+				await workspaceInitManager.acquireProjectLock(project.id);
+
+				try {
+					const exists = await worktreeExists(
+						project.mainRepoPath,
+						worktree.path,
+					);
+
+					if (exists) {
+						const teardownResult = await runTeardown(
+							project.mainRepoPath,
+							worktree.path,
+							worktree.branch,
+						);
+						if (!teardownResult.success) {
+							console.error(
+								`Teardown failed for worktree ${worktree.branch}:`,
+								teardownResult.error,
+							);
+						}
+					}
+
+					try {
+						if (exists) {
+							await removeWorktree(project.mainRepoPath, worktree.path);
+						} else {
+							console.warn(
+								`Worktree ${worktree.path} not found in git, skipping removal`,
+							);
+						}
+					} catch (error) {
+						const errorMessage =
+							error instanceof Error ? error.message : String(error);
+						console.error("Failed to remove worktree:", errorMessage);
+						return {
+							success: false,
+							error: `Failed to remove worktree: ${errorMessage}`,
+						};
+					}
+				} finally {
+					workspaceInitManager.releaseProjectLock(project.id);
+				}
+
+				deleteWorktreeRecord(input.worktreeId);
+				hideProjectIfNoWorkspaces(worktree.projectId);
+
+				track("worktree_deleted", { worktree_id: input.worktreeId });
+
+				return { success: true };
+			}),
 	});
 };

apps/desktop/src/renderer/react-query/workspaces/index.ts

@@ -2,6 +2,7 @@ export { useCloseWorkspace } from "./useCloseWorkspace";
 export { useCreateBranchWorkspace } from "./useCreateBranchWorkspace";
 export { useCreateWorkspace } from "./useCreateWorkspace";
 export { useDeleteWorkspace } from "./useDeleteWorkspace";
+export { useDeleteWorktree } from "./useDeleteWorktree";
 export { useOpenWorktree } from "./useOpenWorktree";
 export { useReorderWorkspaces } from "./useReorderWorkspaces";
 export { useSetActiveWorkspace } from "./useSetActiveWorkspace";

apps/desktop/src/renderer/react-query/workspaces/useDeleteWorktree.ts

@@ -0,0 +1,26 @@
+import { trpc } from "renderer/lib/trpc";
+
+/**
+ * Mutation hook for deleting a closed worktree (one without an active workspace).
+ * Handles cache invalidation for worktree-related queries.
+ */
+export function useDeleteWorktree(
+	options?: Parameters<typeof trpc.workspaces.deleteWorktree.useMutation>[0],
+) {
+	const utils = trpc.useUtils();
+
+	return trpc.workspaces.deleteWorktree.useMutation({
+		...options,
+		onSettled: async (...args) => {
+			// Invalidate worktree queries to refresh the list
+			await utils.workspaces.getWorktreesByProject.invalidate();
+			await options?.onSettled?.(...args);
+		},
+		onSuccess: async (...args) => {
+			await options?.onSuccess?.(...args);
+		},
+		onError: async (...args) => {
+			await options?.onError?.(...args);
+		},
+	});
+}

apps/desktop/src/renderer/screens/main/components/WorkspacesListView/WorkspaceRow/DeleteWorktreeDialog.tsx

@@ -0,0 +1,120 @@
+import {
+	AlertDialog,
+	AlertDialogContent,
+	AlertDialogDescription,
+	AlertDialogFooter,
+	AlertDialogHeader,
+	AlertDialogTitle,
+} from "@superset/ui/alert-dialog";
+import { Button } from "@superset/ui/button";
+import { toast } from "@superset/ui/sonner";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip";
+import { trpc } from "renderer/lib/trpc";
+import { useDeleteWorktree } from "renderer/react-query/workspaces/useDeleteWorktree";
+
+interface DeleteWorktreeDialogProps {
+	worktreeId: string;
+	worktreeName: string;
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+}
+
+export function DeleteWorktreeDialog({
+	worktreeId,
+	worktreeName,
+	open,
+	onOpenChange,
+}: DeleteWorktreeDialogProps) {
+	const deleteWorktree = useDeleteWorktree();
+
+	const { data: canDeleteData, isLoading } =
+		trpc.workspaces.canDeleteWorktree.useQuery(
+			{ worktreeId },
+			{
+				enabled: open,
+				staleTime: Number.POSITIVE_INFINITY,
+			},
+		);
+
+	const handleDelete = () => {
+		onOpenChange(false);
+
+		toast.promise(deleteWorktree.mutateAsync({ worktreeId }), {
+			loading: `Deleting "${worktreeName}"...`,
+			success: `Deleted "${worktreeName}"`,
+			error: (error) =>
+				error instanceof Error ? error.message : "Failed to delete",
+		});
+	};
+
+	const canDelete = canDeleteData?.canDelete ?? true;
+	const reason = canDeleteData?.reason;
+	const hasChanges = canDeleteData?.hasChanges ?? false;
+	const hasUnpushedCommits = canDeleteData?.hasUnpushedCommits ?? false;
+	const hasWarnings = hasChanges || hasUnpushedCommits;
+
+	return (
+		<AlertDialog open={open} onOpenChange={onOpenChange}>
+			<AlertDialogContent className="max-w-[340px] gap-0 p-0">
+				<AlertDialogHeader className="px-4 pt-4 pb-2">
+					<AlertDialogTitle className="font-medium">
+						Delete worktree "{worktreeName}"?
+					</AlertDialogTitle>
+					<AlertDialogDescription asChild>
+						<div className="text-muted-foreground space-y-1.5">
+							{isLoading ? (
+								"Checking status..."
+							) : !canDelete ? (
+								<span className="text-destructive">{reason}</span>
+							) : (
+								<span className="block">
+									This will permanently delete the worktree and its files from
+									disk.
+								</span>
+							)}
+						</div>
+					</AlertDialogDescription>
+				</AlertDialogHeader>
+
+				{!isLoading && canDelete && hasWarnings && (
+					<div className="px-4 pb-2">
+						<div className="text-sm text-amber-700 dark:text-amber-300 bg-amber-100 dark:bg-amber-950/50 border border-amber-200 dark:border-amber-800 rounded px-2 py-1.5">
+							{hasChanges && hasUnpushedCommits
+								? "Has uncommitted changes and unpushed commits"
+								: hasChanges
+									? "Has uncommitted changes"
+									: "Has unpushed commits"}
+						</div>
+					</div>
+				)}
+
+				<AlertDialogFooter className="px-4 pb-4 pt-2 flex-row justify-end gap-2">
+					<Button
+						variant="ghost"
+						size="sm"
+						className="h-7 px-3 text-xs"
+						onClick={() => onOpenChange(false)}
+					>
+						Cancel
+					</Button>
+					<Tooltip delayDuration={400}>
+						<TooltipTrigger asChild>
+							<Button
+								variant="destructive"
+								size="sm"
+								className="h-7 px-3 text-xs"
+								onClick={handleDelete}
+								disabled={!canDelete || isLoading}
+							>
+								Delete
+							</Button>
+						</TooltipTrigger>
+						<TooltipContent side="top" className="text-xs max-w-[200px]">
+							Permanently delete worktree from disk.
+						</TooltipContent>
+					</Tooltip>
+				</AlertDialogFooter>
+			</AlertDialogContent>
+		</AlertDialog>
+	);
+}