Refactor Windows service to user session hidden window

Replaces the Windows Service implementation with a user session service that runs as a hidden window, suitable for use with Scheduled Tasks. Updates dependencies in Cargo.toml to include additional Windows API features. Adjusts install.ps1 to use the new service name and description reflecting the hidden window behavior.

Author: erdemgoksel

Cargo.toml

@@ -3,18 +3,13 @@ name = "beeper-automations"
 version = "0.1.0"
 edition = "2024"
 
-[[bin]]
-name = "auto-beeper-service"
-path = "src/bin/service.rs"
-
 [[bin]]
 name = "auto-beeper-configurator"
 path = "src/bin/configurator.rs"
 
 [[bin]]
 name = "auto-beeper-windows-service"
 path = "src/bin/windows_service.rs"
-required-features = ["windows-service"]
 
 [dependencies]
 beeper-desktop-api = "0.1.1"
@@ -36,7 +31,7 @@ user-idle2 = { git = "https://github.com/ErdemGKSL/user-idle2-rs.git", features
 
 [target.'cfg(windows)'.dependencies]
 windows-service = { version = "0.7", optional = true }
-windows = { version = "0.58", features = ["Win32"] }
+windows = { version = "0.58", features = ["Win32", "Win32_UI_WindowsAndMessaging", "Win32_System_Console"] }
 
 [features]
 windows-service = ["dep:windows-service"]

scripts/install.ps1

@@ -5,11 +5,11 @@ $ErrorActionPreference = "Stop"
 
 # Configuration
 $GITHUB_REPO = "ErdemGKSL/beeper-automations"
-$SERVICE_NAME = "auto-beeper-service"
+$SERVICE_NAME = "auto-beeper-windows-service"
 $CONFIGURATOR_NAME = "auto-beeper-configurator"
 $INSTALL_DIR = "$env:ProgramFiles\BeeperAutomations"
 $SCHEDULED_TASK_NAME = "BeeperAutomations"
-$SERVICE_DESCRIPTION = "Background service for Beeper automations (runs in user session)"
+$SERVICE_DESCRIPTION = "Background service for Beeper automations (runs in user session with hidden window)"
 
 # Color functions
 function Write-InfoMessage {

src/bin/windows_service.rs

@@ -1,205 +1,83 @@
 #![cfg(windows)]
 
-// Windows Service (Session 0) Implementation
-//
-// NOTE: Windows services run in Session 0 (non-interactive), which may prevent
-// proper user idle detection. For accurate idle detection, install as a User Service
-// via install-user-service.ps1, which runs in the interactive user session.
-//
-// The user idle detection code in is_user_active() includes a fallback that detects
-// Session 0 and assumes the user is active when running as a Windows service.
-
-use std::ffi::OsString;
-use std::time::Duration;
-use windows_service::{
-    define_windows_service,
-    service::{
-        ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,
-        ServiceType,
-    },
-    service_control_handler::{self, ServiceControlHandlerResult},
-    service_dispatcher,
-};
-
-const SERVICE_NAME: &str = "BeeperAutomations";
-const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
-
-// Use the shared logging function
-use beeper_automations::logging::log_to_file;
-
-define_windows_service!(ffi_service_main, service_main);
-
-fn write_crash_log(msg: &str) {
-    let log_path = std::env::var("PROGRAMDATA")
-        .unwrap_or_else(|_| "C:\\ProgramData".to_string())
-        + "\\BeeperAutomations\\service_crash.log";
-
-    let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
-
-    if let Ok(mut f) = std::fs::OpenOptions::new()
-        .create(true)
-        .write(true)
-        .append(true)
-        .open(&log_path)
-    {
-        use std::io::Write;
-        let _ = writeln!(f, "[{}] {}", timestamp, msg);
-    }
-}
-
-fn service_main(_arguments: Vec<OsString>) {
-    write_crash_log("service_main() called");
-
-    // Initialize tracing for Windows service mode BEFORE any other logging
-    beeper_automations::logging::init_logging(true);
-    log_to_file("Windows service wrapper started");
-
-    log_to_file("WARNING: Running as Windows Service (Session 0)");
-    log_to_file("WARNING: User idle detection may not work properly in service mode");
-    log_to_file("WARNING: For proper idle detection, install as User Service via install-user-service.ps1");
-
-    write_crash_log("Logging initialized, about to call run_service()");
-
-    if let Err(e) = run_service() {
-        let error_msg = format!("Service error: {}", e);
-        log_to_file(&error_msg);
-        log_to_file(&format!("Error details: {:?}", e));
-        write_crash_log(&error_msg);
+// Windows User Service (Hidden Window)
+// 
+// This binary runs the Beeper Automations service in the user's session
+// without showing a console window. It's designed to be used with Scheduled Tasks.
+
+// Hide the console window at startup
+#[cfg(windows)]
+fn hide_console_window() {
+    use windows::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_HIDE};
+    
+    unsafe {
+        let h_console = windows::Win32::System::Console::GetConsoleWindow();
+        if !h_console.is_invalid() {
+            let _ = ShowWindow(h_console, SW_HIDE);
+        }
     }
-
-    log_to_file("Windows service wrapper exiting");
-    write_crash_log("Windows service wrapper exiting");
 }
 
-fn run_service() -> windows_service::Result<()> {
-    log_to_file("run_service() called");
-
+async fn main_impl() -> anyhow::Result<()> {
+    use beeper_automations::logging::log_to_file;
+    
+    log_to_file("Beeper Automations User Service started (hidden window)");
+    
     // Set working directory to ProgramData
-    let work_dir = std::env::var("PROGRAMDATA").unwrap_or_else(|_| "C:\\ProgramData".to_string())
+    let work_dir = std::env::var("PROGRAMDATA")
+        .unwrap_or_else(|_| "C:\\ProgramData".to_string())
         + "\\BeeperAutomations";
 
-    log_to_file(&format!("Creating work directory: {}", work_dir));
+    log_to_file(&format!("Working directory: {}", work_dir));
+    
     if let Err(e) = std::fs::create_dir_all(&work_dir) {
-        let error_msg = format!("Failed to create work directory: {}", e);
-        log_to_file(&error_msg);
-        log_to_file(&format!("Error details: {:?}", e));
-        return Err(windows_service::Error::Winapi(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            error_msg,
-        )));
+        log_to_file(&format!("Failed to create work directory: {}", e));
     }
-
-    log_to_file(&format!("Setting working directory to: {}", work_dir));
+    
     if let Err(e) = std::env::set_current_dir(&work_dir) {
-        let error_msg = format!("Failed to set working directory: {}", e);
-        log_to_file(&error_msg);
-        log_to_file(&format!("Error details: {:?}", e));
-        return Err(windows_service::Error::Winapi(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            error_msg,
-        )));
-    } else {
-        log_to_file(&format!("Working directory set to: {}", work_dir));
+        log_to_file(&format!("Failed to set working directory: {}", e));
+        return Err(e.into());
     }
 
-    // Create a channel to handle service stop events
+    // Initialize file-based logging (no console output)
+    beeper_automations::logging::init_logging(true);
+    log_to_file("File logging initialized");
+
+    // Create shutdown channel for clean exit
     let (shutdown_tx, shutdown_rx) = tokio::sync::mpsc::channel::<()>(1);
 
-    // Define the service control handler
-    let event_handler = move |control_event| -> ServiceControlHandlerResult {
-        match control_event {
-            ServiceControl::Stop | ServiceControl::Shutdown => {
-                // Signal the service to stop
-                let _ = shutdown_tx.blocking_send(());
-                ServiceControlHandlerResult::NoError
+    // Set up Ctrl+C handler for graceful shutdown
+    #[cfg(windows)]
+    {
+        use tokio::signal::windows::ctrl_c;
+        let mut ctrl_c = ctrl_c()?;
+        
+        tokio::spawn(async move {
+            if ctrl_c.recv().await.is_some() {
+                let _ = shutdown_tx.send(()).await;
             }
-            ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
-            _ => ServiceControlHandlerResult::NotImplemented,
-        }
-    };
-
-    // Register the service control handler
-    let status_handle = service_control_handler::register(SERVICE_NAME, event_handler)?;
-
-    log_to_file("Service control handler registered");
-
-    // Tell Windows that the service is starting
-    status_handle.set_service_status(ServiceStatus {
-        service_type: SERVICE_TYPE,
-        current_state: ServiceState::StartPending,
-        controls_accepted: ServiceControlAccept::empty(),
-        exit_code: ServiceExitCode::Win32(0),
-        checkpoint: 0,
-        wait_hint: Duration::from_secs(0),
-        process_id: None,
-    })?;
-
-    // Create a Tokio runtime for the async service
-    let runtime = tokio::runtime::Runtime::new().map_err(|e| {
-        windows_service::Error::Winapi(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!("Failed to create Tokio runtime: {}", e),
-        ))
-    })?;
-
-    // Tell Windows that the service is running
-    status_handle.set_service_status(ServiceStatus {
-        service_type: SERVICE_TYPE,
-        current_state: ServiceState::Running,
-        controls_accepted: ServiceControlAccept::STOP | ServiceControlAccept::SHUTDOWN,
-        exit_code: ServiceExitCode::Win32(0),
-        checkpoint: 0,
-        wait_hint: Duration::from_secs(0),
-        process_id: None,
-    })?;
-
-    log_to_file("Service status set to Running");
-    log_to_file("About to call beeper_automations::run_service_with_shutdown()");
+        });
+    }
 
-    // Run the service and wait for shutdown signal
-    let result = runtime.block_on(async {
-        tokio::select! {
-            result = beeper_automations::run_service_with_shutdown(shutdown_rx) => {
-                if let Err(e) = result {
-                    log_to_file(&format!("Service error: {}", e));
-                    log_to_file(&format!("Error details: {:?}", e));
-                }
-                log_to_file("run_service_with_shutdown() RETURNED");
-            }
+    // Run the service
+    log_to_file("Starting service loop");
+    let result = beeper_automations::run_service_with_shutdown(shutdown_rx).await;
+    
+    match &result {
+        Ok(_) => log_to_file("Service stopped gracefully"),
+        Err(e) => {
+            log_to_file(&format!("Service error: {}", e));
+            log_to_file(&format!("Error details: {:?}", e));
         }
-    });
-
-    log_to_file(&format!("Service block_on completed with result: {:?}", result));
-
-    log_to_file("Service loop exited, initiating shutdown");
-
-    // Tell Windows that the service is stopping
-    status_handle.set_service_status(ServiceStatus {
-        service_type: SERVICE_TYPE,
-        current_state: ServiceState::StopPending,
-        controls_accepted: ServiceControlAccept::empty(),
-        exit_code: ServiceExitCode::Win32(0),
-        checkpoint: 0,
-        wait_hint: Duration::from_secs(0),
-        process_id: None,
-    })?;
-
-    // Tell Windows that the service has stopped
-    status_handle.set_service_status(ServiceStatus {
-        service_type: SERVICE_TYPE,
-        current_state: ServiceState::Stopped,
-        controls_accepted: ServiceControlAccept::empty(),
-        exit_code: ServiceExitCode::Win32(0),
-        checkpoint: 0,
-        wait_hint: Duration::from_secs(0),
-        process_id: None,
-    })?;
-
-    Ok(())
+    }
+    
+    result
 }
 
-fn main() -> windows_service::Result<()> {
-    // Register the service with Windows Service Control Manager
-    service_dispatcher::start(SERVICE_NAME, ffi_service_main)?;
-    Ok(())
+fn main() -> anyhow::Result<()> {
+    // Hide console window to avoid showing cmd popup
+    hide_console_window();
+    
+    let runtime = tokio::runtime::Runtime::new()?;
+    runtime.block_on(main_impl())
 }