@pheem49/mint 1.8.0 → 1.8.1

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()));
     }
@@ -330,15 +354,10 @@ 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 = |_| {};
@@ -413,15 +432,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();
@@ -553,20 +567,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 +630,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 +658,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 +917,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 +1108,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,
@@ -1067,6 +1157,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/workflows.rs

@@ -5,7 +5,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use mint_core::{load_config, load_workflows};
+use mint_core::{ChatRequest, load_config, load_workflows, send_chat};
 use serde_json::json;
 use tauri::{AppHandle, Emitter, Manager};
 
@@ -53,10 +53,62 @@ pub fn start_monitor(app: AppHandle) {
                 }
                 last_triggered.insert(id.into(), Instant::now());
                 if let Some(main) = app.get_webview_window("main") {
+                    let static_message = workflow["action"]["message"]
+                        .as_str()
+                        .unwrap_or("Automation workflow triggered");
+
+                    let final_message = if let Ok(config) = load_config() {
+                        let prompt = format!(
+                            "You are Mint, a friendly desktop AI assistant. The user has triggered a workflow called '{}'. \
+                            The original notification message is: '{}'. \
+                            Please rewrite this notification message to be extremely friendly, cute, and natural. \
+                            Write in the language matching the user's configured language: '{}'. \
+                            Keep the length under 20 words and always end with a question (e.g. asking if they want to launch the action). \
+                            Only reply with the rewritten message itself, do not include any quotes, markdown formatting, or extra explanations.",
+                            workflow["name"].as_str().unwrap_or(""),
+                            static_message,
+                            config.language
+                        );
+
+                        let chat_req = ChatRequest {
+                            message: prompt,
+                            system_instruction: format!(
+                                "You are Mint, a helpful desktop assistant. Write only the friendly suggestion in the language matching '{}'. No quotes, no markdown, no other text.",
+                                config.language
+                            ),
+                            chat_id: None,
+                            image_data_uri: None,
+                            audio_data_uri: None,
+                            document_attachment: None,
+                            workspace_path: None,
+                        };
+
+                        tauri::async_runtime::block_on(async {
+                            match send_chat(&config, &chat_req).await {
+                                Ok(response) => {
+                                    let cleaned =
+                                        response.text.trim().trim_matches('"').to_string();
+                                    if !cleaned.is_empty() {
+                                        cleaned
+                                    } else {
+                                        static_message.to_string()
+                                    }
+                                }
+                                Err(err) => {
+                                    eprintln!(
+                                        "Failed to generate dynamic suggestion via AI: {:?}",
+                                        err
+                                    );
+                                    static_message.to_string()
+                                }
+                            }
+                        })
+                    } else {
+                        static_message.to_string()
+                    };
+
                     let payload = json!({
-                        "message": workflow["action"]["message"]
-                            .as_str()
-                            .unwrap_or("Automation workflow triggered"),
+                        "message": final_message,
                         "suggestions": [
                             { "label": "Yes, please", "action": workflow["action"] },
                             { "label": "Dismiss", "action": { "type": "none" } }

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Mint",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "identifier": "com.pheem49.mint",
   "build": {
     "beforeDevCommand": "npm run dev:desktop",