@pheem49/mint 1.8.0 → 1.8.2

package/src-tauri/src/browser.rs

@@ -1,141 +1 @@
-use futures_util::{SinkExt, StreamExt};
-use mint_core::MintConfig;
-use serde::Serialize;
-use serde_json::{Value, json};
-use tokio_tungstenite::{connect_async, tungstenite::Message};
-
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BrowserTab {
-    pub id: String,
-    pub title: String,
-    pub url: String,
-}
-
-pub async fn list_tabs(config: &MintConfig) -> Result<Vec<BrowserTab>, String> {
-    Ok(fetch_pages(config)
-        .await?
-        .into_iter()
-        .filter_map(|page| {
-            Some(BrowserTab {
-                id: page["id"].as_str()?.to_owned(),
-                title: page["title"].as_str().unwrap_or_default().to_owned(),
-                url: page["url"].as_str().unwrap_or_default().to_owned(),
-            })
-        })
-        .collect())
-}
-
-pub async fn navigate(config: &MintConfig, url: &str) -> Result<String, String> {
-    if !(url.starts_with("https://") || url.starts_with("http://")) {
-        return Err("browser navigation only supports http and https URLs".into());
-    }
-    let response = cdp_call(config, "Page.navigate", json!({ "url": url })).await?;
-    response["result"]["frameId"]
-        .as_str()
-        .map(|_| format!("navigating to {url}"))
-        .ok_or_else(|| response_error(&response))
-}
-
-pub async fn read_page_text(config: &MintConfig) -> Result<String, String> {
-    let response = cdp_call(
-        config,
-        "Runtime.evaluate",
-        json!({
-            "expression": "document.body ? document.body.innerText.substring(0, 12000) : ''",
-            "returnByValue": true
-        }),
-    )
-    .await?;
-    response["result"]["result"]["value"]
-        .as_str()
-        .map(str::to_owned)
-        .ok_or_else(|| response_error(&response))
-}
-
-pub async fn click(config: &MintConfig, selector: &str) -> Result<String, String> {
-    let selector = selector.trim();
-    if selector.is_empty() || selector.len() > 500 {
-        return Err("browser selector must contain between 1 and 500 characters".into());
-    }
-    let selector = serde_json::to_string(selector).map_err(|error| error.to_string())?;
-    let response = cdp_call(
-        config,
-        "Runtime.evaluate",
-        json!({
-            "expression": format!(
-                "(() => {{ const element = document.querySelector({selector}); if (!element) return 'not-found'; element.click(); return 'clicked'; }})()"
-            ),
-            "returnByValue": true
-        }),
-    )
-    .await?;
-    match response["result"]["result"]["value"].as_str() {
-        Some("clicked") => Ok("clicked".into()),
-        Some("not-found") => Err(format!("browser selector not found: {selector}")),
-        _ => Err(response_error(&response)),
-    }
-}
-
-async fn cdp_call(config: &MintConfig, method: &str, params: Value) -> Result<Value, String> {
-    let page = fetch_pages(config)
-        .await?
-        .into_iter()
-        .find(|page| page["type"] == "page")
-        .ok_or("Chrome DevTools did not report an open browser page")?;
-    let socket_url = page["webSocketDebuggerUrl"]
-        .as_str()
-        .ok_or("Chrome DevTools page does not expose a websocket URL")?;
-    let (mut socket, _) = connect_async(socket_url)
-        .await
-        .map_err(|error| format!("unable to connect to Chrome DevTools websocket: {error}"))?;
-    socket
-        .send(Message::Text(
-            json!({ "id": 1, "method": method, "params": params })
-                .to_string()
-                .into(),
-        ))
-        .await
-        .map_err(|error| error.to_string())?;
-    while let Some(message) = socket.next().await {
-        let message = message.map_err(|error| error.to_string())?;
-        let Message::Text(raw) = message else {
-            continue;
-        };
-        let value: Value = serde_json::from_str(&raw).map_err(|error| error.to_string())?;
-        if value["id"] == 1 {
-            return Ok(value);
-        }
-    }
-    Err("Chrome DevTools websocket closed before returning a response".into())
-}
-
-async fn fetch_pages(config: &MintConfig) -> Result<Vec<Value>, String> {
-    let endpoint = config
-        .extra
-        .get("browserDebugUrl")
-        .and_then(Value::as_str)
-        .unwrap_or("http://127.0.0.1:9222/json/list");
-    let value: Value = mint_core::HTTP_CLIENT
-        .clone()
-        .get(endpoint)
-        .send()
-        .await
-        .map_err(|error| format!("unable to reach Chrome DevTools at {endpoint}: {error}"))?
-        .error_for_status()
-        .map_err(|error| error.to_string())?
-        .json()
-        .await
-        .map_err(|error| error.to_string())?;
-    value
-        .as_array()
-        .cloned()
-        .ok_or_else(|| "Chrome DevTools response was not a page list".into())
-}
-
-fn response_error(response: &Value) -> String {
-    response["error"]["message"]
-        .as_str()
-        .unwrap_or("Chrome DevTools returned an unexpected response")
-        .to_owned()
-}
+// Deleted - Moved browser automation functions to mint-core.

