fix(windows): prevent terminal flashing during WSL detection and execution

- Add CREATE_NO_WINDOW flag (0x08000000) to all WSL commands
- Create wsl_command() helper function that sets the flag automatically
- Apply flag to WSL detection in claude_binary.rs (distro listing, claude path finding)
- Apply flag to WSL detection in shell_environment.rs (distro detection, claude check)
- Apply flag to actual Claude execution via WSL in commands/claude.rs
- Apply flag to Git Bash execution as well

This prevents the console window from briefly appearing when:
1. Auto-detecting Claude installations in WSL distributions
2. Running Claude commands through WSL
3. Running Claude commands through Git Bash

Author: jms830

src-tauri/src/claude_binary.rs

@@ -2,12 +2,19 @@ use anyhow::Result;
 use log::{debug, error, info, warn};
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
+#[cfg(windows)]
+use std::os::windows::process::CommandExt;
 /// Shared module for detecting Claude Code binary installations
 /// Supports NVM installations, aliased paths, and version-based selection
 use std::path::PathBuf;
 use std::process::Command;
 use tauri::Manager;
 
+/// Windows constant for CREATE_NO_WINDOW flag
+/// This prevents console windows from flashing when running background commands
+#[cfg(windows)]
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
 /// Type of Claude installation
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum InstallationType {
@@ -552,11 +559,19 @@ fn find_wsl_installations() -> Vec<ClaudeInstallation> {
     installations
 }
 
+/// Creates a WSL command with CREATE_NO_WINDOW flag to prevent terminal flashing
+#[cfg(windows)]
+fn wsl_command() -> Command {
+    let mut cmd = Command::new("wsl");
+    cmd.creation_flags(CREATE_NO_WINDOW);
+    cmd
+}
+
 /// Get list of WSL distributions
 #[cfg(windows)]
 fn get_wsl_distributions() -> Result<Vec<String>, String> {
     // Run: wsl -l -q (quiet mode, just names)
-    let output = Command::new("wsl")
+    let output = wsl_command()
         .args(["-l", "-q"])
         .output()
         .map_err(|e| format!("Failed to run wsl -l -q: {}", e))?;
@@ -594,7 +609,7 @@ fn get_wsl_distributions() -> Result<Vec<String>, String> {
 #[cfg(windows)]
 fn find_claude_in_wsl(distro: &str) -> Option<String> {
     // Try 'which claude' in the WSL distribution
-    let output = Command::new("wsl")
+    let output = wsl_command()
         .args(["-d", distro, "--", "which", "claude"])
         .output()
         .ok()?;
@@ -615,7 +630,7 @@ fn find_claude_in_wsl(distro: &str) -> Option<String> {
         let nvm_base = format!("{}/.nvm/versions/node", home);
 
         // List node versions and check for claude
-        let output = Command::new("wsl")
+        let output = wsl_command()
             .args(["-d", distro, "--", "ls", "-1", &nvm_base])
             .output();
 
@@ -627,7 +642,7 @@ fn find_claude_in_wsl(distro: &str) -> Option<String> {
                     if !version.is_empty() {
                         let claude_path = format!("{}/{}/bin/claude", nvm_base, version);
                         // Check if claude exists at this path
-                        let check = Command::new("wsl")
+                        let check = wsl_command()
                             .args(["-d", distro, "--", "test", "-f", &claude_path])
                             .output();
 
@@ -643,7 +658,7 @@ fn find_claude_in_wsl(distro: &str) -> Option<String> {
 
         // Check ~/.local/bin/claude
         let local_claude = format!("{}/.local/bin/claude", home);
-        let check = Command::new("wsl")
+        let check = wsl_command()
             .args(["-d", distro, "--", "test", "-f", &local_claude])
             .output();
 
@@ -656,7 +671,7 @@ fn find_claude_in_wsl(distro: &str) -> Option<String> {
 
     // Check common system paths
     for path in common_paths {
-        let check = Command::new("wsl")
+        let check = wsl_command()
             .args(["-d", distro, "--", "test", "-f", path])
             .output();
 
@@ -673,7 +688,7 @@ fn find_claude_in_wsl(distro: &str) -> Option<String> {
 /// Get home directory in WSL
 #[cfg(windows)]
 fn get_wsl_home_dir(distro: &str) -> Option<String> {
-    let output = Command::new("wsl")
+    let output = wsl_command()
         .args(["-d", distro, "--", "echo", "$HOME"])
         .output()
         .ok()?;
@@ -691,7 +706,7 @@ fn get_wsl_home_dir(distro: &str) -> Option<String> {
 /// Get Claude version in WSL
 #[cfg(windows)]
 fn get_claude_version_in_wsl(distro: &str, claude_path: &str) -> Option<String> {
-    let output = Command::new("wsl")
+    let output = wsl_command()
         .args(["-d", distro, "--", claude_path, "--version"])
         .output()
         .ok()?;

src-tauri/src/commands/claude.rs

@@ -13,6 +13,14 @@ use tokio::sync::Mutex;
 #[cfg(windows)]
 use crate::shell_environment::{create_wsl_command, ShellConfig, ShellEnvironment};
 
+#[cfg(windows)]
+use std::os::windows::process::CommandExt;
+
+/// Windows constant for CREATE_NO_WINDOW flag
+/// This prevents console windows from flashing when running background commands
+#[cfg(windows)]
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
 /// Global state to track current Claude process
 pub struct ClaudeProcessState {
     pub current_process: Arc<Mutex<Option<Child>>>,
@@ -398,6 +406,8 @@ fn create_system_command_with_shell(
                 tokio_cmd.arg(arg);
             }
 
+            // Set CREATE_NO_WINDOW to prevent terminal flashing
+            tokio_cmd.creation_flags(CREATE_NO_WINDOW);
             tokio_cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
 
             tokio_cmd
@@ -434,6 +444,8 @@ fn create_system_command_with_shell(
             );
 
             cmd.args(["-lc", &bash_command]);
+            // Set CREATE_NO_WINDOW to prevent terminal flashing
+            cmd.creation_flags(CREATE_NO_WINDOW);
             cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
 
             cmd

src-tauri/src/shell_environment.rs

@@ -11,8 +11,23 @@
 
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
+#[cfg(windows)]
+use std::os::windows::process::CommandExt;
 use std::process::Command;
 
+/// Windows constant for CREATE_NO_WINDOW flag
+/// This prevents console windows from flashing when running background commands
+#[cfg(windows)]
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+/// Creates a WSL command with CREATE_NO_WINDOW flag to prevent terminal flashing
+#[cfg(windows)]
+fn wsl_command() -> Command {
+    let mut cmd = Command::new("wsl");
+    cmd.creation_flags(CREATE_NO_WINDOW);
+    cmd
+}
+
 /// Available shell environments for Claude execution
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 #[serde(rename_all = "lowercase")]
@@ -101,7 +116,7 @@ fn detect_wsl_distributions() -> Vec<WslDistribution> {
     let mut distributions = Vec::new();
 
     // Run `wsl --list --verbose` to get distributions
-    match Command::new("wsl").args(["--list", "--verbose"]).output() {
+    match wsl_command().args(["--list", "--verbose"]).output() {
         Ok(output) if output.status.success() => {
             // WSL outputs UTF-16LE on Windows, need to handle that
             let stdout = String::from_utf8_lossy(&output.stdout);
@@ -220,7 +235,7 @@ fn detect_git_bash() -> Option<String> {
 pub fn check_claude_in_wsl(distro: Option<&str>) -> Option<String> {
     debug!("Checking for Claude in WSL (distro: {:?})...", distro);
 
-    let mut cmd = Command::new("wsl");
+    let mut cmd = wsl_command();
 
     if let Some(d) = distro {
         cmd.args(["-d", d]);
@@ -282,14 +297,15 @@ pub fn windows_to_wsl_path(path: &str) -> String {
 }
 
 /// Create a command that runs through WSL
+/// Uses CREATE_NO_WINDOW flag to prevent terminal flashing
 #[cfg(windows)]
 pub fn create_wsl_command(
     distro: Option<&str>,
     claude_path: &str,
     args: &[String],
     working_dir: &str,
 ) -> Command {
-    let mut cmd = Command::new("wsl");
+    let mut cmd = wsl_command();
 
     // Specify distribution if provided
     if let Some(d) = distro {