Add self-updating support

Author: barely-a-dev

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "qud"
-version = "1.2.7"
+version = "1.2.8"
 edition = "2021"
 license = "GPL-3"
 authors = ["barely-a-dev"]

README.md

@@ -3,7 +3,7 @@
 `qud` is a command-line tool that **automatically detects and updates** various package managers across Linux, Windows,
 macOS, and more.
 
-> **Latest Version:** **v1.2.7**
+> **Latest Version:** **v1.2.8**
 
 ## Table of Contents
 
@@ -45,10 +45,9 @@ macOS, and more.
 git clone https://github.com/barely-a-dev/qud.git
 cd qud
 cargo build --release
+cp ./target/release/qud /usr/bin/qud
 ```
 
-Add `target/release/qud` to your `PATH`.
-
 ### Prebuilt Packages
 
 #### Arch Linux:
@@ -60,7 +59,7 @@ sudo pacman -U qud-<version>-x86_64.pkg.tar.zst
 #### Debian-based:
 
 ```bash
-sudo apt install ./qud_v1.2.7_amd64.deb
+sudo apt install ./qud_v1.2.8_amd64.deb
 ```
 
 ## Usage
@@ -175,7 +174,7 @@ Submit issues or pull requests on [GitHub](https://github.com/barely-a-dev/qud).
 
 ## Version
 
-**v1.2.7**
+**v1.2.8**
 
 For assistance, visit [GitHub](https://github.com/barely-a-dev/qud). Happy updating!
 

src/main.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::doc_markdown)]
 
+mod self_up;
+
 use pico_args::Arguments;
 use std::collections::{HashMap, HashSet};
 use std::env;
@@ -13,7 +15,8 @@ use walkdir::WalkDir;
 // Windows: choco, scoop, winget
 // General: rustup, brew, port (MacPorts), pkg (FreeBSD), cargo, npm, pip, composer, gem, conda, poetry, nuget, asdf, vcpkg, conan, stack, opam, mix, sdkman
 // gvm, pnpm, yarn, maven, go
-const PM: [&str; 45] = [
+// and qud itself.
+const PM: [&str; 46] = [
     "pacman",
     "yay",
     "apt",
@@ -59,6 +62,7 @@ const PM: [&str; 45] = [
     "cave",
     "sbopkg",
     "scratch",
+    "qud",
 ];
 
 /// Determines how to order package manager updates.
@@ -93,18 +97,31 @@ struct Config {
 }
 
 impl Config {
+    #[allow(clippy::too_many_lines)]
     fn parse_args() -> Config {
         let mut pargs = Arguments::from_env();
 
-        // Help and version.
+        // Help, version, and self updating.
         if pargs.contains(["-h", "--help"]) {
             Self::print_help();
             std::process::exit(0);
         }
         if pargs.contains(["-V", "--version"]) {
-            println!("qud v1.2.7");
+            println!("qud v1.2.8");
             std::process::exit(0);
         }
+        if pargs.contains(["-S", "--self-update"]) {
+            if !self_up::perm::is_elevated() {
+                eprintln!("Program must be run as root to update.");
+                std::process::exit(2);
+            }
+            println!("Updating qud...");
+            match self_up::self_update() {
+                Ok(()) => println!("qud updated successfully, exiting."),
+                Err(e) => eprintln!("qud failed to update: {e}, exiting."),
+            }
+            std::process::exit(-1);
+        }
 
         let dry_run = pargs.contains(["-d", "--dry"]);
         let excl_values: Vec<String> = pargs
@@ -195,7 +212,7 @@ impl Config {
 
     fn print_help() {
         println!(
-            r#"qud v1.2.7
+            r#"qud v1.2.8
 
 Usage:
   qud [options]
@@ -212,6 +229,7 @@ Options:
   --ord, -O [s]       Specify the update order. If provided a value (pm1,pm2,...), that order is used for those found; if no value is provided, you'll be prompted to sort.
   --help, -h          Show this help screen.
   --version, -V       Show version information.
+  --self-update, -S   Update qud.
 "#
         );
     }
@@ -795,6 +813,9 @@ fn process_pm(pm_name: &str, auto: bool, current_dir: &Path, extra_args: &[Strin
             };
             upd("scratch", args, true, extra_args, dry_run);
         }
+        "qud" => {
+            upd("qud", &["--self-update"], true, extra_args, dry_run);
+        }
         _ => eprintln!("\x1b[93mWarning:\x1b[0m Unknown package manager: {pm_name}"),
     }
 }

src/self_up.rs

@@ -0,0 +1,107 @@
+use std::{
+    error::Error,
+    fs,
+    path::PathBuf,
+    process::Command,
+};
+
+pub fn self_update() -> Result<(), Box<dyn Error>> {
+    let repo_url = "https://github.com/barely-a-dev/qud.git";
+
+    let temp_dir = std::env::temp_dir().join("qud_temp");
+    if temp_dir.exists() {
+        fs::remove_dir_all(&temp_dir)?;
+    }
+    fs::create_dir(&temp_dir)?;
+    let clone_path = temp_dir.join("qud");
+    println!("Cloning repository into {clone_path:?}");
+
+    let status = Command::new("git")
+        .args(["clone", repo_url, clone_path.to_str().unwrap()])
+        .status()?;
+    if !status.success() {
+        return Err("Git clone failed".into());
+    }
+
+    println!("Building project (release mode)...");
+    let status = Command::new("cargo")
+        .args(["build", "--release"])
+        .current_dir(&clone_path)
+        .status()?;
+    if !status.success() {
+        return Err("Cargo build failed".into());
+    }
+
+    // Determine the binary name based on the OS.
+    #[cfg(target_family = "windows")]
+    let binary_name = "qud.exe";
+    #[cfg(not(target_family = "windows"))]
+    let binary_name = "qud";
+
+    let binary_path = clone_path.join("target").join("release").join(binary_name);
+    if !binary_path.exists() {
+        return Err(format!("Built binary not found at {binary_path:?}").into());
+    }
+
+    #[cfg(not(target_family = "windows"))]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(&binary_path)?.permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&binary_path, perms)?;
+    }
+
+    #[cfg(not(target_family = "windows"))]
+    let install_path = PathBuf::from("/usr/bin/qud");
+
+    #[cfg(target_family = "windows")]
+    let install_path = {
+        let target_dir = PathBuf::from("C:\\Program Files\\qud");
+        fs::create_dir_all(&target_dir)?;
+        target_dir.join("qud.exe")
+    };
+
+    println!(
+        "Copying built binary from {binary_path:?} to {install_path:?}",
+    );
+    fs::copy(&binary_path, &install_path)?;
+
+    println!("Self-update successful!");
+
+    fs::remove_dir_all(&temp_dir)?;
+
+    Ok(())
+}
+
+pub mod perm {
+    #[cfg(not(target_family = "windows"))]
+    mod platform {
+        use std::os::raw::c_uint;
+
+        extern "C" {
+            fn geteuid() -> c_uint;
+        }
+
+        pub fn is_elevated() -> bool {
+            unsafe { geteuid() == 0 }
+        }
+    }
+
+    #[cfg(target_family = "windows")]
+    mod platform {
+        // Link to shell32.dll where IsUserAnAdmin is defined.
+        #[link(name = "shell32")]
+        extern "system" {
+            fn IsUserAnAdmin() -> i32;
+        }
+
+        pub fn is_elevated() -> bool {
+            // IsUserAnAdmin returns a nonzero value if the user is an administrator.
+            unsafe { IsUserAnAdmin() != 0 }
+        }
+    }
+
+    pub fn is_elevated() -> bool {
+        platform::is_elevated()
+    }
+}