fix(harness-monitor): add Windows support with TCP fallback

- Use conditional compilation for Unix socket (only on Unix platforms)
- On Windows, RuntimeSocket is not available, automatically fallback to TCP
- send_socket_message returns error on Windows, triggering TCP fallback
- socket_reachable returns false on Windows
- This ensures Windows builds succeed while maintaining Unix socket on Unix/macOS

Fixes Windows compilation error in GitHub Actions release workflow

Author: phodal

crates/harness-monitor/src/main.rs

@@ -8,7 +8,9 @@ mod run;
 mod shared;
 mod ui;
 
-use crate::observe::ipc::{RuntimeSocket, RuntimeTcp};
+#[cfg(unix)]
+use crate::observe::ipc::RuntimeSocket;
+use crate::observe::ipc::RuntimeTcp;
 use crate::observe::Snapshot;
 use crate::observe::{resolve, resolve_runtime};
 use crate::shared::db::Db;
@@ -293,7 +295,11 @@ fn run_watch(
 }
 
 fn run_serve(ctx: &crate::observe::repo::RepoContext) -> Result<()> {
+    #[cfg(unix)]
     let socket_server = RuntimeSocket::bind(&ctx.runtime_socket_path).ok();
+    #[cfg(not(unix))]
+    let socket_server: Option<()> = None;
+
     let tcp_server = if socket_server.is_none() {
         RuntimeTcp::bind(&ctx.runtime_tcp_addr).ok()
     } else {
@@ -327,6 +333,7 @@ fn run_serve(ctx: &crate::observe::repo::RepoContext) -> Result<()> {
             },
         )?;
 
+        #[cfg(unix)]
         if let Some(server) = &socket_server {
             for message in server.read_pending()? {
                 crate::observe::ipc::send_message(&ctx.runtime_event_path, &message)?;

crates/harness-monitor/src/observe/ipc.rs

@@ -3,6 +3,7 @@ use anyhow::{Context, Result};
 use std::fs::OpenOptions;
 use std::io::{BufRead, BufReader, Seek, SeekFrom, Write};
 use std::net::{TcpListener, TcpStream};
+#[cfg(unix)]
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -85,10 +86,12 @@ impl RuntimeFeed {
     }
 }
 
+#[cfg(unix)]
 pub struct RuntimeSocket {
     listener: UnixListener,
 }
 
+#[cfg(unix)]
 impl RuntimeSocket {
     pub fn bind(socket_path: &Path) -> Result<Self> {
         if let Some(parent) = socket_path.parent() {
@@ -172,6 +175,7 @@ pub fn send_message(event_path: &Path, message: &RuntimeMessage) -> Result<()> {
     Ok(())
 }
 
+#[cfg(unix)]
 pub fn send_socket_message(socket_path: &Path, message: &RuntimeMessage) -> Result<()> {
     let mut stream = UnixStream::connect(socket_path)
         .with_context(|| format!("connect runtime socket {:?}", socket_path))?;
@@ -183,6 +187,11 @@ pub fn send_socket_message(socket_path: &Path, message: &RuntimeMessage) -> Resu
     Ok(())
 }
 
+#[cfg(not(unix))]
+pub fn send_socket_message(_socket_path: &Path, _message: &RuntimeMessage) -> Result<()> {
+    anyhow::bail!("Unix sockets are not supported on this platform")
+}
+
 pub fn send_tcp_message(addr: &str, message: &RuntimeMessage) -> Result<()> {
     let mut stream =
         TcpStream::connect(addr).with_context(|| format!("connect runtime tcp {addr}"))?;
@@ -194,10 +203,16 @@ pub fn send_tcp_message(addr: &str, message: &RuntimeMessage) -> Result<()> {
     Ok(())
 }
 
+#[cfg(unix)]
 pub fn socket_reachable(socket_path: &Path) -> bool {
     socket_path.exists() && UnixStream::connect(socket_path).is_ok()
 }
 
+#[cfg(not(unix))]
+pub fn socket_reachable(_socket_path: &Path) -> bool {
+    false
+}
+
 pub fn tcp_reachable(addr: &str) -> bool {
     addr.parse()
         .ok()
@@ -227,6 +242,7 @@ pub fn read_service_info(info_path: &Path) -> Result<Option<RuntimeServiceInfo>>
     Ok(Some(info))
 }
 
+#[cfg(unix)]
 fn read_stream_message(stream: UnixStream) -> Result<Option<RuntimeMessage>> {
     let mut reader = BufReader::new(stream);
     let mut line = String::new();

crates/harness-monitor/src/observe/mod.rs

@@ -11,7 +11,9 @@ pub mod repo;
 // Re-export commonly used types at this module level
 pub use self::detect::{calculate_stats, scan_agents};
 pub use self::hooks::{handle_git_event, handle_hook, parse_stdin_payload};
-pub use self::ipc::{RuntimeFeed, RuntimeSocket, RuntimeTcp};
+#[cfg(unix)]
+pub use self::ipc::RuntimeSocket;
+pub use self::ipc::{RuntimeFeed, RuntimeTcp};
 pub use self::observe::{
     entry_kind_for_path, entry_kind_for_repo_path, poll_repo, scan_repo, Snapshot,
 };