fix(build): restore Windows compile and add windows CI job

.github/workflows/ci.yml

@@ -27,3 +27,17 @@ jobs:
       - run: rm -rf .cargo
       - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
       - run: mise run ci
+
+  windows-build:
+    runs-on: windows-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          submodules: true
+      - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+      # `cargo check` (debug) catches the compile errors that otherwise only
+      # surface in the release pipeline, without paying for an optimized link.
+      # Integration tests under tests/ are Unix-only (lsof, pkill, etc.) so
+      # we limit the check to lib + bins.
+      - run: cargo check --lib --bins --all-features

src/config_types.rs

@@ -197,13 +197,32 @@ impl JsonSchema for CpuLimit {
 #[serde(try_from = "String")]
 pub struct StopSignal(i32);
 
+// Signal numbers. On Unix we pull them from `libc` so they match the platform
+// (SIGUSR1/2 differ between Linux and BSD/macOS). On Windows the values are
+// only used for parsing and Display — `procs::kill` ignores `stop_signal` and
+// uses TerminateProcess via sysinfo — so POSIX-typical Linux values are fine.
+#[cfg(unix)]
+use libc::{SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGUSR1, SIGUSR2};
+#[cfg(windows)]
+const SIGHUP: i32 = 1;
+#[cfg(windows)]
+const SIGINT: i32 = 2;
+#[cfg(windows)]
+const SIGQUIT: i32 = 3;
+#[cfg(windows)]
+const SIGTERM: i32 = 15;
+#[cfg(windows)]
+const SIGUSR1: i32 = 10;
+#[cfg(windows)]
+const SIGUSR2: i32 = 12;
+
 const SIGNAL_TABLE: &[(&str, i32)] = &[
-    ("HUP", libc::SIGHUP),
-    ("INT", libc::SIGINT),
-    ("QUIT", libc::SIGQUIT),
-    ("TERM", libc::SIGTERM),
-    ("USR1", libc::SIGUSR1),
-    ("USR2", libc::SIGUSR2),
+    ("HUP", SIGHUP),
+    ("INT", SIGINT),
+    ("QUIT", SIGQUIT),
+    ("TERM", SIGTERM),
+    ("USR1", SIGUSR1),
+    ("USR2", SIGUSR2),
 ];
 
 impl StopSignal {
@@ -218,7 +237,7 @@ impl StopSignal {
 
 impl Default for StopSignal {
     fn default() -> Self {
-        Self(libc::SIGTERM)
+        Self(SIGTERM)
     }
 }
 

src/deps.rs

@@ -244,7 +244,7 @@ pub fn compute_reverse_stop_order_with_config(
 mod tests {
     use super::*;
     use crate::daemon_id::DaemonId;
-    use crate::pitchfork_toml::{PitchforkTomlDaemon, Retry};
+    use crate::pitchfork_toml::PitchforkTomlDaemon;
     use indexmap::IndexMap;
 
     // Helper to build a test daemon with only `depends` set, all other fields default/None.

src/main.rs

@@ -26,6 +26,7 @@ mod watch_files;
 mod web;
 
 pub use miette::Result;
+#[cfg(unix)]
 use tokio::signal;
 #[cfg(unix)]
 use tokio::signal::unix::SignalKind;

src/procs.rs

@@ -1,4 +1,5 @@
 use crate::Result;
+#[cfg(unix)]
 use crate::settings::settings;
 use miette::IntoDiagnostic;
 use once_cell::sync::Lazy;
@@ -212,11 +213,12 @@ impl Procs {
 
         #[cfg(windows)]
         {
+            let _ = (stop_signal, stop_timeout);
             if let Some(process) = self.lock_system().process(sysinfo_pid) {
                 process.kill();
                 process.wait();
             }
-            return Ok(true);
+            Ok(true)
         }
 
         #[cfg(unix)]

src/proxy/server.rs

@@ -464,9 +464,9 @@ pub fn generate_ca(cert_path: &std::path::Path, key_path: &std::path::Path) -> c
     // Using OpenOptions + mode() so the file is never world-readable,
     // even briefly before a chmod call.
     {
-        use std::io::Write;
         #[cfg(unix)]
         {
+            use std::io::Write;
             use std::os::unix::fs::OpenOptionsExt;
             std::fs::OpenOptions::new()
                 .write(true)
@@ -809,9 +809,9 @@ impl SniCertResolver {
         let disk_path = self.host_certs_dir.join(format!("{safe_name}.pem"));
         let combined_pem = format!("{}{}", leaf_cert.pem(), key_pem);
         {
-            use std::io::Write;
             #[cfg(unix)]
             {
+                use std::io::Write;
                 use std::os::unix::fs::OpenOptionsExt;
                 if let Err(e) = std::fs::OpenOptions::new()
                     .write(true)

src/state_file.rs

@@ -249,7 +249,6 @@ fn normalized_lock_path(path: &Path) -> PathBuf {
 mod tests {
     use super::*;
     use crate::daemon_status::DaemonStatus;
-    use crate::pitchfork_toml::Retry;
 
     #[test]
     fn test_state_file_toml_roundtrip_stopped() {

src/supervisor/mod.rs

@@ -12,6 +12,7 @@ mod autostop;
 mod hooks;
 mod ipc_handlers;
 mod lifecycle;
+#[cfg(unix)]
 mod pty;
 mod retry;
 mod state;
@@ -29,7 +30,9 @@ use crate::{Result, env};
 use duct::cmd;
 use miette::IntoDiagnostic;
 use once_cell::sync::Lazy;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
+#[cfg(unix)]
+use std::collections::HashSet;
 use std::fs;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;

src/supervisor/pty.rs

@@ -23,7 +23,6 @@ pub struct PtyPair {
 /// practice — the extra fd is simply unused — but if strict
 /// close-on-exec semantics are needed, set `FD_CLOEXEC` manually via
 /// `fcntl(fd, F_SETFD, FD_CLOEXEC)`.
-#[cfg(unix)]
 pub fn openpty() -> std::io::Result<PtyPair> {
     let mut master_fd: libc::c_int = -1;
     let mut slave_fd: libc::c_int = -1;

src/web/routes/logs.rs

@@ -389,6 +389,7 @@ pub async fn stream_sse(
         let mut file_handle: Option<std::fs::File> = None;
 
         // Internal result type for file operations within spawn_blocking
+        #[allow(dead_code)] // FileRotated is constructed only on Unix
         enum FileOpResult {
             Data(Vec<u8>),
             Truncated,
@@ -417,8 +418,10 @@ pub async fn stream_sse(
                 let fh = file_handle.take();
                 let mut ls = last_size;
                 let prev_ino = last_path_ino;
+                #[cfg_attr(not(unix), allow(unused_variables))]
                 let poll_count = poll_count;
                 tokio::task::spawn_blocking(move || {
+                    #[cfg_attr(not(unix), allow(unused_variables))]
                     let opened_fresh = fh.is_none();
                     let mut file = match fh {
                         Some(f) => f,