package/src-tauri/src/headless.rs

@@ -8,11 +8,11 @@ use serde::Deserialize;
 use serde_json::{Value, json};
 use tauri::{AppHandle, Emitter, Manager};
 
-use crate::browser::{click, navigate, read_page_text};
+use mint_core::browser::{click, navigate, read_page_text, type_text};
 
 const MAX_STEPS: usize = 20;
 const SYSTEM_PROMPT: &str = r#"You are Mint's native background task agent. Return only JSON:
-{"thought":"short progress note","action":"done|propose_folder|propose_write_file|open_url|browser_read|browser_click|knowledge_search|propose_bash","target":"path, URL, selector, query, command, or final result","data":"optional file content"}
+{"thought":"short progress note","action":"done|propose_folder|propose_write_file|open_url|browser_read|browser_click|browser_type|knowledge_search|propose_bash","target":"path, URL, selector, query, command, or final result","data":"optional file content"}
 Use only one action per response. Background tasks never mutate the filesystem or execute shell commands. Use propose_folder, propose_write_file, and propose_bash so Mint can record a proposal for explicit user approval."#;
 
 #[derive(Debug, Deserialize)]
@@ -177,6 +177,7 @@ async fn execute_action(
         "open_url" => navigate(config, &action.target).await,
         "browser_read" => read_page_text(config).await,
         "browser_click" => click(config, &action.target).await,
+        "browser_type" => type_text(config, &action.target, &action.data).await,
         "knowledge_search" => {
             let hits = KnowledgeStore::open_default()
                 .map_err(|error| error.to_string())?

package/src-tauri/src/lib.rs

@@ -1,4 +1,3 @@
-mod browser;
 mod desktop;
 mod discord_rpc;
 mod events;
@@ -11,7 +10,7 @@ mod updater;
 mod webhooks;
 mod workflows;
 
-use browser::{
+use mint_core::browser::{
     BrowserTab, click as browser_click, list_tabs as browser_list_tabs,
     navigate as browser_navigate, read_page_text,
 };
@@ -41,7 +40,7 @@ use mint_core::{
 use plugins::execute_plugin;
 
 pub struct ApprovalsState {
-    pub pending: Mutex<HashMap<String, oneshot::Sender<bool>>>,
+    pub pending: Mutex<HashMap<String, oneshot::Sender<ApprovalOutcome>>>,
 }
 
 static COUNTER: AtomicU64 = AtomicU64::new(1);
@@ -136,6 +135,26 @@ async fn get_workspace_tree(path: Option<String>) -> Result<WorkspaceTreeEntry,
         .map_err(|error| format!("workspace tree task failed: {error}"))?
 }
 
+#[tauri::command]
+async fn create_workspace_file(path: String) -> Result<(), String> {
+    std::fs::write(&path, "").map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+async fn create_workspace_folder(path: String) -> Result<(), String> {
+    std::fs::create_dir_all(&path).map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+async fn delete_workspace_item(path: String) -> Result<(), String> {
+    let path_buf = std::path::PathBuf::from(path);
+    if path_buf.is_dir() {
+        std::fs::remove_dir_all(path_buf).map_err(|error| error.to_string())
+    } else {
+        std::fs::remove_file(path_buf).map_err(|error| error.to_string())
+    }
+}
+
 fn build_workspace_tree(path: Option<String>) -> Result<WorkspaceTreeEntry, String> {
     let root = workspace_root(path.as_deref())?;
     let name = root
@@ -191,6 +210,11 @@ fn workspace_root(path: Option<&str>) -> Result<PathBuf, String> {
         None => std::env::current_dir().map_err(|error| error.to_string())?,
     };
     let root = root.canonicalize().map_err(|error| error.to_string())?;
+    let root = if root.ends_with("src-tauri") {
+        root.parent().unwrap_or(&root).to_path_buf()
+    } else {
+        root
+    };
     if !root.is_dir() {
         return Err(format!("workspace is not a directory: {}", root.display()));
     }
@@ -298,10 +322,30 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
         clean_request.message = request.message.strip_prefix("/chat ").unwrap().to_owned();
+        let config_clone = config.clone();
+        let chat_id_str = request.chat_id.clone().unwrap_or_default();
 
-        let (response, _) = orchestrate_chat_with_fallback(&config, &clean_request)
-            .await
-            .map_err(|error| error.to_string())?;
+        let join_handle = tokio::spawn(async move {
+            orchestrate_chat_with_fallback(&config_clone, &clean_request).await
+        });
+
+        let abort_handle = join_handle.abort_handle();
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+        }
+
+        let res = join_handle.await;
+
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str);
+        }
+
+        let (response, _) = match res {
+            Ok(Ok(val)) => val,
+            Ok(Err(e)) => return Err(e.to_string()),
+            Err(e) if e.is_cancelled() => return Err("Chat execution cancelled by user".to_string()),
+            Err(e) => return Err(format!("Task panicked: {}", e)),
+        };
         return Ok(response);
     }
 
@@ -330,33 +374,56 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
             )
             .map_err(|e| e.to_string())?;
 
-        let approved =
+        let outcome =
             tokio::task::block_in_place(move || tokio::runtime::Handle::current().block_on(rx))
-                .unwrap_or(false);
-
-        if approved {
-            Ok(ApprovalOutcome::Approved)
-        } else {
-            Ok(ApprovalOutcome::Denied)
-        }
+                .unwrap_or(ApprovalOutcome::Denied);
+        Ok(outcome)
     };
 
     let progress_cb = |_| {};
     let on_chunk = |_| {};
 
