feat: Add Windows x64 build target (#98)

* feat: Add Windows x64 build target support

- Add Windows x86_64 (MSVC) target to release workflow matrix
- Skip protoc setup on Windows (TPU support is Linux-only)
- Add Windows-specific binary packaging using PowerShell
- Add Windows-specific SHA256 checksum generation
- Add Windows process priority handler in process_list.rs

Closes #97

* fix: Update WMI crate API usage for Windows build compatibility

- Update wmi crate 0.18.0 API: remove COMLibrary usage
- WMIConnection::new() no longer takes COM argument
- WMIConnection::with_namespace_path() takes only namespace path
- Simplify process_list.rs Windows priority handling

The wmi 0.18.0 release removed COMLibrary and simplified the API.
This fix updates cpu_windows.rs and amd_windows.rs to use the new API.

Author: inureyes

.github/workflows/release.yml

@@ -68,6 +68,14 @@ jobs:
             archive_ext: ".zip"
             protoc_platform: osx-aarch_64
 
+          # Windows x86_64
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
+            artifact_name: all-smi.exe
+            asset_name: all-smi-windows-x86_64
+            archive_ext: ".zip"
+            protoc_platform: ""  # Not needed for Windows (TPU is Linux-only)
+
     env:
       BIN_NAME: all-smi
       BUNDLE_ID: ${{ vars.BUNDLE_ID }}
@@ -117,8 +125,9 @@ jobs:
           sudo apt update
           sudo apt install -y libdrm-dev libdrm-amdgpu1
 
-      # 6) Setup protoc (cached)
+      # 6) Setup protoc (cached) - skip on Windows as TPU support is Linux-only
       - name: Setup protoc
+        if: runner.os != 'Windows'
         uses: ./.github/actions/setup-protoc
         with:
           version: ${{ env.PROTOC_VERSION }}
@@ -163,8 +172,19 @@ jobs:
           cp docs/man/all-smi.1 package/
           ditto -c -k --sequesterRsrc package "$ASSET"
 
+      - name: Package Windows binary (zip)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $BIN = "target/${{ matrix.target }}/release/${{ matrix.artifact_name }}"
+          $ASSET = "${{ matrix.asset_name }}.zip"
+          New-Item -ItemType Directory -Force -Path package
+          Copy-Item $BIN -Destination package/
+          Compress-Archive -Path package/* -DestinationPath $ASSET
+
       # 10) Generate checksum
-      - name: Generate checksum
+      - name: Generate checksum (Linux/macOS)
+        if: runner.os != 'Windows'
         run: |
           FILE="${{ matrix.asset_name }}${{ matrix.archive_ext }}"
           if [[ "$RUNNER_OS" == "Linux" ]]; then
@@ -173,6 +193,14 @@ jobs:
             shasum -a 256 "$FILE" > "$FILE.sha256"
           fi
 
+      - name: Generate checksum (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $FILE = "${{ matrix.asset_name }}${{ matrix.archive_ext }}"
+          $hash = (Get-FileHash -Path $FILE -Algorithm SHA256).Hash.ToLower()
+          "$hash  $FILE" | Out-File -FilePath "$FILE.sha256" -Encoding ASCII -NoNewline
+
       # 11) Upload release artifacts and checksum
       - name: Upload release artifacts
         if: github.event_name == 'release' || github.event_name == 'workflow_dispatch'

src/device/cpu_windows.rs

@@ -20,7 +20,7 @@ use chrono::Local;
 use serde::Deserialize;
 use std::sync::RwLock;
 use sysinfo::{CpuRefreshKind, System};
-use wmi::{COMLibrary, WMIConnection};
+use wmi::WMIConnection;
 
 // WMI structures for thermal zone temperature
 #[derive(Deserialize, Debug)]
@@ -49,17 +49,12 @@ fn with_cimv2_connection<T, F: FnOnce(&WMIConnection) -> T>(f: F) -> Option<T> {
     WMI_CIMV2_CONNECTION.with(|cell| {
         let mut conn_ref = cell.borrow_mut();
         if conn_ref.is_none() {
-            match COMLibrary::new() {
-                Ok(com) => match WMIConnection::new(com) {
-                    Ok(wmi_con) => {
-                        *conn_ref = Some(wmi_con);
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to create WMI CIMV2 connection: {e}");
-                    }
-                },
+            match WMIConnection::new() {
+                Ok(wmi_con) => {
+                    *conn_ref = Some(wmi_con);
+                }
                 Err(e) => {
-                    eprintln!("Failed to initialize COM library for CIMV2: {e}");
+                    eprintln!("Failed to create WMI CIMV2 connection: {e}");
                 }
             }
         }
@@ -72,17 +67,12 @@ fn with_root_wmi_connection<T, F: FnOnce(&WMIConnection) -> T>(f: F) -> Option<T
     WMI_ROOT_WMI_CONNECTION.with(|cell| {
         let mut conn_ref = cell.borrow_mut();
         if conn_ref.is_none() {
-            match COMLibrary::new() {
-                Ok(com) => match WMIConnection::with_namespace_path("root\\WMI", com) {
-                    Ok(wmi_con) => {
-                        *conn_ref = Some(wmi_con);
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to create WMI root\\WMI connection: {e}");
-                    }
-                },
+            match WMIConnection::with_namespace_path("root\\WMI") {
+                Ok(wmi_con) => {
+                    *conn_ref = Some(wmi_con);
+                }
                 Err(e) => {
-                    eprintln!("Failed to initialize COM library for root\\WMI: {e}");
+                    eprintln!("Failed to create WMI root\\WMI connection: {e}");
                 }
             }
         }

src/device/process_list.rs

@@ -250,7 +250,11 @@ fn get_process_priority_nice(pid: u32) -> (i32, i32) {
         }
     }
 
-    // Default values if unable to retrieve
+    // On Windows, process priority is managed differently than Unix systems.
+    // Windows uses priority classes (Idle, Below Normal, Normal, Above Normal, High, Realtime)
+    // rather than nice values. The sysinfo crate doesn't expose priority directly.
+    // Return default values as Unix-style nice values don't apply to Windows.
+    // Default values if unable to retrieve (for Windows or any other OS)
     (20, 0)
 }
 

src/device/readers/amd_windows.rs

@@ -24,7 +24,7 @@ use crate::utils::get_hostname;
 use chrono::Local;
 use serde::Deserialize;
 use std::collections::HashMap;
-use wmi::{COMLibrary, WMIConnection};
+use wmi::WMIConnection;
 
 // Thread-local WMI connection for reuse within the same thread
 thread_local! {
@@ -36,17 +36,12 @@ fn with_wmi_connection<T, F: FnOnce(&WMIConnection) -> T>(f: F) -> Option<T> {
     WMI_CONNECTION.with(|cell| {
         let mut conn_ref = cell.borrow_mut();
         if conn_ref.is_none() {
-            match COMLibrary::new() {
-                Ok(com) => match WMIConnection::new(com) {
-                    Ok(wmi_con) => {
-                        *conn_ref = Some(wmi_con);
-                    }
-                    Err(e) => {
-                        eprintln!("AMD GPU: Failed to create WMI connection: {e}");
-                    }
-                },
+            match WMIConnection::new() {
+                Ok(wmi_con) => {
+                    *conn_ref = Some(wmi_con);
+                }
                 Err(e) => {
-                    eprintln!("AMD GPU: Failed to initialize COM library: {e}");
+                    eprintln!("AMD GPU: Failed to create WMI connection: {e}");
                 }
             }
         }
@@ -208,29 +203,7 @@ impl GpuReader for AmdWindowsGpuReader {
 /// Check if AMD GPU is present on Windows using WMI
 /// Note: This creates its own WMI connection since detection may run on a different thread
 pub fn has_amd_gpu_windows() -> bool {
-    // Try multiple COM initialization strategies
-    // Strategy 1: Try normal COM initialization
-    let com = match COMLibrary::new() {
-        Ok(c) => Some(c),
-        Err(e) => {
-            // Strategy 2: Try without_security for already-initialized COM
-            match COMLibrary::without_security() {
-                Ok(c) => Some(c),
-                Err(e2) => {
-                    eprintln!(
-                        "AMD GPU detection: Failed to initialize COM library: {e}, fallback: {e2}"
-                    );
-                    None
-                }
-            }
-        }
-    };
-
-    let Some(com) = com else {
-        return false;
-    };
-
-    let wmi_con = match WMIConnection::new(com) {
+    let wmi_con = match WMIConnection::new() {
         Ok(w) => w,
         Err(e) => {
             eprintln!("AMD GPU detection: Failed to create WMI connection: {e}");