fix: Windows build errors in daemon and CLI

- Add Windows support to granaryd.rs with named pipes and Ctrl+C handling
- Move Stdio import inside #[cfg(unix)] block in auto_start.rs
- Add #[cfg_attr] to suppress unused variable warnings on Windows in run.rs

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

Author: danielkov

src/bin/granaryd.rs

@@ -21,6 +21,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use tokio::select;
+#[cfg(unix)]
 use tokio::signal::unix::{SignalKind, signal};
 use tracing_appender::non_blocking::WorkerGuard;
 
@@ -66,13 +67,27 @@ async fn main() -> anyhow::Result<()> {
     }
 
     // Start IPC listener
-    let socket_path = global_config_service::daemon_socket_path()?;
-    let listener = IpcListener::bind(&socket_path).await?;
+    #[cfg(unix)]
+    #[allow(unused_mut)] // Windows needs mut for accept(), Unix doesn't
+    let mut listener = {
+        let socket_path = global_config_service::daemon_socket_path()?;
+        let listener = IpcListener::bind(&socket_path).await?;
+        tracing::info!("granaryd listening on {:?}", listener.socket_path());
+        listener
+    };
 
-    tracing::info!("granaryd listening on {:?}", listener.socket_path());
+    #[cfg(windows)]
+    let mut listener = {
+        let pipe_name = global_config_service::daemon_pipe_name();
+        let listener = IpcListener::bind(&pipe_name).await?;
+        tracing::info!("granaryd listening on {}", listener.pipe_name());
+        listener
+    };
 
     // Set up signal handlers
+    #[cfg(unix)]
     let mut sigterm = signal(SignalKind::terminate())?;
+    #[cfg(unix)]
     let mut sigint = signal(SignalKind::interrupt())?;
 
     // Flag to track shutdown request from IPC
@@ -95,7 +110,8 @@ async fn main() -> anyhow::Result<()> {
         _ => {}
     }
 
-    // Main loop
+    // Main loop - Unix version with SIGTERM/SIGINT handling
+    #[cfg(unix)]
     loop {
         // Check if shutdown was requested via IPC
         if shutdown_flag.load(std::sync::atomic::Ordering::SeqCst) {
@@ -147,6 +163,55 @@ async fn main() -> anyhow::Result<()> {
         }
     }
 
+    // Main loop - Windows version with Ctrl+C handling
+    #[cfg(windows)]
+    loop {
+        // Check if shutdown was requested via IPC
+        if shutdown_flag.load(std::sync::atomic::Ordering::SeqCst) {
+            tracing::info!("Shutdown requested via IPC");
+            break;
+        }
+
+        select! {
+            // Handle Ctrl+C
+            _ = tokio::signal::ctrl_c() => {
+                tracing::info!("Received Ctrl+C, shutting down...");
+                break;
+            }
+
+            // Periodic log cleanup
+            _ = cleanup_interval.tick() => {
+                match manager.cleanup_old_logs(&log_retention_config) {
+                    Ok(deleted) if deleted > 0 => {
+                        tracing::info!("Periodic log cleanup: deleted {} old log files", deleted);
+                    }
+                    Err(e) => {
+                        tracing::warn!("Periodic log cleanup failed: {}", e);
+                    }
+                    _ => {}
+                }
+            }
+
+            // Accept new connections
+            result = listener.accept() => {
+                match result {
+                    Ok(conn) => {
+                        let manager = Arc::clone(&manager);
+                        let shutdown_flag = Arc::clone(&shutdown_flag);
+                        tokio::spawn(async move {
+                            if let Err(e) = handle_connection(conn, &manager, &shutdown_flag).await {
+                                tracing::error!("Connection error: {}", e);
+                            }
+                        });
+                    }
+                    Err(e) => {
+                        tracing::error!("Accept error: {}", e);
+                    }
+                }
+            }
+        }
+    }
+
     // Graceful shutdown
     tracing::info!("Shutting down workers...");
     manager.shutdown_all().await?;

src/cli/run.rs

@@ -378,6 +378,7 @@ enum Signal {
 }
 
 /// Check if a process is alive by using kill -0
+#[cfg_attr(not(unix), allow(unused_variables))]
 fn is_process_alive(pid: u32) -> bool {
     #[cfg(unix)]
     {
@@ -397,6 +398,7 @@ fn is_process_alive(pid: u32) -> bool {
 }
 
 /// Send a signal to a process
+#[cfg_attr(not(unix), allow(unused_variables))]
 fn send_signal(pid: u32, signal: Signal) {
     #[cfg(unix)]
     {

src/daemon/auto_start.rs

@@ -4,7 +4,7 @@
 //! commands need it. It handles automatic daemon startup with exponential
 //! backoff retry logic.
 
-use std::process::{Command, Stdio};
+use std::process::Command;
 use std::time::Duration;
 use tokio::time::sleep;
 
@@ -69,6 +69,8 @@ pub async fn ensure_daemon() -> Result<DaemonClient> {
 /// sets up its own logging to `~/.granary/daemon/daemon.log`.
 #[cfg(unix)]
 fn spawn_daemon() -> Result<()> {
+    use std::process::Stdio;
+
     // Find the granaryd binary - it should be next to the granary binary
     let current_exe = std::env::current_exe()?;
     let daemon_path = current_exe.with_file_name("granaryd");