-    let res = orchestrate_agent_loop(
-        &config,
-        &request.message,
-        &root,
-        request.image_data_uri.clone(),
-        request.chat_id.as_deref(),
-        fast_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
-    )
-    .await
-    .map_err(|e| e.to_string())?;
+    let chat_id_str = request.chat_id.clone().unwrap_or_default();
+    let config_clone = config.clone();
+    let message_clone = request.message.clone();
+    let root_clone = root.clone();
+    let image_data_uri_clone = request.image_data_uri.clone();
+    let chat_id_clone = request.chat_id.clone();
+    let agent_id_clone = request.agent_id.clone();
+
+    let join_handle = tokio::spawn(async move {
+        orchestrate_agent_loop(
+            &config_clone,
+            &message_clone,
+            &root_clone,
+            image_data_uri_clone,
+            chat_id_clone.as_deref(),
+            agent_id_clone.as_deref(),
+            fast_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        )
+        .await
+    });
+
+    let abort_handle = join_handle.abort_handle();
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+    }
+
+    let res = join_handle.await;
+
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str);
+    }
+
+    let res = match res {
+        Ok(Ok(val)) => val,
+        Ok(Err(e)) => return Err(e.to_string()),
+        Err(e) if e.is_cancelled() => return Err("Agent execution cancelled by user".to_string()),
+        Err(e) => return Err(format!("Task panicked: {}", e)),
+    };
 
     Ok(ChatResponse {
         provider: res.provider,
@@ -378,13 +445,34 @@ async fn stream_chat_message(
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
         clean_request.message = request.message.strip_prefix("/chat ").unwrap().to_owned();
+        let config_clone = config.clone();
+        let on_event_clone = on_event.clone();
+        let chat_id_str = request.chat_id.clone().unwrap_or_default();
 
-        let (response, _) =
-            orchestrate_chat_stream_with_fallback(&config, &clean_request, |chunk| {
-                let _ = on_event.send(DesktopStreamEvent::Chunk { chunk });
+        let join_handle = tokio::spawn(async move {
+            orchestrate_chat_stream_with_fallback(&config_clone, &clean_request, move |chunk| {
+                let _ = on_event_clone.send(DesktopStreamEvent::Chunk { chunk });
             })
             .await
-            .map_err(|error| error.to_string())?;
+        });
+
+        let abort_handle = join_handle.abort_handle();
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+        }
+
+        let res = join_handle.await;
+
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str);
+        }
+
+        let (response, _) = match res {
+            Ok(Ok(val)) => val,
+            Ok(Err(e)) => return Err(e.to_string()),
+            Err(e) if e.is_cancelled() => return Err("Chat execution cancelled by user".to_string()),
+            Err(e) => return Err(format!("Task panicked: {}", e)),
+        };
         return Ok(response);
     }
 
@@ -413,15 +501,10 @@ async fn stream_chat_message(
             )
             .map_err(|e| e.to_string())?;
 
-        let approved =
+        let outcome =
             tokio::task::block_in_place(move || tokio::runtime::Handle::current().block_on(rx))
-                .unwrap_or(false);
-
-        if approved {
-            Ok(ApprovalOutcome::Approved)
-        } else {
-            Ok(ApprovalOutcome::Denied)
-        }
+                .unwrap_or(ApprovalOutcome::Denied);
+        Ok(outcome)
     };
 
     let on_progress_event = on_event.clone();
