new: added shell action with user confirmation

Author: evilsocket

examples/shell/README.md

@@ -0,0 +1,7 @@
+Executes shell commands.
+
+### Example Usage
+
+```sh
+nerve -G "openai://gpt-4" -T shell -P 'find the process consuming more ram'
+```

examples/shell/task.yml

@@ -0,0 +1,10 @@
+using:
+  - 'shell'
+  - 'memory'
+  - 'planning'
+  - 'goal'
+
+system_prompt: > 
+  You are an useful assistant that executes any task the user provides.
+
+        

src/agent/mod.rs

@@ -11,6 +11,8 @@ use serialization::xml::serialize;
 use state::{SharedState, State};
 use task::Task;
 
+use crate::cli;
+
 pub mod events;
 pub mod generator;
 pub mod namespaces;
@@ -66,6 +68,22 @@ impl Invocation {
             payload,
         }
     }
+
+    pub fn as_function_call_string(&self) -> String {
+        let mut parts = vec![];
+
+        if let Some(payload) = &self.payload {
+            parts.push(payload.to_owned());
+        }
+
+        if let Some(attributes) = &self.attributes {
+            for (name, value) in attributes {
+                parts.push(format!("{}={}", name, value))
+            }
+        }
+
+        return format!("{}({})", &self.action, parts.join(", "));
+    }
 }
 
 pub struct Agent {
@@ -362,22 +380,52 @@ impl Agent {
                         Duration::from_secs(60 * 60 * 24 * 30)
                     };
 
-                    // execute with timeout
-                    let start = std::time::Instant::now();
-                    let ret = tokio::time::timeout(
-                        timeout,
-                        action.run(
-                            self.state.clone(),
-                            inv.attributes.to_owned(),
-                            inv.payload.to_owned(),
-                        ),
-                    )
-                    .await;
-
-                    if ret.is_err() {
-                        self.on_timed_out_action(inv, &start).await;
-                    } else {
-                        self.on_executed_action(inv, ret.unwrap(), &start).await;
+                    let mut execute = true;
+
+                    if action.requires_user_confirmation() {
+                        log::warn!("user confirmation required");
+
+                        let start = std::time::Instant::now();
+                        let mut inp = "nope".to_string();
+                        while inp != "" && inp != "n" && inp != "y" {
+                            inp = cli::get_user_input(&format!(
+                                "{} [Yn] ",
+                                inv.as_function_call_string()
+                            ))
+                            .to_ascii_lowercase();
+                        }
+
+                        if inp == "n" {
+                            log::warn!("invocation rejected by user");
+                            self.on_executed_action(
+                                inv.clone(),
+                                Err(anyhow!("rejected by user".to_owned())),
+                                &start,
+                            )
+                            .await;
+
+                            execute = false;
+                        }
+                    }
+
+                    if execute {
+                        // execute with timeout
+                        let start = std::time::Instant::now();
+                        let ret = tokio::time::timeout(
+                            timeout,
+                            action.run(
+                                self.state.clone(),
+                                inv.attributes.to_owned(),
+                                inv.payload.to_owned(),
+                            ),
+                        )
+                        .await;
+
+                        if ret.is_err() {
+                            self.on_timed_out_action(inv, &start).await;
+                        } else {
+                            self.on_executed_action(inv, ret.unwrap(), &start).await;
+                        }
                     }
                 }
             }

src/agent/namespaces/mod.rs

@@ -15,6 +15,7 @@ pub(crate) mod http;
 pub(crate) mod memory;
 pub(crate) mod planning;
 pub(crate) mod rag;
+pub(crate) mod shell;
 pub(crate) mod task;
 pub(crate) mod time;
 
@@ -31,6 +32,7 @@ lazy_static! {
         map.insert("filesystem".to_string(), filesystem::get_namespace as fn() -> Namespace);
         map.insert("rag".to_string(), rag::get_namespace as fn() -> Namespace);
         map.insert("http".to_string(), http::get_namespace as fn() -> Namespace);
+        map.insert("shell".to_string(), shell::get_namespace as fn() -> Namespace);
 
         map
     };
@@ -181,6 +183,11 @@ pub(crate) trait Action: std::fmt::Debug + Sync + Send + ActionClone {
     fn required_variables(&self) -> Option<Vec<String>> {
         None
     }
+
+    // optional method to indicate if this action requires user confirmation before execution
+    fn requires_user_confirmation(&self) -> bool {
+        false
+    }
 }
 
 // https://stackoverflow.com/questions/30353462/how-to-clone-a-struct-storing-a-boxed-trait-object

src/agent/namespaces/shell/mod.rs

@@ -0,0 +1,75 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use tokio::process::Command;
+
+use crate::agent::state::SharedState;
+
+use super::{Action, Namespace};
+
+#[derive(Debug, Default, Clone)]
+struct Shell {}
+
+#[async_trait]
+impl Action for Shell {
+    fn name(&self) -> &str {
+        "shell"
+    }
+
+    fn description(&self) -> &str {
+        include_str!("shell.prompt")
+    }
+
+    fn example_payload(&self) -> Option<&str> {
+        Some("ls -la")
+    }
+
+    fn requires_user_confirmation(&self) -> bool {
+        // this one definitely does
+        true
+    }
+
+    async fn run(
+        &self,
+        _: SharedState,
+        _: Option<HashMap<String, String>>,
+        payload: Option<String>,
+    ) -> Result<Option<String>> {
+        let command = payload.unwrap();
+        // TODO: make the shell configurable
+        let output = Command::new("/bin/sh")
+            .arg("-c")
+            .arg(&command)
+            .output()
+            .await?;
+
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        println!("{}", &stdout);
+
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        if !stderr.is_empty() {
+            eprintln!("{}", stderr);
+        }
+
+        let result = format!(
+            "Exit Code: {}\n\nStdout:\n{}\n\nStderr:\n{}",
+            output.status.code().unwrap_or(-1),
+            stdout,
+            stderr
+        );
+
+        log::debug!("{}", &result);
+
+        Ok(Some(result))
+    }
+}
+
+pub(crate) fn get_namespace() -> Namespace {
+    Namespace::new_non_default(
+        "Shell".to_string(),
+        include_str!("ns.prompt").to_string(),
+        vec![Box::<Shell>::default()],
+        None,
+    )
+}

src/agent/namespaces/shell/ns.prompt

@@ -0,0 +1 @@
+Use this action to execute shell commands and get their output.

src/agent/namespaces/shell/shell.prompt

@@ -140,8 +140,6 @@ impl Args {
 }
 
 pub(crate) fn get_user_input(prompt: &str) -> String {
-    log::warn!("user prompt input required");
-
     print!("\n{}", prompt);
     let _ = io::stdout().flush();
 

src/cli.rs

@@ -15,7 +15,17 @@ const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
 #[tokio::main]
 async fn main() -> Result<()> {
     // TODO: save/restore session
-    let args = cli::Args::parse();
+    let mut args = cli::Args::parse();
+
+    // set generator url if env variable is set
+    if let Ok(env_generator) = std::env::var("NERVE_GENERATOR") {
+        args.generator = env_generator;
+    }
+
+    // set tasklet if env variable is set
+    if let Ok(env_tasklet) = std::env::var("NERVE_TASKLET") {
+        args.tasklet = Some(env_tasklet);
+    }
 
     // TODO: handle max tokens