Fix git pull issue and unwrap error

fluere-plugin/src/downloader.rs

@@ -1,23 +1,33 @@
 use crate::util::home_cache_path;
-use std::process::Command;
+use git2::{Cred, FetchOptions, RemoteCallbacks, Repository};
 
 pub fn download_plugin_from_github(repo_name: &str) -> Result<(), std::io::Error> {
     let url = format!("https://github.com/{}.git", repo_name);
-    let path = home_cache_path();
-    let cd_cmd = format!("cd {}", path.display());
+    let path = home_cache_path().unwrap();
     if !path.exists() {
         std::fs::create_dir_all(path.clone())?;
     }
-    if path.join(repo_name.split('/').last().unwrap()).exists() {
-        Command::new("bash")
-            .arg("-c")
-            .arg(cd_cmd + ";git fetch ;git pull")
-            .output()?;
+    let repo_path = path.join(repo_name.split('/').last().unwrap());
+    if repo_path.exists() {
+        let mut callbacks = RemoteCallbacks::new();
+        callbacks.credentials(|_url, username_from_url, _allowed_types| {
+            Cred::ssh_key(
+                username_from_url.unwrap(),
+                None,
+                std::path::Path::new(&format!("{}/.ssh/id_rsa", std::env::var("HOME").unwrap())),
+                None,
+            )
+        });
+        let mut fetch_options = FetchOptions::new();
+        fetch_options.remote_callbacks(callbacks);
+        let repo = Repository::open(&repo_path)?;
+        repo.find_remote("origin")?
+            .fetch(&["master"], Some(&mut fetch_options), None)?;
+        let fetch_head = repo.find_reference("FETCH_HEAD")?;
+        let annotated = repo.reference_to_annotated_commit(&fetch_head)?;
+        repo.merge(&[&annotated], None, Some(&mut fetch_options))?;
     } else {
-        Command::new("bash")
-            .arg("-c")
-            .arg(cd_cmd + "; git clone " + &url)
-            .output()?;
+        Repository::clone(&url, &path)?;
     }
     Ok(())
 }

fluere-plugin/src/lib.rs

@@ -103,7 +103,7 @@ impl PluginManager {
                     None => {
                         match download_plugin_from_github(name) {
                             Ok(_) => {
-                                let path = home_cache_path().join(name.split('/').last().unwrap());
+                                let path = home_cache_path()?.join(name.split('/').last().unwrap());
                                 match std::fs::read_to_string(path.join("init.lua")) {
                                     Ok(code) => {
                                         let lua_clone = self.lua.clone();
@@ -124,8 +124,11 @@ impl PluginManager {
                                         let argument_table = lua.create_table()?;
 
                                         // println!("extra argument details{:?}", plugin_config.extra_arguments);
-                                        for (key, value) in
-                                            plugin_config.extra_arguments.clone().unwrap().iter()
+                                        for (key, value) in plugin_config
+                                            .extra_arguments
+                                            .clone()
+                                            .expect("not enough argument")
+                                            .iter()
                                         {
                                             argument_table.set(key.as_str(), value.as_str())?;
                                         }

fluere-plugin/src/util.rs

@@ -4,25 +4,32 @@ use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-pub fn home_cache_path() -> PathBuf {
+pub fn home_cache_path() -> Result<PathBuf, std::io::Error> {
     // Check for the SUDO_USER environment variable
     let sudo_user = env::var("SUDO_USER");
 
     let path_base = match sudo_user {
         Ok(user) => {
-            // If SUDO_USER is set, construct the path using the user's home directory
-            let user_home = format!("/home/{}", user);
-            Path::new(&user_home).join(".cache")
+            // on macOS just return the cache_dir()
+            if env::consts::OS == "macos" {
+                Ok(cache_dir().expect("Could not determine the home directory"))
+            } else {
+                // If SUDO_USER is set, construct the path using the user's home directory
+                let user_home = format!("/home/{}", user);
+                Ok(Path::new(&user_home).join(".cache"))
+            }
         }
         Err(_) => {
-            // If not running under sudo, just use the config_dir function as before
-            cache_dir().unwrap()
+            // If not running under sudo, just use the cache_dir function as before
+            cache_dir().ok_or(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                "Could not determine the cache directory",
+            ))
         }
     };
-
-    let path_config = path_base.join("fluere");
-    if !path_config.exists() {
-        fs::create_dir_all(path_config.clone()).unwrap();
+    let path_cache = path_base?.join("fluere");
+    if !path_cache.exists() {
+        fs::create_dir_all(path_cache.clone())?;
     }
-    path_config
+    Ok(path_cache)
 }

src/net/live_fluereflow.rs

@@ -509,7 +509,7 @@ fn draw_ui(
         flow_columns[5],
     );
 }
-async fn listen_for_exit_keys() -> Result<(),std::io::Error> {
+async fn listen_for_exit_keys() -> Result<(), std::io::Error> {
     loop {
         if event::poll(std::time::Duration::from_millis(100))? {
             if let event::Event::Key(KeyEvent {