Fix auto-update, installer, and UI bugs (v0.1.1)

- Fix auto-update applying to wrong exe when run from non-installed location
- Skip background update check after applying update to prevent double download
- Remove unnecessary UAC elevation for install/update (LOCALAPPDATA is user-writable)
- Fix process info dialog background color inconsistency
- Fetch exe path on-demand for process info dialog
- Exclude System Idle Process (PID 0) from CPU utilization
- Improve process info dialog layout and styling

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: faratech

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "htop-win"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 description = "A Windows clone of htop - interactive process viewer"
 authors = ["htop-win contributors"]
@@ -27,7 +27,6 @@ windows = { version = "0.61", features = [
     "Win32_NetworkManagement_IpHelper",
     "Win32_NetworkManagement_Ndis",
     "Win32_UI_Shell",
-    "Win32_UI_WindowsAndMessaging",
     "Win32_System_Com",
     "Wdk_System_SystemInformation",
 ] }

src/app.rs

@@ -798,6 +798,14 @@ impl App {
             let (io_read, io_write) = crate::system::get_process_io_counters(proc.pid);
             proc_copy.io_read_bytes = io_read;
             proc_copy.io_write_bytes = io_write;
+            // Query exe path on-demand if not already available
+            if proc_copy.exe_path.is_empty() {
+                let exe_path = crate::system::get_process_exe_path(proc.pid);
+                if !exe_path.is_empty() {
+                    proc_copy.exe_path = exe_path.clone();
+                    proc_copy.command = exe_path;
+                }
+            }
             self.process_info_target = Some(proc_copy);
             self.view_mode = ViewMode::ProcessInfo;
         }

src/installer.rs

@@ -3,82 +3,6 @@
 use std::fs;
 use std::path::PathBuf;
 
