feat: add webmux prune command (#118)

centdix · web-flow · commit eda234a810e9 · 2026-03-11T18:24:06.000+01:00
diff --git a/backend/src/__tests__/lifecycle-service.test.ts b/backend/src/__tests__/lifecycle-service.test.ts
@@ -762,6 +762,36 @@ describe("LifecycleService", () => {
     expect(run(["git", "branch", "--list", "feature-ahead"], repoRoot)).toBe("");
   });
 
+  it("prunes all project worktrees", async () => {
+    const repoRoot = await initRepo();
+    const runtime = new ProjectRuntime();
+    const tmux = new FakeTmuxGateway();
+    const docker = new FakeDockerGateway();
+    const hooks = new FakeHookRunner();
+    const lifecycle = makeLifecycleService(repoRoot, tmux, runtime, docker, hooks);
+
+    await lifecycle.createWorktree({ branch: "feature-prune-host" });
+    await lifecycle.createWorktree({ branch: "feature-prune-docker", profile: "sandbox" });
+    await lifecycle.closeWorktree("feature-prune-host");
+
+    const result = await lifecycle.pruneWorktrees();
+
+    expect(result.removedBranches).toEqual([
+      "feature-prune-docker",
+      "feature-prune-host",
+    ]);
+    expect(hooks.calls.filter((call) => call.name === "preRemove").map((call) => call.cwd).sort()).toEqual([
+      join(repoRoot, "__worktrees", "feature-prune-docker"),
+      join(repoRoot, "__worktrees", "feature-prune-host"),
+    ]);
+    expect(docker.removed).toEqual(["feature-prune-docker"]);
+    expect(new BunGitGateway().listWorktrees(repoRoot).filter((entry) => entry.path !== repoRoot)).toEqual([]);
+    expect(run(["git", "branch", "--list", "feature-prune-host"], repoRoot)).toBe("");
+    expect(run(["git", "branch", "--list", "feature-prune-docker"], repoRoot)).toBe("");
+    expect(tmux.listWindows()).toEqual([]);
+    expect(runtime.listWorktrees()).toEqual([]);
+  });
+
   it("removes the sandbox container before deleting a docker worktree", async () => {
     const repoRoot = await initRepo();
     const runtime = new ProjectRuntime();
diff --git a/backend/src/services/lifecycle-service.ts b/backend/src/services/lifecycle-service.ts
@@ -86,6 +86,10 @@ export interface CreateLifecycleWorktreeInput {
   envOverrides?: Record<string, string>;
 }
 
+export interface PruneWorktreesResult {
+  removedBranches: string[];
+}
+
 export class LifecycleError extends Error {
   constructor(
     message: string,
@@ -272,6 +276,23 @@ export class LifecycleService {
     }
   }
 
+  async pruneWorktrees(): Promise<PruneWorktreesResult> {
+    try {
+      const resolvedWorktrees = await this.resolveAllWorktrees();
+      const removedBranches: string[] = [];
+
+      for (const resolved of resolvedWorktrees) {
+        const branch = resolved.entry.branch ?? resolved.entry.path;
+        await this.removeResolvedWorktree(resolved);
+        removedBranches.push(branch);
+      }
+
+      return { removedBranches };
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
+
   async mergeWorktree(branch: string): Promise<void> {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
@@ -402,6 +423,18 @@ export class LifecycleService {
     return { entry, gitDir, meta };
   }
 
+  private async resolveAllWorktrees(): Promise<ResolvedLifecycleWorktree[]> {
+    const entries = this.listProjectWorktrees().sort((left, right) =>
+      (left.branch ?? left.path).localeCompare(right.branch ?? right.path)
+    );
+
+    return await Promise.all(entries.map(async (entry) => {
+      const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
+      const meta = await readWorktreeMeta(gitDir);
+      return { entry, gitDir, meta };
+    }));
+  }
+
   private async initializeUnmanagedWorktree(
     resolved: ResolvedLifecycleWorktree,
   ): Promise<InitializeManagedWorktreeResult> {
diff --git a/bin/src/completions.test.ts b/bin/src/completions.test.ts
@@ -119,6 +119,7 @@ describe("runCompletionCommand", () => {
     const output = spy.mock.calls[0]?.[0];
     expect(output).toContain("#compdef webmux");
     expect(output).toContain("compdef _webmux webmux");
+    expect(output).toContain("prune:Remove all worktrees in the current project");
     expect(output).not.toContain('_webmux "$@"');
     spy.mockRestore();
   });
@@ -128,6 +129,7 @@ describe("runCompletionCommand", () => {
     const code = runCompletionCommand(["bash"]);
     expect(code).toBe(0);
     expect(spy).toHaveBeenCalledWith(expect.stringContaining("complete -F _webmux webmux"));
+    expect(spy).toHaveBeenCalledWith(expect.stringContaining("prune"));
     spy.mockRestore();
   });
 });
diff --git a/bin/src/completions.ts b/bin/src/completions.ts
@@ -127,6 +127,7 @@ _webmux() {
     'close:Close a worktree session'
     'remove:Remove a worktree'
     'merge:Merge a worktree into main'
+    'prune:Remove all worktrees in the current project'
     'completion:Generate shell completion script'
   )
 
@@ -176,7 +177,7 @@ const BASH_SCRIPT = `_webmux() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=($(compgen -W "serve init service update add list open close remove merge completion" -- "\${cur}"))
+    COMPREPLY=($(compgen -W "serve init service update add list open close remove merge prune completion" -- "\${cur}"))
     return
   fi
 
diff --git a/bin/src/webmux.test.ts b/bin/src/webmux.test.ts
@@ -65,6 +65,17 @@ describe("webmux entrypoint", () => {
     });
   });
 
+  it("parses prune as a worktree command", () => {
+    delete process.env.PORT;
+
+    expect(parseRootArgs(["prune"])).toEqual({
+      port: 5111,
+      debug: false,
+      command: "prune",
+      commandArgs: [],
+    });
+  });
+
   it("runs worktree commands from a project subdirectory", async () => {
     const repoRoot = await mkdtemp(join(tmpdir(), "webmux-cli-"));
     tempDirs.push(repoRoot);
diff --git a/bin/src/webmux.ts b/bin/src/webmux.ts
@@ -25,6 +25,7 @@ Usage:
   webmux close        Close a worktree session without removing it
   webmux remove       Remove a worktree
   webmux merge        Merge a worktree into the main branch and remove it
+  webmux prune        Remove all worktrees in the current project
   webmux completion   Generate shell completion script (bash, zsh)
 
 Options:
@@ -38,7 +39,7 @@ Environment:
 `);
 }
 
-type RootCommand = "serve" | "init" | "service" | "update" | "add" | "list" | "open" | "close" | "remove" | "merge" | "completion" | null;
+type RootCommand = "serve" | "init" | "service" | "update" | "add" | "list" | "open" | "close" | "remove" | "merge" | "prune" | "completion" | null;
 
 interface ParsedRootArgs {
   port: number;
@@ -58,6 +59,7 @@ function isRootCommand(value: string): value is NonNullable<RootCommand> {
     || value === "close"
     || value === "remove"
     || value === "merge"
+    || value === "prune"
     || value === "completion";
 }
 
@@ -121,13 +123,14 @@ export function parseRootArgs(args: string[]): ParsedRootArgs {
   };
 }
 
-function isWorktreeCommand(command: RootCommand): command is "add" | "list" | "open" | "close" | "remove" | "merge" {
+function isWorktreeCommand(command: RootCommand): command is "add" | "list" | "open" | "close" | "remove" | "merge" | "prune" {
   return command === "add"
     || command === "list"
     || command === "open"
     || command === "close"
     || command === "remove"
-    || command === "merge";
+    || command === "merge"
+    || command === "prune";
 }
 
 // ── Load env files from CWD (.env.local overrides .env) ─────────────────────
diff --git a/bin/src/worktree-commands.test.ts b/bin/src/worktree-commands.test.ts
@@ -22,6 +22,10 @@ function stubLifecycleService(calls: Array<{ method: string; value: unknown }>)
     async mergeWorktree(branch: string): Promise<void> {
       calls.push({ method: "mergeWorktree", value: branch });
     },
+    async pruneWorktrees(): Promise<{ removedBranches: string[] }> {
+      calls.push({ method: "pruneWorktrees", value: null });
+      return { removedBranches: ["feature/search", "feature/api"] };
+    },
   };
 }
 
@@ -183,6 +187,66 @@ describe("runWorktreeCommand", () => {
     expect(stdout).toEqual(["Merged feature/search into develop"]);
   });
 
+  it("prunes all worktrees after confirmation", async () => {
+    const { runtime, calls } = makeRuntime();
+    runtime.git = stubGit([
+      { path: "/repo", branch: "main", bare: false },
+      { path: "/repo/.worktrees/feature-search", branch: "feature/search", bare: false },
+      { path: "/repo/.worktrees/feature-api", branch: "feature/api", bare: false },
+    ]);
+    const stdout: string[] = [];
+    const confirmCalls: number[] = [];
+
+    const exitCode = await runWorktreeCommand(
+      {
+        command: "prune",
+        args: [],
+        projectDir: "/repo",
+        port: 5111,
+      },
+      {
+        createRuntime: () => runtime,
+        confirmPrune: async (count) => {
+          confirmCalls.push(count);
+          return true;
+        },
+        stdout: (message) => stdout.push(message),
+      },
+    );
+
+    expect(exitCode).toBe(0);
+    expect(confirmCalls).toEqual([2]);
+    expect(calls).toEqual([{ method: "pruneWorktrees", value: null }]);
+    expect(stdout).toEqual(["Pruned 2 worktrees: feature/search, feature/api"]);
+  });
+
+  it("aborts prune when confirmation is declined", async () => {
+    const { runtime, calls } = makeRuntime();
+    runtime.git = stubGit([
+      { path: "/repo", branch: "main", bare: false },
+      { path: "/repo/.worktrees/feature-search", branch: "feature/search", bare: false },
+    ]);
+    const stdout: string[] = [];
+
+    const exitCode = await runWorktreeCommand(
+      {
+        command: "prune",
+        args: [],
+        projectDir: "/repo",
+        port: 5111,
+      },
+      {
+        createRuntime: () => runtime,
+        confirmPrune: async () => false,
+        stdout: (message) => stdout.push(message),
+      },
+    );
+
+    expect(exitCode).toBe(0);
+    expect(calls).toEqual([]);
+    expect(stdout).toEqual(["Aborted."]);
+  });
+
   it("returns a failing exit code when lifecycle execution fails", async () => {
     const stdout: string[] = [];
     const stderr: string[] = [];
@@ -220,6 +284,9 @@ describe("runWorktreeCommand", () => {
             async mergeWorktree(): Promise<void> {
               throw new Error("not used");
             },
+            async pruneWorktrees(): Promise<{ removedBranches: string[] }> {
+              throw new Error("not used");
+            },
           },
         }),
         stdout: (message) => stdout.push(message),
@@ -329,4 +396,24 @@ describe("runWorktreeCommand", () => {
     expect(createRuntimeCalled).toBe(false);
     expect(stdout).toEqual(["Usage:\n  webmux list"]);
   });
+
+  it("prints prune help without creating a runtime", async () => {
+    let createRuntimeCalled = false;
+    const stdout: string[] = [];
+
+    const exitCode = await runWorktreeCommand(
+      { command: "prune", args: ["--help"], projectDir: "/repo", port: 5111 },
+      {
+        createRuntime: () => {
+          createRuntimeCalled = true;
+          throw new Error("unexpected");
+        },
+        stdout: (msg) => stdout.push(msg),
+      },
+    );
+
+    expect(exitCode).toBe(0);
+    expect(createRuntimeCalled).toBe(false);
+    expect(stdout).toEqual(["Usage:\n  webmux prune"]);
+  });
 });
diff --git a/bin/src/worktree-commands.ts b/bin/src/worktree-commands.ts
