Commands fixes + New commands

2023-05-01 04:24:06 +05:00 · 2023-05-01 04:24:06 +05:00 · fc764c0c85
commit fc764c0c85
parent 1033840325
60 changed files with 404 additions and 103 deletions
--- a/src-tauri/src/assistant_commands.rs
+++ b/src-tauri/src/assistant_commands.rs
@ -7,8 +7,7 @@ use log::{info, warn, error};

 use core::time::Duration;
 use std::path::PathBuf;
-use std::process::Child;
-use std::process::Command;
+use std::process::{Command, Child};
 // use tauri::Manager;

 mod structs;
@ -34,14 +33,16 @@ pub fn parse_commands() -> Result<Vec<AssistantCommand>, String> {
                let cc_yaml: CommandsList;

                // try parse command.yaml
-                if let Ok(parse_result) = serde_yaml::from_reader::<File, CommandsList>(cc_reader) {
-                    cc_yaml = parse_result;
-                } else {
-                    warn!("Can't parse {}, skipping ...", &cc_file.display());
-                    continue;
-                    // return Err(format!("Can't parse {}", &cc_file.display()));
+                match serde_yaml::from_reader::<File, CommandsList>(cc_reader) {
+                    Ok(parse_result) => {
+                        cc_yaml = parse_result;
+                    },
+                    Err(msg) => {
+                        warn!("Can't parse {}, skipping ...\nCommand parse error is: {:?}", &cc_file.display(), msg);
+                        eprintln!("Can't parse {}, skipping ...\nCommand parse error is: {:?}", &cc_file.display(), msg);
+                        continue;
+                    }
                }
-
                // everything seems to be Ok
                commands.push(AssistantCommand {
                    path: _cpath,
@ -109,11 +110,30 @@ pub fn execute_exe(exe: &str, args: &Vec<String>) -> std::io::Result<Child> {
    Command::new(exe).args(args).spawn()
 }

+pub fn execute_cli(cmd: &str, args: &Vec<String>) -> std::io::Result<Child> {
+
+    println!("Spawning cmd as: cmd /C {} {:?}", cmd, args);
+
+    if cfg!(target_os = "windows") {
+        Command::new("cmd")
+                .arg("/C")
+                .arg(cmd)
+                .args(args)
+                .spawn()
+    } else {
+        Command::new("sh")
+                .arg("-c")
+                .arg(cmd)
+                .args(args)
+                .spawn()
+    }
+}
+
 pub fn execute_command(
    cmd_path: &PathBuf,
    cmd_config: &Config,
    app_handle: &tauri::AppHandle,
-) -> Result<(), String> {
+) -> Result<bool, String> {
    match cmd_config.command.action.as_str() {
        "voice" => {
            // VOICE command type
@ -124,7 +144,7 @@ pub fn execute_command(
                .unwrap();
            events::play(random_cmd_sound, app_handle);

-            Ok(())
+            Ok(true)
        }
        "ahk" => {
            // AutoHotkey command type
@ -146,7 +166,7 @@ pub fn execute_command(
                    .unwrap();
                events::play(random_cmd_sound, app_handle);

-                Ok(())
+                Ok(true)
            } else {
                error!("AHK process spawn error (does exe path is valid?)");
                Err("AHK process spawn error (does exe path is valid?)".into())
@ -154,28 +174,26 @@ pub fn execute_command(
        }
        "cli" => {
            // CLI command type
-            let exe_path_absolute = Path::new(&cmd_config.command.exe_path);
-            let exe_path_local = Path::new(&cmd_path).join(&cmd_config.command.exe_path);
+            let cli_cmd = &cmd_config.command.cli_cmd;

-            if let Ok(_) = execute_exe(
-                if exe_path_absolute.exists() {
-                    exe_path_absolute.to_str().unwrap()
-                } else {
-                    exe_path_local.to_str().unwrap()
-                },
-                &cmd_config.command.exe_args,
+            match execute_cli(
+                cli_cmd,
+                &cmd_config.command.cli_args,
            ) {
-                let random_cmd_sound = cmd_config
-                    .voice
-                    .sounds
-                    .choose(&mut rand::thread_rng())
-                    .unwrap();
-                events::play(random_cmd_sound, app_handle);
+                    Ok(_) => {
+                        let random_cmd_sound = cmd_config
+                        .voice
+                        .sounds
+                        .choose(&mut rand::thread_rng())
+                        .unwrap();
+                    events::play(random_cmd_sound, app_handle);

-                Ok(())
-            } else {
-                error!("Shell process spawn error (does cli command is valid?)");
-                Err("Shell process spawn error (does cli command is valid?)".into())
+                    Ok(true)
+                },
+                Err(msg) => {
+                    error!("CLI command error ({})", msg);
+                    Err(format!("Shell command error ({})", msg).into())
+                }
            }
        }
        "terminate" => {
@ -190,6 +208,17 @@ pub fn execute_command(
            std::thread::sleep(Duration::from_secs(2));
            std::process::exit(0);
        }
+        "stop_chaining" => {
+            // STOP_CHAINING command type
+            let random_cmd_sound = cmd_config
+                .voice
+                .sounds
+                .choose(&mut rand::thread_rng())
+                .unwrap();
+            events::play(random_cmd_sound, app_handle);
+
+            Ok(false)
+        }
        _ => {
            error!("Command type unknown");
            Err("Command type unknown".into())
--- a/src-tauri/src/assistant_commands/structs.rs
+++ b/src-tauri/src/assistant_commands/structs.rs
@ -15,18 +15,32 @@ pub struct CommandsList {
 #[derive(Deserialize, Debug)]
 pub struct Config {
    pub command: ConfigCommandSection,
+
    pub voice: ConfigVoiceSection,
+
    pub phrases: Vec<String>,
 }

 #[derive(Deserialize, Debug)]
 pub struct ConfigCommandSection {
    pub action: String,
+
+    #[serde(default)]
    pub exe_path: String,
+
+    #[serde(default)]
    pub exe_args: Vec<String>,
+
+    #[serde(default)]
+    pub cli_cmd: String,
+
+    #[serde(default)]
+    pub cli_args: Vec<String>
 }

 #[derive(Deserialize, Debug)]
 pub struct ConfigVoiceSection {
+
+    #[serde(default)]
    pub sounds: Vec<String>,
 }
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@ -24,7 +24,7 @@ pub const AUTHOR_NAME: Option<&str> = option_env!("CARGO_PKG_AUTHORS");
 pub const REPOSITORY_LINK: Option<&str> = option_env!("CARGO_PKG_REPOSITORY");

 // RUSPOTTER
-pub const RUSPOTTER_MIN_SCORE: f32 = 0.64;
+pub const RUSPOTTER_MIN_SCORE: f32 = 0.62;

 // PICOVOICE
 pub const COMMANDS_PATH: &str = "commands/";
--- a/src-tauri/src/recorder.rs
+++ b/src-tauri/src/recorder.rs
@ -111,17 +111,6 @@ pub fn stop_recording() {
    }
 }

-// pub fn update_selected_microphone_index() -> i32 {
-//     let selected_microphone: i32 = get_selected_microphone_index();
-
-//     // store current microphone idx
-//     SELECTED_MICROPHONE_IDX.store(selected_microphone, Ordering::SeqCst);
-
-//     // return microphone index
-//     info!("Selected microphone index = {selected_microphone}");
-//     selected_microphone
-// }
-
 pub fn get_selected_microphone_index() -> i32 {
    let selected_microphone: i32;

--- a/src-tauri/src/tauri_commands/listener.rs
+++ b/src-tauri/src/tauri_commands/listener.rs
@ -1,4 +1,5 @@
 use porcupine::{Porcupine, PorcupineBuilder};
+use std::ops::Sub;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::path::Path;
 use log::{info, warn, error};
@ -149,9 +150,17 @@ fn keyword_callback(_keyword_index: i32) {
                    );

                    match cmd_result {
-                        Ok(_) => {
+                        Ok(chain) => {
                            println!("Command executed successfully!");
-                            start = SystemTime::now(); // listen for more commands
+
+                            if chain {
+                                // continue chaining commands
+                                start = SystemTime::now(); // listen for more commands
+                            } else {
+                                // skip forward if chaining is not required
+                                start = start.checked_sub(core::time::Duration::from_secs(1000)).unwrap();
+                            }
+
                            continue;
                        }
                        Err(error_message) => {
@ -317,7 +326,7 @@ fn rustpotter_init() -> Result<bool, String> {
            avg_threshold: 0.,
            threshold: 0.5,
            min_scores: 15,
-            score_mode: ScoreMode::Max,
+            score_mode: ScoreMode::Average,
            comparator_band_size: 5,
            comparator_ref: 0.22
        },
@ -325,7 +334,7 @@ fn rustpotter_init() -> Result<bool, String> {
            gain_normalizer: GainNormalizationConfig {
                enabled: true,
                gain_ref: None,
-                min_gain: 0.5,
+                min_gain: 0.7,
                max_gain: 1.0,
            },
            band_pass: BandPassConfig {