fix(windows): use PowerShell instead of /bin/zsh for shell spawning

On Windows, the app was failing to create terminals because it tried
to use /bin/zsh which doesn't exist. This change adds platform-specific
shell handling:

- PTY sessions: Use PowerShell/cmd.exe on Windows, zsh/bash on Unix
- run_shell_command: Use PowerShell on Windows
- exec_shell_command: Use PowerShell with Set-Location on Windows
- install_claude_code: Use PowerShell for npm, error for native install

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: yesimmia

src-tauri/src/lib.rs

@@ -5564,11 +5564,22 @@ struct ClaudeCodeVersionInfo {
 
 /// Run a command in user's interactive login shell (to get proper PATH with nvm, etc.)
 fn run_shell_command(cmd: &str) -> std::io::Result<std::process::Output> {
-    // Use user's default shell from $SHELL, fallback to /bin/zsh (macOS default)
-    let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string());
-    std::process::Command::new(&shell)
-        .args(["-ilc", cmd]) // -i for interactive (loads .zshrc), -l for login, -c for command
-        .output()
+    #[cfg(windows)]
+    {
+        // On Windows, use PowerShell to run commands (better PATH handling than cmd.exe)
+        std::process::Command::new("powershell")
+            .args(["-NoProfile", "-Command", cmd])
+            .output()
+    }
+
+    #[cfg(not(windows))]
+    {
+        // Use user's default shell from $SHELL, fallback to /bin/zsh (macOS default)
+        let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string());
+        std::process::Command::new(&shell)
+            .args(["-ilc", cmd]) // -i for interactive (loads .zshrc), -l for login, -c for command
+            .output()
+    }
 }
 
 /// Detect Claude Code installation type
@@ -5760,9 +5771,25 @@ async fn install_claude_code_version(
             )
         };
 
-        // Use bash directly without -il to avoid slow shell startup
+        // Use appropriate shell based on platform
         println!("[DEBUG] cmd={}", cmd);
 
+        #[cfg(windows)]
+        let mut child = {
+            // On Windows, use PowerShell for npm commands
+            // Native install is not supported on Windows (uses Unix-specific tools)
+            if install_type_str != "npm" {
+                return Err("Native install is only supported on macOS/Linux. Please use npm install on Windows.".to_string());
+            }
+            Command::new("powershell")
+                .args(["-NoProfile", "-Command", &cmd])
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .map_err(|e| format!("Failed to spawn: {}", e))?
+        };
+
+        #[cfg(not(windows))]
         let mut child = Command::new("/bin/bash")
             .args(["-c", &cmd])
             .stdout(Stdio::piped())
@@ -6358,14 +6385,26 @@ fn read_file_base64(path: String) -> Result<String, String> {
 async fn exec_shell_command(command: String, cwd: String) -> Result<String, String> {
     use tokio::process::Command;
 
-    // Use user's default shell with login mode to get proper environment (API keys, etc.)
-    let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string());
+    #[cfg(windows)]
+    let output = {
+        // On Windows, use PowerShell with -WorkingDirectory
+        Command::new("powershell")
+            .args(["-NoProfile", "-Command", &format!("Set-Location '{}'; {}", cwd, command)])
+            .output()
+            .await
+            .map_err(|e| format!("Failed to run command: {}", e))?
+    };
 
-    let output = Command::new(&shell)
-        .args(["-ilc", &format!("cd '{}' && {}", cwd, command)])
-        .output()
-        .await
-        .map_err(|e| format!("Failed to run command: {}", e))?;
+    #[cfg(not(windows))]
+    let output = {
+        // Use user's default shell with login mode to get proper environment (API keys, etc.)
+        let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string());
+        Command::new(&shell)
+            .args(["-ilc", &format!("cd '{}' && {}", cwd, command)])
+            .output()
+            .await
+            .map_err(|e| format!("Failed to run command: {}", e))?
+    };
 
     if output.status.success() {
         Ok(String::from_utf8_lossy(&output.stdout).to_string())

src-tauri/src/pty_manager.rs

@@ -142,25 +142,69 @@ pub fn create_session(
         })
         .map_err(|e| format!("Failed to open PTY: {}", e))?;
 
-    // Determine shell (use user's default, fallback to zsh which is macOS default since Catalina)
-    let shell_cmd = shell.unwrap_or_else(|| {
-        std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string())
-    });
+    // Determine shell and build command based on platform
+    #[cfg(windows)]
+    let mut cmd = {
+        // On Windows, use PowerShell as default (better than cmd.exe for modern terminals)
+        let shell_cmd = shell.unwrap_or_else(|| {
+            std::env::var("SHELL")
+                .or_else(|_| std::env::var("COMSPEC"))
+                .unwrap_or_else(|_| "powershell.exe".to_string())
+        });
+
+        let is_powershell = shell_cmd.to_lowercase().contains("powershell");
+        let is_cmd = shell_cmd.to_lowercase().contains("cmd");
+
+        if let Some(ref command_str) = command {
+            let mut c = CommandBuilder::new(&shell_cmd);
+            if is_powershell {
+                c.arg("-NoExit");
+                c.arg("-Command");
+                c.arg(command_str);
+            } else if is_cmd {
+                c.arg("/K");
+                c.arg(command_str);
+            } else {
+                // Generic: try Unix-style args
+                c.arg("-c");
+                c.arg(command_str);
+            }
+            c
+        } else {
+            // Interactive shell
+            let mut c = CommandBuilder::new(&shell_cmd);
+            if is_powershell {
+                c.arg("-NoExit");
+            } else if is_cmd {
+                c.arg("/K");
+            }
+            c
+        }
+    };
 
-    // Build command: either run custom command via login shell, or just start shell
-    // Use -ilc (interactive + login) to load user's shell config (~/.zshrc, ~/.bashrc)
-    // This ensures PATH includes nvm, homebrew, npm global, etc.
-    let mut cmd = if let Some(ref command_str) = command {
-        let mut c = CommandBuilder::new(&shell_cmd);
-        c.arg("-ilc");
-        c.arg(command_str);
-        c
-    } else {
-        // Interactive shell: use -il for login mode (loads profile/rc files)
-        let mut c = CommandBuilder::new(&shell_cmd);
-        c.arg("-il");
-        c
+    #[cfg(not(windows))]
+    let mut cmd = {
+        // On Unix, use user's default shell, fallback to zsh (macOS default since Catalina)
+        let shell_cmd = shell.unwrap_or_else(|| {
+            std::env::var("SHELL").unwrap_or_else(|_| "/bin/zsh".to_string())
+        });
+
+        // Build command: either run custom command via login shell, or just start shell
+        // Use -ilc (interactive + login) to load user's shell config (~/.zshrc, ~/.bashrc)
+        // This ensures PATH includes nvm, homebrew, npm global, etc.
+        if let Some(ref command_str) = command {
+            let mut c = CommandBuilder::new(&shell_cmd);
+            c.arg("-ilc");
+            c.arg(command_str);
+            c
+        } else {
+            // Interactive shell: use -il for login mode (loads profile/rc files)
+            let mut c = CommandBuilder::new(&shell_cmd);
+            c.arg("-il");
+            c
+        }
     };
+
     cmd.cwd(&cwd);
 
     // Set proper TERM for xterm.js