fix(windows): resolve diffs, stray consoles, and state persistence

Three Windows-only breakages:

- Diffs never opened: the sidebar ran `sh -c '… | delta'`, but there is
  no POSIX `sh` on Windows. Wire delta in as git's pager instead so git
  drives the pipe itself — no shell dependency, identical result on every
  platform.
- A console window flashed on every `git`/`gh` probe: a GUI-subsystem
  binary owns no console, so each child got its own. Add a `hide_console`
  helper that sets `CREATE_NO_WINDOW`, applied to all child spawns.
- Projects were forgotten across restarts: `config_path` only checked
  `$XDG_CONFIG_HOME`/`$HOME`, both unset on Windows, so state never saved
  or loaded. Fall back to the roaming app-data dir there.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mathix420

alacritree/src/app.rs

@@ -1146,25 +1146,30 @@ impl AlacritreeApp {
     }
 }
 
-/// Pipe `git diff` for the clicked file through delta. Positional args via
-/// `sh -c '…' name "$1" "$2"` keep path/branch names out of the script body so
-/// no shell metacharacter in the file name can be interpreted.
+/// Show the clicked file's `git diff` in delta, wired in as git's pager so git
+/// drives the pipe itself.  This drops the POSIX-`sh` dependency the old
+/// `sh -c '… | delta'` had — which had no equivalent on Windows, so diffs never
+/// opened there.  Paths/branches stay in argv, so no file name is shell-parsed.
 fn build_diff_command(req: &DiffRequest) -> (String, Vec<String>) {
-    let script: &str = match &req.source {
-        DiffSource::Staged => r#"git diff --cached -- "$1" | delta --paging=always"#,
-        DiffSource::Worktree => r#"git diff -- "$1" | delta --paging=always"#,
-        // `--no-index` is git's "diff arbitrary files" mode; against /dev/null it
-        // shows the untracked file as a pure addition. Exits non-zero by design.
-        DiffSource::Untracked => r#"git diff --no-index -- /dev/null "$1" | delta --paging=always"#,
+    let mut args =
+        vec!["-c".to_string(), "core.pager=delta --paging=always".to_string(), "diff".to_string()];
+    match &req.source {
+        DiffSource::Staged => args.push("--cached".to_string()),
+        DiffSource::Worktree => {},
+        // `--no-index` against /dev/null shows the untracked file as a pure
+        // addition; git special-cases "/dev/null" on every platform. Exits
+        // non-zero by design.
+        DiffSource::Untracked => args.push("--no-index".to_string()),
         // Triple-dot diff = "from merge-base to HEAD" — matches the sidebar's
         // `Changes vs <branch>` stat semantics in git_status.rs.
-        DiffSource::Branch { .. } => r#"git diff "$2"... -- "$1" | delta --paging=always"#,
-    };
-    let mut args = vec!["-c".to_string(), script.to_string(), "sh".to_string(), req.file.clone()];
-    if let DiffSource::Branch { base } = &req.source {
-        args.push(base.clone());
+        DiffSource::Branch { base } => args.push(format!("{base}...")),
+    }
+    args.push("--".to_string());
+    if matches!(req.source, DiffSource::Untracked) {
+        args.push("/dev/null".to_string());
     }
-    ("sh".to_string(), args)
+    args.push(req.file.clone());
+    ("git".to_string(), args)
 }
 
 fn dirty_warning(counts: &DirtyCounts) -> Option<String> {

alacritree/src/command_ext.rs

@@ -0,0 +1,25 @@
+//! alacritree is a GUI-subsystem binary with no console of its own, so on
+//! Windows each `git`/`gh`/`cmd` child gets a fresh console window unless we
+//! pass `CREATE_NO_WINDOW`.
+
+use std::process::Command;
+
+pub trait CommandExt {
+    /// Suppress the console window Windows would spawn for this child. No-op
+    /// elsewhere.
+    fn hide_console(&mut self) -> &mut Self;
+}
+
+impl CommandExt for Command {
+    #[cfg(windows)]
+    fn hide_console(&mut self) -> &mut Self {
+        use std::os::windows::process::CommandExt as _;
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        self.creation_flags(CREATE_NO_WINDOW)
+    }
+
+    #[cfg(not(windows))]
+    fn hide_console(&mut self) -> &mut Self {
+        self
+    }
+}

alacritree/src/links.rs

@@ -12,6 +12,7 @@ use alacritty_terminal::index::{Direction, Point};
 use alacritty_terminal::term::Term;
 use alacritty_terminal::term::search::{Match, RegexIter, RegexSearch};
 
+use crate::command_ext::CommandExt;
 use crate::session::EventProxy;
 
 // Identical to alacritty's built-in URL hint regex so the set of recognised
@@ -161,6 +162,7 @@ pub fn open(uri: &str) {
 #[cfg(target_os = "macos")]
 fn spawn(uri: &str) -> std::io::Result<()> {
     Command::new("open")
+        .hide_console()
         .arg(uri)
         .stdin(Stdio::null())
         .stdout(Stdio::null())
@@ -174,6 +176,7 @@ fn spawn(uri: &str) -> std::io::Result<()> {
     // `start` treats its first quoted argument as a window title, so pass an
     // empty title before the URL to keep `cmd` from eating it.
     Command::new("cmd")
+        .hide_console()
         .args(["/c", "start", ""])
         .arg(uri)
         .stdin(Stdio::null())
@@ -186,6 +189,7 @@ fn spawn(uri: &str) -> std::io::Result<()> {
 #[cfg(not(any(target_os = "macos", target_os = "windows")))]
 fn spawn(uri: &str) -> std::io::Result<()> {
     Command::new("xdg-open")
+        .hide_console()
         .arg(uri)
         .stdin(Stdio::null())
         .stdout(Stdio::null())

alacritree/src/main.rs

@@ -5,6 +5,7 @@ mod bindings;
 mod builtin_font;
 mod clipboard;
 mod colors;
+mod command_ext;
 mod config;
 mod fonts;
 mod git_status;

alacritree/src/pr_status.rs

@@ -16,6 +16,8 @@ use std::sync::mpsc::{self, Receiver};
 use std::thread;
 use std::time::{Duration, Instant};
 
+use crate::command_ext::CommandExt;
+
 /// Re-query at most this often.  PR base branches rarely change, and a stale
 /// answer just falls back to the previous diff target — not worth hammering
 /// `gh` on every status refresh.
@@ -120,6 +122,7 @@ fn spawn_lookup(
 /// to be checked out in the worktree.
 fn query_gh(path: &Path, branch: &str) -> Option<PrInfo> {
     let output = Command::new("gh")
+        .hide_console()
         .current_dir(path)
         .args(["pr", "view", branch, "--json", "number,baseRefName,url"])
         .stdout(Stdio::piped())
@@ -147,7 +150,8 @@ mod tests {
 
     #[test]
     fn parses_gh_json() {
-        let stdout = br#"{"baseRefName":"main","number":42,"url":"https://github.com/o/r/pull/42"}"#;
+        let stdout =
+            br#"{"baseRefName":"main","number":42,"url":"https://github.com/o/r/pull/42"}"#;
         let info = parse_gh_output(stdout).unwrap();
         assert_eq!(info.number, 42);
         assert_eq!(info.base_branch, "main");

alacritree/src/state.rs

@@ -26,13 +26,26 @@ fn default_true() -> bool {
 }
 
 pub fn config_path() -> Option<PathBuf> {
-    let base = if let Some(xdg) = std::env::var_os("XDG_CONFIG_HOME") {
-        PathBuf::from(xdg)
-    } else {
-        let home = std::env::var_os("HOME")?;
-        PathBuf::from(home).join(".config")
-    };
-    Some(base.join("alacritree").join("state.toml"))
+    Some(config_dir()?.join("alacritree").join("state.toml"))
+}
+
+/// Per-user config base: XDG on Unix, the roaming app-data dir on Windows
+/// (which has neither `$XDG_CONFIG_HOME` nor `$HOME`).
+#[cfg(not(windows))]
+fn config_dir() -> Option<PathBuf> {
+    if let Some(xdg) = std::env::var_os("XDG_CONFIG_HOME") {
+        return Some(PathBuf::from(xdg));
+    }
+    let home = std::env::var_os("HOME")?;
+    Some(PathBuf::from(home).join(".config"))
+}
+
+#[cfg(windows)]
+fn config_dir() -> Option<PathBuf> {
+    std::env::var_os("APPDATA")
+        .or_else(|| std::env::var_os("LOCALAPPDATA"))
+        .map(PathBuf::from)
+        .or_else(home::home_dir)
 }
 
 pub fn load() -> PersistedState {

alacritree/src/worktree.rs

@@ -6,6 +6,8 @@ use std::process::{Command, Stdio};
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::thread;
 
+use crate::command_ext::CommandExt;
+
 #[derive(Debug, Clone)]
 pub enum Progress {
     Step(String),
@@ -141,6 +143,7 @@ fn enable_claude_terminal_bell(worktree_root: &Path) -> std::io::Result<()> {
 
 fn run_git(cwd: &Path, args: &[&str]) -> Result<(), String> {
     let output = Command::new("git")
+        .hide_console()
         .arg("-C")
         .arg(cwd)
         .args(args)
@@ -159,6 +162,7 @@ fn run_git(cwd: &Path, args: &[&str]) -> Result<(), String> {
 
 fn has_remote(cwd: &Path, name: &str) -> bool {
     Command::new("git")
+        .hide_console()
         .arg("-C")
         .arg(cwd)
         .args(["remote", "get-url", name])
@@ -219,6 +223,7 @@ fn resolve_base_branch(cwd: &Path, hint: Option<&str>) -> Result<(String, String
 
 fn rev_parse_verify(cwd: &Path, name: &str) -> bool {
     Command::new("git")
+        .hide_console()
         .arg("-C")
         .arg(cwd)
         .args(["rev-parse", "--verify", "--quiet", name])
@@ -235,6 +240,7 @@ fn rev_parse_verify(cwd: &Path, name: &str) -> bool {
 /// We pull the `refs/heads/<name>` from the symref line.
 fn query_origin_head(cwd: &Path) -> Option<String> {
     let output = Command::new("git")
+        .hide_console()
         .arg("-C")
         .arg(cwd)
         .args(["ls-remote", "--symref", "origin", "HEAD"])