clean up orphaned worktrees on launch

Author: jonathanlab

apps/array/src/main/preload.ts

@@ -436,6 +436,12 @@ contextBridge.exposeInMainWorld("electronAPI", {
       ipcRenderer.invoke("remove-task-association", taskId),
     clearTaskWorktree: (taskId: string): Promise<void> =>
       ipcRenderer.invoke("clear-task-worktree", taskId),
+    cleanupOrphanedWorktrees: (
+      mainRepoPath: string,
+    ): Promise<{
+      deleted: string[];
+      errors: Array<{ path: string; error: string }>;
+    }> => ipcRenderer.invoke("cleanup-orphaned-worktrees", mainRepoPath),
   },
   // Worktree API
   worktree: {

apps/array/src/main/services/folders.ts

@@ -141,6 +141,27 @@ async function clearTaskWorktree(taskId: string): Promise<void> {
   }
 }
 
+async function cleanupOrphanedWorktreesForFolder(
+  mainRepoPath: string,
+): Promise<{
+  deleted: string[];
+  errors: Array<{ path: string; error: string }>;
+}> {
+  const WorktreeManager = (await import("@posthog/agent")).WorktreeManager;
+  const manager = new WorktreeManager({ mainRepoPath });
+
+  const associations = foldersStore.get("taskAssociations", []);
+  const associatedWorktreePaths: string[] = [];
+
+  for (const assoc of associations) {
+    if (assoc.worktree?.worktreePath) {
+      associatedWorktreePaths.push(assoc.worktree.worktreePath);
+    }
+  }
+
+  return await manager.cleanupOrphanedWorktrees(associatedWorktreePaths);
+}
+
 export function registerFoldersIpc(): void {
   ipcMain.handle(
     "get-folders",
@@ -292,4 +313,28 @@ export function registerFoldersIpc(): void {
       }
     },
   );
+
+  ipcMain.handle(
+    "cleanup-orphaned-worktrees",
+    async (
+      _event: IpcMainInvokeEvent,
+      mainRepoPath: string,
+    ): Promise<{
+      deleted: string[];
+      errors: Array<{ path: string; error: string }>;
+    }> => {
+      try {
+        return await cleanupOrphanedWorktreesForFolder(mainRepoPath);
+      } catch (error) {
+        console.error(
+          `Failed to cleanup orphaned worktrees for ${mainRepoPath}:`,
+          error,
+        );
+        return {
+          deleted: [],
+          errors: [{ path: mainRepoPath, error: String(error) }],
+        };
+      }
+    },
+  );
 }

apps/array/src/renderer/stores/registeredFoldersStore.ts

@@ -9,6 +9,12 @@ interface RegisteredFoldersState {
   removeFolder: (folderId: string) => Promise<void>;
   updateLastAccessed: (folderId: string) => Promise<void>;
   getFolderByPath: (path: string) => RegisteredFolder | undefined;
+  cleanupOrphanedWorktrees: (
+    mainRepoPath: string,
+  ) => Promise<{
+    deleted: string[];
+    errors: Array<{ path: string; error: string }>;
+  }>;
 }
 
 let updateDebounceTimer: ReturnType<typeof setTimeout> | null = null;
@@ -34,6 +40,17 @@ export const useRegisteredFoldersStore = create<RegisteredFoldersState>()(
       try {
         const folders = await loadFolders();
         set({ folders, isLoaded: true });
+
+        for (const folder of folders) {
+          get()
+            .cleanupOrphanedWorktrees(folder.path)
+            .catch((error) => {
+              console.error(
+                `Failed to cleanup orphaned worktrees for ${folder.path}:`,
+                error,
+              );
+            });
+        }
       } catch (error) {
         console.error("Failed to load folders:", error);
         set({ folders: [], isLoaded: true });
@@ -106,6 +123,20 @@ export const useRegisteredFoldersStore = create<RegisteredFoldersState>()(
       getFolderByPath: (path: string) => {
         return get().folders.find((f) => f.path === path);
       },
+
+      cleanupOrphanedWorktrees: async (mainRepoPath: string) => {
+        try {
+          return await window.electronAPI.folders.cleanupOrphanedWorktrees(
+            mainRepoPath,
+          );
+        } catch (error) {
+          console.error("Failed to cleanup orphaned worktrees:", error);
+          return {
+            deleted: [],
+            errors: [{ path: mainRepoPath, error: String(error) }],
+          };
+        }
+      },
     };
   },
 );

apps/array/src/renderer/types/electron.d.ts

@@ -221,6 +221,12 @@ declare global {
       ) => Promise<TaskFolderAssociation | null>;
       removeTaskAssociation: (taskId: string) => Promise<void>;
       clearTaskWorktree: (taskId: string) => Promise<void>;
+      cleanupOrphanedWorktrees: (
+        mainRepoPath: string,
+      ) => Promise<{
+        deleted: string[];
+        errors: Array<{ path: string; error: string }>;
+      }>;
     };
     worktree: {
       create: (mainRepoPath: string) => Promise<{

packages/agent/src/worktree-manager.ts

@@ -791,4 +791,57 @@ export class WorktreeManager {
       return null;
     }
   }
+
+  async cleanupOrphanedWorktrees(
+    associatedWorktreePaths: string[],
+  ): Promise<{
+    deleted: string[];
+    errors: Array<{ path: string; error: string }>;
+  }> {
+    this.logger.info("Starting cleanup of orphaned worktrees");
+
+    const allWorktrees = await this.listWorktrees();
+    const deleted: string[] = [];
+    const errors: Array<{ path: string; error: string }> = [];
+
+    const associatedPathsSet = new Set(
+      associatedWorktreePaths.map((p) => path.resolve(p)),
+    );
+
+    for (const worktree of allWorktrees) {
+      const resolvedPath = path.resolve(worktree.worktreePath);
+
+      if (!associatedPathsSet.has(resolvedPath)) {
+        this.logger.info("Found orphaned worktree", {
+          path: worktree.worktreePath,
+        });
+
+        try {
+          await this.deleteWorktree(worktree.worktreePath);
+          deleted.push(worktree.worktreePath);
+          this.logger.info("Deleted orphaned worktree", {
+            path: worktree.worktreePath,
+          });
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          errors.push({
+            path: worktree.worktreePath,
+            error: errorMessage,
+          });
+          this.logger.error("Failed to delete orphaned worktree", {
+            path: worktree.worktreePath,
+            error: errorMessage,
+          });
+        }
+      }
+    }
+
+    this.logger.info("Cleanup completed", {
+      deleted: deleted.length,
+      errors: errors.length,
+    });
+
+    return { deleted, errors };
+  }
 }