Windows: fix open-in editor + worktree/terminal cleanup

Author: ksndmplb

src-tauri/src/backend/app_server.rs

@@ -6,6 +6,7 @@ use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::OnceLock;
 use std::time::Duration;
 
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
@@ -357,6 +358,55 @@ fn resolve_windows_command_path(
     None
 }
 
+#[cfg(windows)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+struct WindowsCommandCacheKey {
+    command: String,
+    path_env: Option<String>,
+    cwd: Option<String>,
+}
+
+#[cfg(windows)]
+static WINDOWS_COMMAND_PATH_CACHE: OnceLock<
+    std::sync::Mutex<HashMap<WindowsCommandCacheKey, PathBuf>>,
+> = OnceLock::new();
+
+#[cfg(windows)]
+fn resolve_windows_command_path_cached(
+    command: &str,
+    path_env: Option<&OsString>,
+    cwd_for_resolution: Option<&Path>,
+) -> Option<PathBuf> {
+    let trimmed = command.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    let cwd_key = if trimmed.contains('\\') || trimmed.contains('/') {
+        cwd_for_resolution.map(|cwd| cwd.to_string_lossy().to_string())
+    } else {
+        None
+    };
+    let key = WindowsCommandCacheKey {
+        command: trimmed.to_string(),
+        path_env: path_env.map(|value| value.to_string_lossy().to_string()),
+        cwd: cwd_key,
+    };
+
+    let cache = WINDOWS_COMMAND_PATH_CACHE.get_or_init(|| std::sync::Mutex::new(HashMap::new()));
+    if let Ok(guard) = cache.lock() {
+        if let Some(hit) = guard.get(&key) {
+            return Some(hit.clone());
+        }
+    }
+
+    let resolved = resolve_windows_command_path(trimmed, path_env, cwd_for_resolution)?;
+    if let Ok(mut guard) = cache.lock() {
+        guard.insert(key, resolved.clone());
+    }
+    Some(resolved)
+}
+
 pub(crate) fn build_codex_command_with_bin(
     codex_bin: Option<String>,
     cwd_for_resolution: Option<&Path>,
@@ -378,7 +428,7 @@ pub(crate) fn build_codex_command_with_bin(
     );
 
     #[cfg(windows)]
-    let bin = resolve_windows_command_path(raw_bin, path_env.as_ref(), cwd_for_resolution)
+    let bin = resolve_windows_command_path_cached(raw_bin, path_env.as_ref(), cwd_for_resolution)
         .map(|path| path.to_string_lossy().to_string())
         .unwrap_or_else(|| raw_bin.to_string());
 
@@ -506,8 +556,17 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
         .clone()
         .filter(|value| !value.trim().is_empty())
         .or(default_codex_bin);
+    let codex_bin_for_check = codex_bin.clone();
     let workspace_dir = Path::new(&entry.path);
-    let _ = check_codex_installation(codex_bin.clone(), Some(workspace_dir)).await?;
+    if !workspace_dir.is_dir() {
+        return Err(format!(
+            "Workspace folder does not exist: `{}`",
+            workspace_dir.display()
+        ));
+    }
+    if !cfg!(windows) {
+        let _ = check_codex_installation(codex_bin_for_check.clone(), Some(workspace_dir)).await?;
+    }
 
     let mut command = build_codex_command_with_bin(codex_bin, Some(workspace_dir));
     apply_codex_args(&mut command, codex_args.as_deref())?;
@@ -520,7 +579,19 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
     command.stdout(std::process::Stdio::piped());
     command.stderr(std::process::Stdio::piped());
 
-    let mut child = command.spawn().map_err(|e| e.to_string())?;
+    let mut child = match command.spawn() {
+        Ok(child) => child,
+        Err(err) => {
+            if err.kind() == ErrorKind::NotFound && workspace_dir.is_dir() {
+                if let Err(error) =
+                    check_codex_installation(codex_bin_for_check.clone(), Some(workspace_dir)).await
+                {
+                    return Err(error);
+                }
+            }
+            return Err(err.to_string());
+        }
+    };
     let stdin = child.stdin.take().ok_or("missing stdin")?;
     let stdout = child.stdout.take().ok_or("missing stdout")?;
     let stderr = child.stderr.take().ok_or("missing stderr")?;

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -70,6 +70,7 @@ use ignore::WalkBuilder;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::sync::{broadcast, mpsc, Mutex};
+use tokio::sync::{broadcast, mpsc, Mutex, Notify};
 
 use backend::app_server::{
     spawn_workspace_session, WorkspaceSession,
@@ -135,6 +136,7 @@ struct DaemonState {
     data_dir: PathBuf,
     workspaces: Mutex<HashMap<String, WorkspaceEntry>>,
     sessions: Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_connect_notifiers: Mutex<HashMap<String, Arc<Notify>>>,
     storage_path: PathBuf,
     settings_path: PathBuf,
     app_settings: Mutex<AppSettings>,
@@ -158,6 +160,7 @@ impl DaemonState {
             data_dir: config.data_dir.clone(),
             workspaces: Mutex::new(workspaces),
             sessions: Mutex::new(HashMap::new()),
+            workspace_connect_notifiers: Mutex::new(HashMap::new()),
             storage_path,
             settings_path,
             app_settings: Mutex::new(app_settings),
@@ -267,7 +270,7 @@ impl DaemonState {
             },
             |error| git_core::is_missing_worktree_error(error),
             |path| {
-                std::fs::remove_dir_all(path)
+                workspaces_core::remove_dir_all_best_effort(path)
                     .map_err(|err| format!("Failed to remove worktree folder: {err}"))
             },
             true,
@@ -287,7 +290,7 @@ impl DaemonState {
             },
             |error| git_core::is_missing_worktree_error(error),
             |path| {
-                std::fs::remove_dir_all(path)
+                workspaces_core::remove_dir_all_best_effort(path)
                     .map_err(|err| format!("Failed to remove worktree folder: {err}"))
             },
         )
@@ -427,18 +430,12 @@ impl DaemonState {
     }
 
     async fn connect_workspace(&self, id: String, client_version: String) -> Result<(), String> {
-        {
-            let sessions = self.sessions.lock().await;
-            if sessions.contains_key(&id) {
-                return Ok(());
-            }
-        }
-
         let client_version = client_version.clone();
         workspaces_core::connect_workspace_core(
             id,
             &self.workspaces,
             &self.sessions,
+            &self.workspace_connect_notifiers,
             &self.app_settings,
             move |entry, default_bin, codex_args, codex_home| {
                 spawn_with_client(

src-tauri/src/git/mod.rs

@@ -423,7 +423,15 @@ pub(crate) async fn get_git_status(
     drop(workspaces);
 
     let repo_root = resolve_git_root(&entry)?;
-    let repo = Repository::open(&repo_root).map_err(|e| e.to_string())?;
+    if !repo_root.is_dir() {
+        return Err(format!("Git root not found: {}", repo_root.display()));
+    }
+    let repo = Repository::discover(&repo_root).map_err(|e| {
+        format!(
+            "Git repository not found at `{}`: {e}",
+            repo_root.display()
+        )
+    })?;
 
     let branch_name = repo
         .head()