feat: allow uninstalling apps

Signed-off-by: Oskar Manhart <52569953+oskardotglobal@users.noreply.github.com>

Author: oskardotglobal

winapps-cli/src/main.rs

@@ -1,8 +1,11 @@
+use std::collections::HashSet;
+
 use clap::{Command, arg};
+use inquire::MultiSelect;
 use miette::{IntoDiagnostic, Result};
-use tracing::{Level, info};
+use tracing::{Level, debug, info};
 use tracing_subscriber::EnvFilter;
-use winapps::{Config, Freerdp, RemoteClient};
+use winapps::{Config, Freerdp, RemoteClient, config::App};
 
 fn cli() -> Command {
     Command::new("winapps-cli")
@@ -26,8 +29,6 @@ fn cli() -> Command {
 
 fn main() -> Result<()> {
     tracing_subscriber::fmt()
-        .without_time()
-        .with_target(false)
         .with_level(true)
         .with_max_level(Level::INFO)
         .with_env_filter(EnvFilter::from_default_env())
@@ -45,16 +46,41 @@ fn main() -> Result<()> {
         Some(("setup", _)) => {
             info!("Running setup");
 
-            // TODO: Allow deleting apps, maybe pass installed apps
-            // so they can be deselected?
-            match inquire::MultiSelect::new("Select apps to link", config.get_available_apps()?)
+            let available = config.get_available_apps()?;
+            let installed: Vec<usize> = available
+                .iter()
+                .enumerate()
+                .filter_map(|(i, app)| config.linked_apps.contains_key(&app.id).then_some(i))
+                .collect();
+
+            debug!(
+                "{} apps available, {} apps installed",
+                available.len(),
+                config.linked_apps.len()
+            );
+
+            match MultiSelect::new("Select apps to link", available)
+                .with_default(installed.as_slice())
+                .with_page_size(20)
                 .prompt_skippable()
                 .map_err(|e| winapps::Error::Command {
                     message: "Failed to display selection dialog".into(),
                     source: e.into(),
                 })? {
-                Some(apps) => apps.into_iter().try_for_each(|app| app.link(&mut config))?,
-                None => info!("No apps selected, skipping setup..."),
+                Some(apps) => {
+                    let selected: HashSet<App> = apps.into_iter().collect();
+                    let installed: HashSet<App> = config.linked_apps.values().cloned().collect();
+
+                    for app in selected.symmetric_difference(&installed).cloned() {
+                        match (selected.contains(&app), installed.contains(&app)) {
+                            (true, false) => app.link(&mut config)?,
+                            (false, true) => app.unlink(&mut config)?,
+                            (false, false) => (),
+                            (true, true) => unreachable!(),
+                        }
+                    }
+                }
+                None => info!("No apps (de-)selected, skipping setup..."),
             };
 
             Ok(())

winapps/src/backend/container.rs

@@ -34,7 +34,7 @@ impl Backend for Container {
         .with_err("Could not get container status")
         .wait_with_output()?;
 
-        debug!("{command} returned state: {state}");
+        debug!("{command} returned state: {}", state.trim());
         ensure!(state.trim() == Self::STATE_RUNNING, Error::VmNotRunning);
 
         Ok(())

winapps/src/backend/mod.rs

@@ -61,7 +61,15 @@ impl Config {
         self.backend.get_host(self)
     }
 
+    fn normalize_app_id(input: String) -> String {
+        input
+            .strip_suffix(".exe")
+            .map(|s| s.to_string())
+            .unwrap_or(input)
+    }
+
     pub fn get_available_apps(&self) -> Result<Vec<App>> {
+        // todo: stronger parsing, better errors
         let apps = Command::new("C:\\ExtractPrograms.ps1")
             .into_remote(self)
             .wait_with_output()?
@@ -71,11 +79,14 @@ impl Config {
 
                 match (split.next(), split.next(), split.next(), split.next()) {
                     (Some(id), Some(name), Some(path), Some(icon)) => Some(App {
-                        id: id.to_string(),
+                        id: Self::normalize_app_id(id.to_string()),
                         name: name.to_string(),
                         win_exec: path.to_string(),
                         kind: AppKind::FromBase64(icon.to_string()),
                     }),
+
+                    // Skip ids ending in .dll for now
+                    (Some(id), _, _, _) if id.ends_with(".dll") => None,
                     _ => None,
                 }
             })

winapps/src/command.rs

@@ -1,5 +1,5 @@
 use crate::{Config, Error, IntoResult, Result, bail, ensure};
-use shlex::{split, try_join};
+use shlex::split;
 use std::{
     fmt::{Display, Formatter},
     iter,
@@ -35,29 +35,25 @@ impl FromStr for Command {
             bail!("Commands should have an executable")
         };
 
-        Ok(Self {
-            exec,
-            args: items.collect(),
-            error_message: String::from("Error running child command"),
-            loud: false,
-        })
+        Ok(Command::new(exec).args(items))
     }
 }
 
 impl Command {
-    pub fn new<T: Into<String>>(exec: T) -> Self {
+    pub fn new<T: Into<String> + Display>(exec: T) -> Self {
         Self {
+            error_message: format!("Error running child command {}", &exec),
             exec: exec.into(),
             args: Vec::new(),
-            error_message: String::from("Error running child command"),
             loud: false,
         }
     }
 
     pub fn into_remote(mut self, config: &Config) -> Self {
-        let prev =
-            try_join(iter::once(self.exec.as_str()).chain(self.args.iter().map(|s| s.as_str())))
-                .expect("Since this has been created by shlex::join, it should always be valid");
+        let prev = iter::once(self.exec)
+            .chain(self.args.iter().cloned())
+            .collect::<Vec<String>>()
+            .join(" ");
 
         self.exec = "sshpass".to_string();
         self.clear_args()
@@ -66,6 +62,7 @@ impl Command {
                 "ssh",
                 format!("{}@{}", config.auth.username, config.get_host()).as_str(),
                 "-oStrictHostKeyChecking=accept-new",
+                "-oWarnWeakCrypto=no-pq-kex",
                 "-p",
                 config.auth.ssh_port.to_string().as_str(),
             ])
@@ -137,17 +134,15 @@ impl Command {
             message: self.error_message.clone(),
         })?;
 
+        let stdout = String::from_utf8_lossy_owned(output.stdout);
+
+        debug!("Got stdout: {stdout}");
         debug!(
-            "Child exit code is zero, returning output {} {}",
-            output.stdout.len(),
-            output.stderr.len()
+            "Got stderr: {}",
+            String::from_utf8_lossy_owned(output.stderr)
         );
 
-        Ok(format!(
-            "{}\n{}",
-            String::from_utf8(output.stdout).expect("Commands should always return valid utf-8"),
-            String::from_utf8(output.stderr).expect("Commands should always return valid utf-8")
-        ))
+        Ok(stdout)
     }
 }
 

winapps/src/config/apps.rs

@@ -5,15 +5,23 @@ use crate::{
     ensure,
 };
 use base64::{Engine, prelude::BASE64_STANDARD};
-use std::{fmt::Display, fs::write};
-use tracing::debug;
+use std::{fmt::Display, fs, os::unix::fs::PermissionsExt};
+use tracing::{debug, warn};
 
 impl PartialEq for App {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
+impl Eq for App {}
+
+impl std::hash::Hash for App {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
 impl Display for App {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.write_fmt(format_args!("{} ({})", self.name, self.win_exec))
@@ -32,7 +40,7 @@ impl App {
         match &self.kind {
             AppKind::FromBase64(base64) => {
                 let path = icons_dir()?.join(format!("{}.png", self.id));
-                write(path.clone(), BASE64_STANDARD.decode(base64)?)?;
+                fs::write(path.clone(), BASE64_STANDARD.decode(base64)?)?;
 
                 self.kind = AppKind::Existing;
 
@@ -72,21 +80,33 @@ Comment={} (WinApps)",
 
         let path = desktop_dir()?.join(format!("{}.desktop", self.id));
 
-        write(&path, self.try_as_desktop_file()?)?;
+        fs::write(&path, self.try_as_desktop_file()?)?;
+        fs::set_permissions(&path, PermissionsExt::from_mode(0o750))?;
 
-        if !config.linked_apps.contains(&self) {
+        if !config.linked_apps.contains_key(&self.id) {
             debug!("Writing app {} to config", self.id);
 
-            config.linked_apps.push(self);
+            config.linked_apps.insert(self.id.clone(), self);
             config.save()?;
         }
 
         Ok(())
     }
-}
 
-impl Config {
-    pub fn find_linked_app(&self, id: String) -> Option<&App> {
-        self.linked_apps.iter().find(|app| app.id == id)
+    pub fn unlink(self, config: &mut Config) -> Result<()> {
+        let path = desktop_dir()?.join(format!("{}.desktop", self.id));
+
+        fs::remove_file(&path).unwrap_or_else(|_| {
+            warn!(
+                "Could not delete desktop file for {} ({})",
+                self.id,
+                path.to_string_lossy()
+            )
+        });
+
+        debug!("Removing app {} to config", self.id);
+
+        config.linked_apps.remove_entry(&self.id);
+        config.save()
     }
 }

winapps/src/config/mod.rs

@@ -1,6 +1,6 @@
 use derive_new::new;
-use serde::{Deserialize, Serialize};
-use std::net::IpAddr;
+use serde::{Deserialize, Deserializer, Serialize};
+use std::{collections::HashMap, net::IpAddr};
 
 use crate::Backends;
 
@@ -19,8 +19,9 @@ pub struct Config {
     pub manual: ManualConfig,
     #[new(value = "FreerdpConfig::new()")]
     pub freerdp: FreerdpConfig,
-    #[new(value = "Vec::new()")]
-    pub linked_apps: Vec<App>,
+    #[new(value = "HashMap::new()")]
+    #[serde(deserialize_with = "deserialize_apps")]
+    pub linked_apps: HashMap<String, App>,
     #[new(value = "false")]
     pub debug: bool,
 
@@ -92,9 +93,25 @@ pub enum AppKind {
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct App {
-    pub id: String,
     pub name: String,
     pub win_exec: String,
+
+    #[serde(skip)]
+    pub id: String,
+
     #[serde(skip)]
     pub kind: AppKind,
 }
+
+fn deserialize_apps<'de, D>(deserializer: D) -> Result<HashMap<String, App>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let mut apps = HashMap::<String, App>::deserialize(deserializer)?;
+
+    for (id, app) in apps.iter_mut() {
+        app.id = id.clone();
+    }
+
+    Ok(apps)
+}

winapps/src/lib.rs

@@ -1,7 +1,8 @@
 #![allow(clippy::new_without_default)]
+#![warn(clippy::unwrap_used)]
 #![feature(decl_macro)]
 #![feature(exit_status_error)]
-#![feature(once_cell_try)]
+#![feature(string_from_utf8_lossy_owned)]
 
 pub use crate::{
     backend::{Backend, Backends},

winapps/src/remote_client/freerdp.rs

@@ -48,9 +48,8 @@ impl RemoteClient for Freerdp {
     fn run_app(self, config: &Config, app_name: String, args: Vec<String>) -> Result<()> {
         let path = config
             .linked_apps
-            .iter()
-            .filter_map(|app| app.id.eq(&app_name).then_some(app.win_exec.clone()))
-            .next()
+            .get(&app_name)
+            .map(|app| app.win_exec.clone())
             .unwrap_or(app_name);
 
         let Some(home_regex) = dirs::home_dir().map(|home| {