feat(git): delete worktree and directory upon termination

Author: brucehsu

apps/desktop/src-tauri/gen/schemas/acl-manifests.json

@@ -13,6 +13,7 @@ commands.allow = [
   "stage_all_changes",
   "unstage_all_changes",
   "discard_all_changes",
+  "remove_session_worktree",
   "commit_git_changes",
   "get_last_commit_message",
   "load_config",
@@ -42,6 +43,7 @@ commands.allow = [
   "stage_all_changes",
   "unstage_all_changes",
   "discard_all_changes",
+  "remove_session_worktree",
   "commit_git_changes",
   "get_last_commit_message",
   "load_config",

apps/desktop/src-tauri/permissions/app.toml

@@ -3,7 +3,7 @@ use base64::{engine::general_purpose, Engine as _};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::{Read, Write};
-use std::path::{Path, PathBuf};
+use std::path::{Component, Path, PathBuf};
 use std::sync::{atomic::{AtomicU32, Ordering}, Arc, Mutex};
 use tauri::{AppHandle, Emitter, RunEvent, State, WindowEvent};
 #[cfg(target_os = "macos")]
@@ -460,6 +460,117 @@ fn discard_all_changes(path: String) -> Result<(), String> {
   )
 }
 
+fn remove_session_worktree_blocking(
+  repo_path: String,
+  worktree_path: String,
+  branch: Option<String>,
+) -> Result<(), String> {
+  let root = resolve_repo_root(repo_path)?;
+  if !Path::new(&root).exists() {
+    return Err(format!("Path '{}' does not exist", root));
+  }
+
+  let trimmed_worktree = worktree_path.trim();
+  if trimmed_worktree.is_empty() {
+    return Err("Worktree path cannot be empty".to_string());
+  }
+
+  let worktree_root = worktrees_root_dir()?;
+  let worktree = PathBuf::from(trimmed_worktree);
+  if !worktree.is_absolute() {
+    return Err("Worktree path must be absolute".to_string());
+  }
+  let allowed = if worktree.exists() {
+    let canonical_worktree = worktree
+      .canonicalize()
+      .map_err(|error| format!("Failed to resolve worktree path: {error}"))?;
+    let canonical_root = worktree_root
+      .canonicalize()
+      .unwrap_or(worktree_root.clone());
+    canonical_worktree.starts_with(&canonical_root)
+  } else {
+    let canonical_root = worktree_root
+      .canonicalize()
+      .unwrap_or(worktree_root.clone());
+    let has_parent_dir = worktree
+      .components()
+      .any(|component| matches!(component, Component::ParentDir));
+    !has_parent_dir && worktree.starts_with(&canonical_root)
+  };
+  if !allowed {
+    return Err("Worktree path is outside managed Codelegate worktrees".to_string());
+  }
+
+  let worktree_path = Path::new(trimmed_worktree);
+  let worktree_exists_before = worktree_path.exists();
+
+  let remove_output = std::process::Command::new("git")
+    .arg("-C")
+    .arg(&root)
+    .arg("worktree")
+    .arg("remove")
+    .arg("--force")
+    .arg(trimmed_worktree)
+    .output()
+    .map_err(|error| format!("Failed to run git: {error}"))?;
+  if !remove_output.status.success() {
+    let stderr = String::from_utf8_lossy(&remove_output.stderr).trim().to_string();
+    let is_not_worktree = stderr.contains("is not a working tree");
+    let is_missing = stderr.contains("No such file or directory")
+      || stderr.contains("does not exist");
+    if is_not_worktree && worktree_exists_before {
+      return Err("Refusing to delete directory because target is not a registered git worktree".to_string());
+    }
+    let ignorable = is_not_worktree || is_missing;
+    if !ignorable {
+      return Err(if stderr.is_empty() {
+        "Failed to remove worktree".to_string()
+      } else {
+        stderr
+      });
+    }
+  }
+
+  if worktree_path.exists() {
+    std::fs::remove_dir_all(worktree_path)
+      .map_err(|error| format!("Failed to remove worktree directory: {error}"))?;
+  }
+
+  let branch_name = branch.unwrap_or_default().trim().to_string();
+  if !branch_name.is_empty() {
+    let branch_output = std::process::Command::new("git")
+      .arg("-C")
+      .arg(&root)
+      .arg("branch")
+      .arg("-D")
+      .arg(&branch_name)
+      .output()
+      .map_err(|error| format!("Failed to run git: {error}"))?;
+    if !branch_output.status.success() {
+      let stderr = String::from_utf8_lossy(&branch_output.stderr).trim().to_string();
+      let ignorable = stderr.contains("not found");
+      if !ignorable {
+        return Err(if stderr.is_empty() {
+          format!("Failed to delete branch '{}'", branch_name)
+        } else {
+          stderr
+        });
+      }
+    }
+  }
+
+  Ok(())
+}
+
+#[tauri::command]
+async fn remove_session_worktree(repo_path: String, worktree_path: String, branch: Option<String>) -> Result<(), String> {
+  tauri::async_runtime::spawn_blocking(move || {
+    remove_session_worktree_blocking(repo_path, worktree_path, branch)
+  })
+  .await
+  .map_err(|error| format!("Failed to join worktree removal task: {error}"))?
+}
+
 #[tauri::command]
 fn commit_git_changes(path: String, message: String, amend: bool) -> Result<(), String> {
   let root = resolve_repo_root(path)?;
@@ -770,6 +881,13 @@ fn previous_sessions_file() -> Result<PathBuf, String> {
   Ok(home.join(".codelegate").join("previous_sessions.json"))
 }
 
+fn worktrees_root_dir() -> Result<PathBuf, String> {
+  let home = std::env::var_os("HOME")
+    .map(PathBuf::from)
+    .ok_or_else(|| "Unable to locate home directory".to_string())?;
+  Ok(home.join(".codelegate").join("worktrees"))
+}
+
 fn should_override_close_flow() -> bool {
   has_saved_config().unwrap_or(false) && load_config().is_ok()
 }
@@ -861,6 +979,7 @@ pub fn run() {
       stage_all_changes,
       unstage_all_changes,
       discard_all_changes,
+      remove_session_worktree,
       commit_git_changes,
       get_last_commit_message,
       load_config,

apps/desktop/src-tauri/src/lib.rs

@@ -6,19 +6,21 @@ import {
   useState,
   type PointerEvent as ReactPointerEvent,
 } from "react";
-import { confirm, open } from "@tauri-apps/plugin-dialog";
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
 import styles from "./App.module.css";
 import Sidebar from "./components/Sidebar/Sidebar";
 import MainPane from "./components/MainPane/MainPane";
 import NewSessionDialog from "./components/NewSessionDialog/NewSessionDialog";
 import SettingsDialog from "./components/SettingsDialog/SettingsDialog";
 import RenameDialog from "./components/RenameDialog/RenameDialog";
 import CloseDialog from "./components/CloseDialog/CloseDialog";
+import TerminateSessionDialog from "./components/TerminateSessionDialog/TerminateSessionDialog";
 import OnboardingDialog from "./components/OnboardingDialog/OnboardingDialog";
 import { useAppState } from "./hooks/useAppState";
 import { useToasts } from "./hooks/useToasts";
 import Toasts from "./components/Toasts/Toasts";
-import type { AgentId, CloseConfirmPayload, CloseConfirmResult, EnvVar, RepoConfig, PaneKind } from "./types";
+import type { AgentId, CloseConfirmPayload, CloseConfirmResult, EnvVar, RepoConfig, PaneKind, Session } from "./types";
 import { getRepoName, groupSessionsByRepo, validateEnvVars } from "./utils/session";
 import { defineHotkey, runHotkeys, type HotkeyBinding } from "./utils/hotkeys";
 import {
@@ -30,6 +32,15 @@ import { agentCatalog } from "./constants";
 
 const emptyEnv: EnvVar[] = [{ key: "", value: "" }];
 
+function canDeleteWorktreeForSession(session: Session | null | undefined) {
+  if (!session?.repo.worktree?.enabled) {
+    return false;
+  }
+  const cwd = session.cwd?.trim();
+  const repoRoot = session.repo.repoPath.trim();
+  return Boolean(cwd && repoRoot && cwd !== repoRoot);
+}
+
 function buildModifierSessionSelectHotkeys(
   shortcutModifier: string,
   selectSessionByHotkeyIndex: (index: number) => void
@@ -72,6 +83,8 @@ export default function App() {
   const closeDialogResolveRef = useRef<((result: CloseConfirmResult) => void) | null>(null);
   const closeDialogPromiseRef = useRef<Promise<CloseConfirmResult> | null>(null);
   const previousActiveSessionIdRef = useRef<string | null>(null);
+  const [terminateDialogSessionId, setTerminateDialogSessionId] = useState<string | null>(null);
+  const [terminateDialogDeleteWorktree, setTerminateDialogDeleteWorktree] = useState(false);
 
   function focusSearch() {
     if (searchInputRef.current) {
@@ -334,6 +347,14 @@ export default function App() {
     () => visibleSessions.find((session) => session.id === activeSessionId) ?? null,
     [activeSessionId, visibleSessions]
   );
+  const terminateDialogSession = useMemo(
+    () => sessions.find((session) => session.id === terminateDialogSessionId) ?? null,
+    [sessions, terminateDialogSessionId]
+  );
+  const canDeleteDialogWorktree = useMemo(
+    () => canDeleteWorktreeForSession(terminateDialogSession),
+    [terminateDialogSession]
+  );
 
   const canRestartActiveAgent = useMemo(() => {
     if (activePaneKind !== "agent" || !activeSession) {
@@ -361,19 +382,73 @@ export default function App() {
     openRename(activeSessionId);
   }, [activeSessionId, openRename]);
 
-  const terminateActiveSession = useCallback(async () => {
-    if (!activeSessionId) {
+  const openTerminateDialog = useCallback((sessionId: string) => {
+    setTerminateDialogSessionId(sessionId);
+    setTerminateDialogDeleteWorktree(false);
+  }, []);
+
+  const closeTerminateDialog = useCallback(() => {
+    setTerminateDialogSessionId(null);
+    setTerminateDialogDeleteWorktree(false);
+  }, []);
+
+  const confirmTerminateDialog = useCallback(async () => {
+    const session = sessions.find((item) => item.id === terminateDialogSessionId);
+    const targetSessionId = terminateDialogSessionId;
+    if (!session || !targetSessionId) {
+      closeTerminateDialog();
       return;
     }
-    const confirmed = await confirm(
-      "Terminate this session? This will close the tab and stop ongoing shell sessions.",
-      { title: "Codelegate", kind: "warning" }
-    );
-    if (!confirmed) {
+    const shouldDeleteWorktree = terminateDialogDeleteWorktree && canDeleteWorktreeForSession(session);
+    closeTerminateDialog();
+    try {
+      let cleanupWorktree:
+        | {
+            repoPath: string;
+            worktreePath: string;
+            branch?: string;
+          }
+        | undefined;
+      if (shouldDeleteWorktree) {
+        let branchName: string | undefined;
+        const branchPath = session.cwd?.trim();
+        if (branchPath) {
+          try {
+            const resolvedBranch = await invoke<string>("get_git_branch", { path: branchPath });
+            const trimmedBranch = resolvedBranch.trim();
+            if (trimmedBranch) {
+              branchName = trimmedBranch;
+            }
+          } catch (error) {
+            // Keep branch optional; backend cleanup will still remove worktree directory.
+            pushToast({ message: `Failed to resolve branch from git: ${String(error)}`, tone: "error" });
+          }
+        }
+        cleanupWorktree = {
+          repoPath: session.repo.repoPath,
+          worktreePath: session.cwd ?? "",
+          branch: branchName || undefined,
+        };
+      }
+      await terminateSession(targetSessionId, cleanupWorktree ? { cleanupWorktree } : undefined);
+    } catch (error) {
+      pushToast({ message: `Failed to terminate session: ${String(error)}`, tone: "error" });
+    }
+  }, [
+    closeTerminateDialog,
+    pushToast,
+    sessions,
+    terminateDialogDeleteWorktree,
+    terminateDialogSessionId,
+    terminateSession,
+  ]);
+
+  const terminateActiveSession = useCallback(() => {
+    if (!activeSessionId) {
       return;
     }
-    terminateSession(activeSessionId);
-  }, [activeSessionId, terminateSession]);
+    openTerminateDialog(activeSessionId);
+  }, [activeSessionId, openTerminateDialog]);
 
   const openSettings = useCallback(() => {
     setFontFamily(config.settings.terminalFontFamily);
@@ -749,7 +824,7 @@ export default function App() {
           onNewSession={handleOpenDialog}
           onOpenSettings={openSettings}
           onRenameSession={openRename}
-          onTerminateSession={terminateSession}
+          onTerminateSession={openTerminateDialog}
           agentOutputting={agentOutputting}
           searchRef={searchInputRef}
           showShortcutHints={showShortcutHints}
@@ -835,6 +910,17 @@ export default function App() {
         onClose={handleCloseConfirmCancel}
         onConfirm={handleCloseConfirmSubmit}
       />
+      <TerminateSessionDialog
+        open={Boolean(terminateDialogSession)}
+        sessionLabel={terminateDialogSession?.branch?.trim() || getRepoName(terminateDialogSession?.repo.repoPath ?? "")}
+        canDeleteWorktree={canDeleteDialogWorktree}
+        deleteWorktree={terminateDialogDeleteWorktree}
+        onDeleteWorktreeChange={setTerminateDialogDeleteWorktree}
+        onClose={closeTerminateDialog}
+        onConfirm={() => {
+          void confirmTerminateDialog();
+        }}
+      />
       <Toasts toasts={toasts} onDismiss={removeToast} />
     </div>
   );

apps/desktop/src/App.tsx

@@ -1,5 +1,4 @@
 import { Bot, MoreHorizontal, Plus, Settings } from "lucide-react";
-import { confirm } from "@tauri-apps/plugin-dialog";
 import { Fragment, useEffect, useState } from "react";
 import type { SessionGroup } from "../../utils/session";
 import { ClaudeIconIcon, OpenaiIconIcon } from "@codelegate/shared/icons";
@@ -195,14 +194,7 @@ export default function Sidebar({
                           <button
                             type="button"
                             className={`${styles.menuItem} ${styles.menuItemWithShortcut} ${styles.menuItemDanger}`}
-                            onClick={async () => {
-                              const confirmed = await confirm(
-                                "Terminate this session? This will close the tab and stop ongoing shell sessions.",
-                                { title: "Codelegate", kind: "warning" }
-                              );
-                              if (!confirmed) {
-                                return;
-                              }
+                            onClick={() => {
                               setOpenMenuId(null);
                               onTerminateSession(session.id);
                             }}