-#[cfg(windows)]
-use windows::core::{PCWSTR, w};
-#[cfg(windows)]
-use windows::Win32::Foundation::{CloseHandle, HANDLE, HWND};
-#[cfg(windows)]
-use windows::Win32::Security::{GetTokenInformation, TokenElevation, TOKEN_ELEVATION, TOKEN_QUERY};
-#[cfg(windows)]
-use windows::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
-#[cfg(windows)]
-use windows::Win32::UI::Shell::ShellExecuteW;
-#[cfg(windows)]
-use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNORMAL;
-
-/// Check if running as administrator
-#[cfg(windows)]
-pub fn is_admin() -> bool {
-    unsafe {
-        let mut token = HANDLE::default();
-        if OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token).is_ok() {
-            let mut elevation = TOKEN_ELEVATION::default();
-            let mut size = 0u32;
-            let result = GetTokenInformation(
-                token,
-                TokenElevation,
-                Some(&mut elevation as *mut _ as *mut _),
-                std::mem::size_of::<TOKEN_ELEVATION>() as u32,
-                &mut size,
-            );
-            let _ = CloseHandle(token);
-            result.is_ok() && elevation.TokenIsElevated != 0
-        } else {
-            false
-        }
-    }
-}
-
-#[cfg(not(windows))]
-pub fn is_admin() -> bool {
-    false
-}
-
-/// Re-launch the current process with UAC elevation
-#[cfg(windows)]
-pub fn elevate_with_args(args: &str) -> Result<(), Box<dyn std::error::Error>> {
-    let exe_path = std::env::current_exe()?;
-    let exe_path_wide: Vec<u16> = exe_path
-        .to_string_lossy()
-        .encode_utf16()
-        .chain(std::iter::once(0))
-        .collect();
-    let args_wide: Vec<u16> = format!("{}\0", args).encode_utf16().collect();
-
-    let result = unsafe {
-        ShellExecuteW(
-            Some(HWND::default()),
-            w!("runas"),
-            PCWSTR(exe_path_wide.as_ptr()),
-            PCWSTR(args_wide.as_ptr()),
-            PCWSTR::null(),
-            SW_SHOWNORMAL,
-        )
-    };
-
-    // ShellExecuteW returns > 32 on success
-    if result.0 as usize > 32 {
-        Ok(())
-    } else {
-        Err("Failed to elevate privileges".into())
-    }
-}
-
-#[cfg(not(windows))]
-pub fn elevate_with_args(_args: &str) -> Result<(), Box<dyn std::error::Error>> {
-    Err("UAC elevation is only supported on Windows".into())
-}
-
 /// Get the installation path for htop
 pub fn get_install_path() -> Result<PathBuf, Box<dyn std::error::Error>> {
     let local_app_data = std::env::var("LOCALAPPDATA")?;
@@ -109,17 +33,8 @@ pub fn get_installed_version() -> Option<String> {
 }
 
 /// Install htop-win to a PATH directory so it can be run from anywhere
+/// Installs to %LOCALAPPDATA%\Microsoft\WindowsApps which is user-writable and already in PATH
 pub fn install_to_path(force: bool) -> Result<(), Box<dyn std::error::Error>> {
-    if !is_admin() {
-        // Re-launch with UAC elevation
-        println!("Requesting administrator privileges...");
-        let args = if force { "--install --force" } else { "--install" };
-        elevate_with_args(args)?;
-        println!("Elevated process launched. Check that window for results.");
-        return Ok(());
-    }
-
-    // We're running as admin - do the installation
     let current_exe = std::env::current_exe()?;
     let current_version = env!("CARGO_PKG_VERSION");
     let target_path = get_install_path()?;
@@ -245,7 +160,6 @@ fn download_file(url: &str, dest: &std::path::Path) -> Result<(), Box<dyn std::e
 fn cleanup_temp_files() {
     let temp_dir = std::env::temp_dir();
     let _ = fs::remove_file(temp_dir.join("htop-win-update.exe"));
-    let _ = fs::remove_file(temp_dir.join("htop-win-update-path.txt"));
 }
 
 /// Update htop-win from GitHub releases
@@ -281,19 +195,7 @@ pub fn update_from_github(force: bool) -> Result<(), Box<dyn std::error::Error>>
 
     println!("Download complete. Installing...");
 
-    // Need admin to install to WindowsApps
-    if !is_admin() {
-        // Copy temp file path to a location the elevated process can access
-        let update_marker = temp_dir.join("htop-win-update-path.txt");
-        fs::write(&update_marker, temp_file.to_string_lossy().as_bytes())?;
-
-        println!("Requesting administrator privileges...");
-        elevate_with_args("--install-update")?;
-        println!("Elevated process launched. Check that window for results.");
-        return Ok(());
-    }
-
-    // We're admin - do the actual install
+    // Install directly - %LOCALAPPDATA%\Microsoft\WindowsApps is user-writable
     do_install_update(&temp_file)
 }
 
@@ -340,24 +242,6 @@ pub fn do_install_update(update_file: &std::path::Path) -> Result<(), Box<dyn st
     Ok(())
 }
 
