fix(worktree):Before renaming, verify the root directory of the working tree.

Fixed the issue where the validity of the parent repository's working tree directory was not verified during renaming of the working tree. Now, the directory will be checked for existence and accessibility first, and the operation will fail early if it is invalid, to avoid inconsistencies in the state if the working tree fails to move after the branch has been renamed.

New test cases have been added to verify this scenario.

Author: zhoupengwu

src-tauri/src/shared/workspaces_core/worktree.rs

@@ -406,8 +406,6 @@ where
         return Err("Branch name is unchanged.".to_string());
     }
 
-    run_git_command(&parent_root, &["branch", "-m", &old_branch, &final_branch]).await?;
-
     // Use the same priority logic as add_worktree_core:
     // per-workspace setting > global setting > default
     let worktree_root = if let Some(custom_folder) = &parent.settings.worktrees_folder {
@@ -430,44 +428,80 @@ where
     let current_path = PathBuf::from(&entry.path);
     let next_path = unique_worktree_path_for_rename(&worktree_root, &safe_name, &current_path)?;
     let next_path_string = next_path.to_string_lossy().to_string();
-    if next_path_string != entry.path {
+    let old_path_string = entry.path.clone();
+
+    run_git_command(&parent_root, &["branch", "-m", &old_branch, &final_branch]).await?;
+
+    let mut moved_worktree = false;
+    if next_path_string != old_path_string {
         if let Err(error) = run_git_command(
             &parent_root,
-            &["worktree", "move", &entry.path, &next_path_string],
+            &["worktree", "move", &old_path_string, &next_path_string],
         )
         .await
         {
             let _ =
                 run_git_command(&parent_root, &["branch", "-m", &final_branch, &old_branch]).await;
             return Err(error);
         }
+        moved_worktree = true;
     }
 
-    let (entry_snapshot, list) = {
+    let update_result: Result<(WorkspaceEntry, WorkspaceEntry, Vec<WorkspaceEntry>), String> = {
         let mut workspaces = workspaces.lock().await;
-        let entry = match workspaces.get_mut(&id) {
-            Some(entry) => entry,
-            None => return Err("workspace not found".to_string()),
-        };
-        if entry.name.trim() == old_branch {
-            entry.name = final_branch.clone();
-        }
-        entry.path = next_path_string.clone();
-        match entry.worktree.as_mut() {
-            Some(worktree) => {
-                worktree.branch = final_branch.clone();
+        if let Some(entry) = workspaces.get_mut(&id) {
+            let old_snapshot = entry.clone();
+            if entry.name.trim() == old_branch {
+                entry.name = final_branch.clone();
             }
-            None => {
-                entry.worktree = Some(WorktreeInfo {
-                    branch: final_branch.clone(),
-                });
+            entry.path = next_path_string.clone();
+            match entry.worktree.as_mut() {
+                Some(worktree) => {
+                    worktree.branch = final_branch.clone();
+                }
+                None => {
+                    entry.worktree = Some(WorktreeInfo {
+                        branch: final_branch.clone(),
+                    });
+                }
             }
+            let snapshot = entry.clone();
+            let list: Vec<_> = workspaces.values().cloned().collect();
+            Ok((old_snapshot, snapshot, list))
+        } else {
+            Err("workspace not found".to_string())
         }
-        let snapshot = entry.clone();
-        let list: Vec<_> = workspaces.values().cloned().collect();
-        (snapshot, list)
     };
-    write_workspaces(storage_path, &list)?;
+    let (old_snapshot, entry_snapshot, list) = match update_result {
+        Ok(value) => value,
+        Err(error) => {
+            if moved_worktree {
+                let _ = run_git_command(
+                    &parent_root,
+                    &["worktree", "move", &next_path_string, &old_path_string],
+                )
+                .await;
+            }
+            let _ =
+                run_git_command(&parent_root, &["branch", "-m", &final_branch, &old_branch]).await;
+            return Err(error);
+        }
+    };
+    if let Err(error) = write_workspaces(storage_path, &list) {
+        if moved_worktree {
+            let _ = run_git_command(
+                &parent_root,
+                &["worktree", "move", &next_path_string, &old_path_string],
+            )
+            .await;
+        }
+        let _ = run_git_command(&parent_root, &["branch", "-m", &final_branch, &old_branch]).await;
+        let mut workspaces = workspaces.lock().await;
+        if let Some(entry) = workspaces.get_mut(&id) {
+            *entry = old_snapshot;
+        }
+        return Err(error);
+    }
 
     if let Some(session) = sessions.lock().await.get(&entry_snapshot.id).cloned() {
         session

src-tauri/src/workspaces/tests.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::future::Future;
 use std::path::PathBuf;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex as StdMutex};
 
 use super::settings::{apply_workspace_settings_update, sort_workspaces};
 use super::worktree::{
@@ -56,6 +56,7 @@ fn workspace_with_id_and_kind(
             launch_script: None,
             launch_scripts: None,
             worktree_setup_script: None,
+            worktrees_folder: None,
         },
     }
 }
@@ -390,6 +391,95 @@ fn rename_worktree_updates_name_when_unmodified() {
     });
 }
 
+#[test]
+fn rename_worktree_validates_worktree_root_before_branch_rename() {
+    run_async(async {
+        let temp_dir = std::env::temp_dir().join(format!("codex-monitor-test-{}", Uuid::new_v4()));
+        let repo_path = temp_dir.join("repo");
+        std::fs::create_dir_all(&repo_path).expect("create repo path");
+        let worktree_path = temp_dir.join("worktrees").join("parent").join("old");
+        std::fs::create_dir_all(&worktree_path).expect("create worktree path");
+
+        let invalid_root = temp_dir.join("not-a-directory");
+        std::fs::write(&invalid_root, "x").expect("create invalid root file");
+
+        let mut parent_settings = WorkspaceSettings::default();
+        parent_settings.worktrees_folder = Some(invalid_root.to_string_lossy().to_string());
+        let parent = WorkspaceEntry {
+            id: "parent".to_string(),
+            name: "Parent".to_string(),
+            path: repo_path.to_string_lossy().to_string(),
+            kind: WorkspaceKind::Main,
+            parent_id: None,
+            worktree: None,
+            settings: parent_settings,
+        };
+        let worktree = WorkspaceEntry {
+            id: "wt-3".to_string(),
+            name: "feature/old".to_string(),
+            path: worktree_path.to_string_lossy().to_string(),
+            kind: WorkspaceKind::Worktree,
+            parent_id: Some(parent.id.clone()),
+            worktree: Some(WorktreeInfo {
+                branch: "feature/old".to_string(),
+            }),
+            settings: WorkspaceSettings::default(),
+        };
+        let workspaces = Mutex::new(HashMap::from([
+            (parent.id.clone(), parent.clone()),
+            (worktree.id.clone(), worktree.clone()),
+        ]));
+        let sessions: Mutex<HashMap<String, Arc<WorkspaceSession>>> = Mutex::new(HashMap::new());
+        let app_settings = Mutex::new(AppSettings::default());
+        let storage_path = temp_dir.join("workspaces.json");
+
+        let calls: Arc<StdMutex<Vec<Vec<String>>>> = Arc::new(StdMutex::new(Vec::new()));
+        let result = rename_worktree_core(
+            worktree.id.clone(),
+            "feature/new".to_string(),
+            &temp_dir,
+            &workspaces,
+            &sessions,
+            &app_settings,
+            &storage_path,
+            |_| Ok(repo_path.clone()),
+            |_root, branch| {
+                let branch = branch.to_string();
+                async move { Ok(branch) }
+            },
+            |value| sanitize_worktree_name(value),
+            |_, _, current| Ok(current.to_path_buf()),
+            |_root, args| {
+                let calls = calls.clone();
+                let args: Vec<String> = args.iter().map(|value| value.to_string()).collect();
+                async move {
+                    calls
+                        .lock()
+                        .expect("lock")
+                        .push(args);
+                    Ok(())
+                }
+            },
+            |_entry, _default_bin, _codex_args, _codex_home| async move {
+                Err("spawn not expected".to_string())
+            },
+        )
+        .await;
+
+        let error = result.expect_err("expected invalid worktree root to fail");
+        assert!(error.contains("Failed to create worktree directory"));
+        assert!(calls.lock().expect("lock").is_empty());
+
+        let stored = workspaces.lock().await;
+        let entry = stored.get(&worktree.id).expect("stored entry");
+        assert_eq!(
+            entry.worktree.as_ref().map(|worktree| worktree.branch.as_str()),
+            Some("feature/old")
+        );
+        assert_eq!(entry.path, worktree.path);
+    });
+}
+
 #[test]
 fn remove_workspace_succeeds_when_parent_repo_folder_is_missing() {
     run_async(async {