feat: Windows portability — cross-platform RNG, HOME lookup, browser open (#11)

- ident.rs: mint Stable-Commit-Ids from `getrandom` (OS entropy on every
  platform — getrandom syscall / BCryptGenRandom) instead of reading
  `/dev/urandom`; the time/pid/counter fallback stays as a last resort.
- commands.rs: `home_dir()` now falls back to `USERPROFILE` when `HOME` is
  unset (Windows); all HOME lookups go through it. The man-page setup step is
  gated to non-Windows (`man` doesn't exist there); completion already no-ops
  when the shell can't be detected.
- view.rs: `open_url` gains a Windows arm (`cmd /C start`) alongside macOS
  (`open`) and other-unix (`xdg-open`).
- CI: a `windows-latest` job builds and runs the portable unit tests
  (ident/render/engine; the git-driven integration + view tests assume a POSIX
  shell and are skipped there).

Verified `cargo check --target x86_64-pc-windows-msvc --all-targets` compiles
cleanly (lib, bin, and tests). `make_executable` was already cfg(unix)-gated.

Author: freshtonic

.github/workflows/ci.yml

@@ -44,3 +44,19 @@ jobs:
       # they aren't covered here. The rest run against throwaway local repos.
       - name: Test
         run: cargo test --verbose
+
+  # Guard Windows portability: the code must compile and the pure unit tests
+  # (ident / render / engine) must pass. The git-driven integration and view
+  # tests assume a POSIX shell and aren't run here yet.
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Build
+        run: cargo build --verbose
+      - name: Test (portable unit tests)
+        run: cargo test --lib -- --skip view

Cargo.lock

@@ -22,6 +22,9 @@ anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 clap_complete = "4"
 clap_mangen = "0.2"
+# Cross-platform OS entropy for minting Stable-Commit-Ids (a thin wrapper over
+# each platform's RNG — getrandom syscall / BCryptGenRandom — no C deps).
+getrandom = "0.3"
 # The interactive `git queue tui` editor (ADR-0001). By far the project's
 # largest dependency; the domain logic lives in the headless `engine`, so the
 # TUI stack is confined to the thin `view` shell. crossterm is re-exported via

Cargo.toml

@@ -77,8 +77,11 @@ so reviewers see which PR merges next)",
     }
     // The next three steps are user-scoped (not repo-local), so they only run
     // interactively — never under a non-interactive `--yes`.
-    // 3. Man page.
-    if tty && confirm("Install the man page? (`man git-queue`, and `git queue --help`)", true) {
+    // 3. Man page (Unix only — Windows has no `man`).
+    if tty
+        && !cfg!(windows)
+        && confirm("Install the man page? (`man git-queue`, and `git queue --help`)", true)
+    {
         if let Err(e) = install_man_pages() {
             eprintln!("note: could not install the man page: {e:#}");
         }
@@ -114,8 +117,8 @@ so reviewers see which PR merges next)",
         }
     }
     // 6. Claude Code skill (only when Claude Code is present; interactive only).
-    let home = std::env::var("HOME").unwrap_or_default();
-    let claude_dir = std::path::Path::new(&home).join(".claude");
+    let home = home_dir();
+    let claude_dir = home.join(".claude");
     if tty
         && claude_dir.exists()
         && confirm(
@@ -138,7 +141,7 @@ git-queue correctly?",
         ("copilot", ".config/github-copilot"),
     ]
     .iter()
-    .filter(|(_, d)| std::path::Path::new(&home).join(d).exists())
+    .filter(|(_, d)| home.join(d).exists())
     .map(|(n, _)| *n)
     .collect();
     if tty
@@ -176,8 +179,7 @@ fn setup_undo() -> Result<()> {
         let _ = git::ok(&["config", "--global", "--unset", "alias.q"]);
         println!("Removed the `git q` alias.");
     }
-    let home = std::env::var("HOME").unwrap_or_default();
-    let skill = std::path::Path::new(&home).join(".claude/skills/using-git-queue/SKILL.md");
+    let skill = home_dir().join(".claude/skills/using-git-queue/SKILL.md");
     if skill.exists() {
         std::fs::remove_file(&skill).ok();
         println!("Removed {}.", skill.display());
@@ -186,8 +188,13 @@ fn setup_undo() -> Result<()> {
     Ok(())
 }
 
+/// The user's home directory, portably: `HOME` on unix, `USERPROFILE` on
+/// Windows.
 fn home_dir() -> std::path::PathBuf {
-    std::path::PathBuf::from(std::env::var("HOME").unwrap_or_default())
+    std::env::var_os("HOME")
+        .or_else(|| std::env::var_os("USERPROFILE"))
+        .map(std::path::PathBuf::from)
+        .unwrap_or_default()
 }
 
 /// The candidate `man1` directories, preferring a system-wide location.

src/commands.rs

@@ -23,17 +23,14 @@ pub fn new_id() -> String {
     encode(&random_bytes())
 }
 
-/// 128 bits of randomness: the OS pool when available, else a hash of
-/// high-resolution time, pid and a counter (uniqueness, not secrecy).
+/// 128 bits of randomness: the OS pool (cross-platform via `getrandom`), else a
+/// hash of high-resolution time, pid and a counter (uniqueness, not secrecy).
 fn random_bytes() -> [u8; 16] {
-    use std::io::Read;
     let mut out = [0u8; 16];
-    if let Ok(mut f) = std::fs::File::open("/dev/urandom") {
-        if f.read_exact(&mut out).is_ok() {
-            return out;
-        }
+    match getrandom::fill(&mut out) {
+        Ok(()) => out,
+        Err(_) => fallback_random(),
     }
-    fallback_random()
 }
 
 fn fallback_random() -> [u8; 16] {

src/ident.rs

@@ -573,15 +573,28 @@ impl App {
     }
 }
 
-/// Open `url` in the user's default browser (best-effort).
+/// Open `url` in the user's default browser (best-effort, cross-platform).
 fn open_url(url: &str) {
-    let opener = if cfg!(target_os = "macos") {
-        "open"
-    } else {
-        "xdg-open"
+    #[cfg(target_os = "windows")]
+    let mut cmd = {
+        // `start` is a cmd builtin; the empty "" is its (window-title) argument.
+        let mut c = std::process::Command::new("cmd");
+        c.args(["/C", "start", "", url]);
+        c
+    };
+    #[cfg(target_os = "macos")]
+    let mut cmd = {
+        let mut c = std::process::Command::new("open");
+        c.arg(url);
+        c
+    };
+    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+    let mut cmd = {
+        let mut c = std::process::Command::new("xdg-open");
+        c.arg(url);
+        c
     };
-    let _ = std::process::Command::new(opener)
-        .arg(url)
+    let _ = cmd
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
         .spawn();