feat: process paths passed to run

Signed-off-by: Oskar Manhart <[email protected]>

Author: oskardotglobal

Cargo.lock

@@ -11,10 +11,16 @@ fn cli() -> Command {
         .arg_required_else_help(true)
         .allow_external_subcommands(true)
         .subcommand(Command::new("connect").about("Opens full session on remote"))
+        .subcommand(Command::new("setup").about("Create desktop files for installed Windows apps"))
         .subcommand(
             Command::new("run")
                 .about("Runs a configured app or an executable on the remote")
-                .arg(arg!(NAME: "the name of the app/the path to the executable")),
+                .arg(arg!(<NAME> "the name of the app/the path to the executable"))
+                .arg(
+                    arg!([ARGS]... "Arguments to pass to the command")
+                        .trailing_var_arg(true)
+                        .allow_hyphen_values(true),
+                ),
         )
         .subcommand(
             Command::new("vm")
@@ -55,6 +61,11 @@ fn main() -> Result<()> {
     backend.check_depends()?;
 
     match matches.subcommand() {
+        Some(("setup", _)) => {
+            info!("Running setup");
+            todo!()
+        }
+
         Some(("connect", _)) => {
             info!("Connecting to remote");
 
@@ -65,9 +76,13 @@ fn main() -> Result<()> {
         Some(("run", sub_matches)) => {
             info!("Connecting to app on remote");
 
+            let args = sub_matches
+                .get_many::<String>("args")
+                .map_or(Vec::new(), |args| args.map(|v| v.to_owned()).collect());
+
             match sub_matches.get_one::<String>("name") {
                 None => panic!("App is required and should never be None here"),
-                Some(app) => client.run_app(app),
+                Some(app) => client.run_app(app.to_owned(), args),
             }?;
 
             Ok(())

winapps-cli/src/main.rs

@@ -16,3 +16,4 @@ miette = "7.2.0"
 thiserror = "2.0.9"
 enum_dispatch = "0.3.13"
 base64 = "0.22.1"
+regex = { version = "1.11.2", features = [] }

winapps/Cargo.toml

@@ -52,16 +52,4 @@ impl Backend for Container {
     fn get_host(&self) -> IpAddr {
         Ipv4Addr::new(127, 0, 0, 1).into()
     }
-
-    fn as_remote_command(&self, command: Command) -> Command {
-        Command::new("sshpass")
-            .args(["-p", &*self.config.auth.password])
-            .args([
-                "ssh",
-                &*format!("{}@localhost", self.config.auth.username),
-                "-p",
-                &*self.config.auth.ssh_port.to_string(),
-            ])
-            .arg(format!("{} {}", command.exec, command.args.join(" ")))
-    }
 }

winapps/src/backend/container.rs

@@ -1,6 +1,6 @@
 use std::{net::IpAddr, str::FromStr};
 
-use crate::{command::Command, ensure, Backend, Config, Error, Result};
+use crate::{ensure, Backend, Config, Error, Result};
 
 #[derive(Debug, Clone)]
 pub struct Manual {
@@ -35,16 +35,4 @@ impl Backend for Manual {
         // so it should always be valid at this point
         IpAddr::from_str(&self.config.manual.host).unwrap()
     }
-
-    fn as_remote_command(&self, command: Command) -> Command {
-        Command::new("sshpass")
-            .args(["-p", &*self.config.auth.password])
-            .args([
-                "ssh",
-                &*format!("{}@{}", self.config.auth.username, self.config.manual.host),
-                "-p",
-                &*self.config.auth.ssh_port.to_string(),
-            ])
-            .arg(format!("{} {}", command.exec, command.args.join(" ")))
-    }
 }

winapps/src/backend/manual.rs

@@ -17,8 +17,6 @@ pub trait Backend {
     fn check_depends(&self) -> Result<()>;
 
     fn get_host(&self) -> IpAddr;
-
-    fn as_remote_command(&self, command: Command) -> Command;
 }
 
 #[enum_dispatch(Backend)]
@@ -48,13 +46,9 @@ impl Config {
         self.get_backend().get_host()
     }
 
-    pub fn as_remote_command(&'static self, command: Command) -> Command {
-        self.get_backend().as_remote_command(command)
-    }
-
     fn get_installed_apps(&'static self) -> Result<Vec<App>> {
         let apps = Command::new("C:\\ExtractPrograms.ps1")
-            .into_remote(self.get_backend())
+            .into_remote(self)
             .wait_with_output()?
             .lines()
             .filter_map(|line| {

winapps/src/backend/mod.rs

@@ -1,4 +1,4 @@
-use crate::{ensure, Backend, Backends, Error, IntoResult, Result};
+use crate::{ensure, Backend, Backends, Config, Error, IntoResult, Result};
 use std::{
     fmt::{Display, Formatter},
     process::{Child, Command as StdCommand, Stdio},
@@ -60,8 +60,23 @@ impl Command {
         }
     }
 
-    pub fn into_remote(self, backend: &Backends) -> Self {
-        backend.as_remote_command(self)
+    pub fn into_remote(mut self, config: &'static Config) -> Self {
+        let prev = format!("{} {}", self.exec, self.args.join(" "));
+
+        self.exec = "sshpass".to_string();
+        self.clear_args()
+            .args(["-p", &*config.auth.password])
+            .args([
+                "ssh",
+                &*format!(
+                    "{}@{}",
+                    config.auth.username,
+                    config.get_backend().get_host()
+                ),
+                "-p",
+                &*config.auth.ssh_port.to_string(),
+            ])
+            .arg(prev)
     }
 
     pub fn with_err(mut self, message: &'static str) -> Self {

winapps/src/command.rs

@@ -5,8 +5,6 @@ use crate::{bail, dirs::path_ok, Config, Error, IntoResult, Result};
 
 impl Config {
     /// Reads the config from disk.
-    ///
-    /// Panics if this is called a second time after already returning an `Ok`.
     pub fn load() -> Result<&'static Config> {
         static CONFIG: OnceLock<Config> = OnceLock::new();
 

winapps/src/config/operations.rs

@@ -1,11 +1,12 @@
+use crate::{bail, command::Command, Config, Error, RemoteClient, Result};
+use regex::Regex;
 use std::{
     net::{SocketAddr, TcpStream},
+    path::{Path, PathBuf},
     time::Duration,
 };
 use tracing::info;
 
-use crate::{command::Command, Config, Error, RemoteClient, Result};
-
 pub struct Freerdp {
     config: &'static Config,
 }
@@ -51,17 +52,39 @@ impl RemoteClient for Freerdp {
         Ok(())
     }
 
-    fn run_app(&self, app_name: &str) -> Result<()> {
+    fn run_app(&self, app_name: String, args: Vec<String>) -> Result<()> {
         let path = self
             .config
             .linked_apps
             .iter()
-            .filter_map(|app| app.id.eq(app_name).then_some(app.win_exec.clone()))
+            .filter_map(|app| app.id.eq(&app_name).then_some(app.win_exec.clone()))
             .next()
-            .unwrap_or(app_name.to_string());
+            .unwrap_or(app_name);
+
+        let Some(home_regex) = dirs::home_dir().map(|home| {
+            Regex::new(&format!(
+                "^{}",
+                home.into_os_string()
+                    .into_string()
+                    .expect("$HOME should always be a valid string")
+            ))
+            .expect("'^$HOME' should always be a valid regex")
+        }) else {
+            bail!("Couldn't find $HOME")
+        };
 
         self.get_command()
             .arg(format!("/app:program:{path}"))
+            .args(args.iter().map(|arg| {
+                if arg.contains("/") && home_regex.is_match(arg) {
+                    home_regex
+                        .replace(arg, r"\\tsclient\\media")
+                        .to_string()
+                        .replace("/", r"\")
+                } else {
+                    arg.to_owned()
+                }
+            }))
             .spawn()
             .map(|_| ())
     }

winapps/src/remote_client/freerdp.rs

@@ -5,7 +5,7 @@ pub(crate) mod freerdp;
 pub trait RemoteClient {
     fn check_depends(&self) -> Result<()>;
 
-    fn run_app(&self, exec: &str) -> Result<()>;
+    fn run_app(&self, exec: String, args: Vec<String>) -> Result<()>;
 
     fn run_full_session(&self) -> Result<()>;
 }