@@ -442,19 +525,47 @@ async fn stream_chat_message(
         }
     };
 
-    let res = orchestrate_agent_loop(
-        &config,
-        &request.message,
-        &root,
-        request.image_data_uri.clone(),
-        request.chat_id.as_deref(),
-        fast_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
-    )
-    .await
-    .map_err(|e| e.to_string())?;
+    let chat_id_str = request.chat_id.clone().unwrap_or_default();
+    let config_clone = config.clone();
+    let message_clone = request.message.clone();
+    let root_clone = root.clone();
+    let image_data_uri_clone = request.image_data_uri.clone();
+    let chat_id_clone = request.chat_id.clone();
+    let agent_id_clone = request.agent_id.clone();
+
+    let join_handle = tokio::spawn(async move {
+        orchestrate_agent_loop(
+            &config_clone,
+            &message_clone,
+            &root_clone,
+            image_data_uri_clone,
+            chat_id_clone.as_deref(),
+            agent_id_clone.as_deref(),
+            fast_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        )
+        .await
+    });
+
+    let abort_handle = join_handle.abort_handle();
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+    }
+
+    let res = join_handle.await;
+
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str);
+    }
+
+    let res = match res {
+        Ok(Ok(val)) => val,
+        Ok(Err(e)) => return Err(e.to_string()),
+        Err(e) if e.is_cancelled() => return Err("Agent execution cancelled by user".to_string()),
+        Err(e) => return Err(format!("Task panicked: {}", e)),
+    };
 
     Ok(ChatResponse {
         provider: res.provider,
@@ -464,6 +575,12 @@ async fn stream_chat_message(
     })
 }
 