-/// Complete an update installation (called when elevated with --install-update)
-pub fn complete_update_install() -> Result<(), Box<dyn std::error::Error>> {
-    let temp_dir = std::env::temp_dir();
-    let update_marker = temp_dir.join("htop-win-update-path.txt");
-
-    let update_path = fs::read_to_string(&update_marker)?;
-    let update_file = PathBuf::from(update_path.trim());
-
-    // Clean up marker file
-    let _ = fs::remove_file(&update_marker);
-
-    if !update_file.exists() {
-        return Err("Update file not found".into());
-    }
-
-    do_install_update(&update_file)
-}
-
 /// Update status for background updates
 #[derive(Clone)]
 pub enum UpdateStatus {
@@ -418,24 +302,20 @@ pub fn apply_pending_update() -> bool {
     let temp_dir = std::env::temp_dir();
     let update_file = temp_dir.join("htop-win-update.exe");
 
+    // Get the currently running executable - this is what we need to update
+    let current_exe = match std::env::current_exe() {
+        Ok(p) => p,
+        Err(_) => return false,
+    };
+
     if !update_file.exists() {
         // Clean up any old backup files from previous updates
-        let install_path = match get_install_path() {
-            Ok(p) => p,
-            Err(_) => return false,
-        };
-        let backup_path = install_path.with_extension("exe.old");
+        let backup_path = current_exe.with_extension("exe.old");
         let _ = fs::remove_file(&backup_path);
         return false;
     }
 
-    let install_path = match get_install_path() {
-        Ok(p) => p,
-        Err(_) => {
-            let _ = fs::remove_file(&update_file);
-            return false;
-        }
-    };
+    let install_path = current_exe;
 
     // If install path doesn't exist, just copy directly
     if !install_path.exists() {

src/main.rs

@@ -41,7 +41,6 @@ struct Args {
     inefficient: bool,
     install: bool,
     update: bool,
-    install_update: bool,
     force: bool,
 }
 
@@ -121,9 +120,6 @@ fn parse_args() -> Result<Args, lexopt::Error> {
             Long("update") => {
                 args.update = true;
             }
-            Long("install-update") => {
-                args.install_update = true;
-            }
             Long("force") | Short('f') => {
                 args.force = true;
             }
@@ -333,17 +329,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    if args.install_update {
-        // Called from elevated process to complete update installation
-        if let Err(e) = installer::complete_update_install() {
-            eprintln!("Update installation failed: {}", e);
-            std::process::exit(1);
-        }
-        return Ok(());
-    }
-
     // Apply any pending update before starting (downloaded in previous session)
-    installer::apply_pending_update();
+    let update_just_applied = installer::apply_pending_update();
 
     // Enable Efficiency Mode by default (reduces CPU usage via EcoQoS)
     if !args.inefficient {
@@ -449,8 +436,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create benchmark stats if in benchmark mode
     let mut bench_stats = benchmark_mode.map(|_| BenchmarkStats::new());
 
-    // Spawn background update check
-    let update_rx = installer::spawn_update_check();
+    // Spawn background update check (skip if we just applied an update, since
+    // the running binary is still the old version and would re-download)
+    let update_rx = if update_just_applied {
+        // Create a dummy channel that never sends anything
+        let (_, rx) = std::sync::mpsc::channel();
+        rx
+    } else {
+        installer::spawn_update_check()
+    };
 
     // Run the main loop
     let result = run_app(&mut terminal, &mut app, &config, bench_stats.as_mut(), update_rx);

src/system/mod.rs

@@ -9,8 +9,9 @@ mod process;
 pub use cpu::CpuInfo;
 pub use memory::{format_bytes, MemoryInfo};
 pub use process::{
-    enable_debug_privilege, enrich_processes, get_process_affinity, get_process_io_counters,
-    kill_process, set_efficiency_mode, set_priority_class, set_process_affinity, ProcessInfo,
+    enable_debug_privilege, enrich_processes, get_process_affinity, get_process_exe_path,
+    get_process_io_counters, kill_process, set_efficiency_mode, set_priority_class,
+    set_process_affinity, ProcessInfo,
 };
 #[cfg(windows)]
 pub use native::{query_all_processes, calculate_cpu_percentages};

src/system/native.rs

@@ -190,6 +190,12 @@ pub fn calculate_cpu_percentages(
     let cache_snapshot = CACHE.snapshot();
 
     for proc in processes.iter() {
+        // System Idle Process (PID 0) represents idle CPU time, not actual work
+        if proc.pid == 0 {
+            cpu_percentages.insert(0, 0.0);
+            continue;
+        }
+
         let total_time = proc.kernel_time + proc.user_time;
 
         let cpu_percent = if let Some(entry) = cache_snapshot.get(&proc.pid) {

src/system/process.rs

@@ -317,6 +317,23 @@ pub fn get_process_io_counters(_pid: u32) -> (u64, u64) {
     (0, 0)
 }
 
+/// Get executable path for a specific process (on-demand, for ProcessInfo dialog)
+#[cfg(windows)]
+pub fn get_process_exe_path(pid: u32) -> String {
+    let handle = match open_process_query(pid) {
+        Some(h) => h,
+        None => return String::new(),
+    };
+    let result = query_exe_path(handle);
+    unsafe { let _ = CloseHandle(handle); }
+    result
+}
+
+#[cfg(not(windows))]
+pub fn get_process_exe_path(_pid: u32) -> String {
+    String::new()
+}
+
 /// Enriched data from Windows API for visible processes
 #[cfg(windows)]
 struct EnrichedProcessData {