+#[tauri::command]
+async fn cancel_chat_message(chat_id: String) -> Result<(), String> {
+    mint_core::cancel_agent(&chat_id);
+    Ok(())
+}
+
 #[tauri::command]
 fn save_interaction_agent_activity(
     interaction_id: i64,
@@ -553,20 +670,52 @@ struct LearnedSkillDto {
     source_path: String,
     content: String,
     updated_at: String,
+    location: String,
 }
 
 #[tauri::command]
-fn list_learned_skills() -> Result<Vec<LearnedSkillDto>, String> {
+fn list_learned_skills(workspace_path: Option<String>) -> Result<Vec<LearnedSkillDto>, String> {
     let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
-    let skills = store.learned_skills(100).map_err(|e| e.to_string())?;
-    let dtos = skills
-        .into_iter()
-        .map(|s| LearnedSkillDto {
+    let db_skills = store.learned_skills(100).map_err(|e| e.to_string())?;
+
+    let mut global_skills = Vec::new();
+    if let Some(home) = dirs::home_dir() {
+        let global_skills_path = home.join(".config").join("mint").join("mint-skills");
+        if !global_skills_path.exists() {
+            let _ = std::fs::create_dir_all(&global_skills_path);
+        }
+        mint_core::skills::load_skills_from_dir(&global_skills_path, &mut global_skills);
+    }
+
+    let mut workspace_skills = Vec::new();
+    if let Ok(root) = workspace_root(workspace_path.as_deref()) {
+        let workspace_skills_path1 = root.join(".agents").join("skills");
+        mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut workspace_skills);
+
+        let workspace_skills_path2 = root.join("skills");
+        mint_core::skills::load_skills_from_dir(&workspace_skills_path2, &mut workspace_skills);
+    }
+
+    let mut unique_skills = std::collections::BTreeMap::new();
+    for s in db_skills {
+        unique_skills.insert(s.name.clone(), (s, "database"));
+    }
+    for s in global_skills {
+        unique_skills.insert(s.name.clone(), (s, "global"));
+    }
+    for s in workspace_skills {
+        unique_skills.insert(s.name.clone(), (s, "workspace"));
+    }
+
+    let dtos = unique_skills
+        .into_values()
+        .map(|(s, loc)| LearnedSkillDto {
             id: s.id,
             name: s.name,
             source_path: s.source_path,
             content: s.content,
             updated_at: s.created_at,
+            location: loc.to_string(),
         })
         .collect();
     Ok(dtos)
@@ -584,6 +733,7 @@ fn add_learned_skill(name: String, content: String) -> Result<LearnedSkillDto, S
         source_path: skill.source_path,
         content: skill.content,
         updated_at: skill.created_at,
+        location: "database".to_string(),
     })
 }
 
@@ -611,16 +761,47 @@ async fn submit_tool_approval(
     state: tauri::State<'_, ApprovalsState>,
     token: String,
     approved: bool,
+    answer: Option<String>,
 ) -> Result<(), String> {
     let mut pending = state.pending.lock().map_err(|error| error.to_string())?;
     if let Some(tx) = pending.remove(&token) {
-        let _ = tx.send(approved);
+        let outcome = if let Some(ans) = answer {
+            if !ans.trim().is_empty() {
+                ApprovalOutcome::Intercepted(ans)
+            } else {
+                ApprovalOutcome::Denied
+            }
+        } else if approved {
+            ApprovalOutcome::Approved
+        } else {
+            ApprovalOutcome::Denied
+        };
+        let _ = tx.send(outcome);
         Ok(())
     } else {
         Err("No pending approval found for this token".into())
     }
 }
 
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DetectedTools {
+    pub docker: bool,
+    pub git: bool,
+    pub gh: bool,
+    pub node: bool,
+}
+
+#[tauri::command]
+async fn detect_system_tools() -> Result<DetectedTools, String> {
+    Ok(DetectedTools {
+        docker: mint_core::config::which("docker"),
+        git: mint_core::config::which("git"),
+        gh: mint_core::config::which("gh"),
+        node: mint_core::config::which("node"),
+    })
+}
+
 #[derive(serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 struct DesktopImageGenResponse {
@@ -839,7 +1020,15 @@ async fn click_browser_selector(selector: String) -> Result<String, String> {
     )
     .await
 }
-
+#[tauri::command]
+async fn type_in_browser(selector: String, text: String) -> Result<String, String> {
+    mint_core::browser::type_text(
+        &load_config().map_err(|error| error.to_string())?,
+        &selector,
+        &text,
+    )
+    .await
+}
 #[tauri::command]
 fn start_screen_capture(app: AppHandle) -> Result<(), String> {
     open_desktop_window(&app, "screen-picker")
@@ -1022,7 +1211,11 @@ pub fn run() {
         })
         .invoke_handler(tauri::generate_handler![
             get_runtime_status,
+            detect_system_tools,
             get_workspace_tree,
+            create_workspace_file,
+            create_workspace_folder,
+            delete_workspace_item,
             generate_images,
             select_workspace_directory,
             get_config,
@@ -1033,6 +1226,7 @@ pub fn run() {
             inspect_shell_command,
             send_chat_message,
             stream_chat_message,
+            cancel_chat_message,
             submit_tool_approval,
             get_recent_interactions,
             save_interaction_agent_activity,
@@ -1067,6 +1261,7 @@ pub fn run() {
             navigate_browser,
             read_browser_page,
             click_browser_selector,
+            type_in_browser,
             start_screen_capture,
             submit_screen_selection,
             submit_spotlight,

package/src-tauri/src/webhooks.rs

@@ -154,6 +154,7 @@ async fn answer(text: &str, system: &str) -> String {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         },
     )
     .await