@pheem49/mint 1.7.1 → 1.8.1

package/src/renderer/src-web/tauri.ts

@@ -134,6 +134,28 @@ export async function getRuntimeStatus(): Promise<RuntimeStatus> {
   return invoke<RuntimeStatus>('get_runtime_status')
 }
 
+export interface DetectedTools {
+  docker: boolean
+  git: boolean
+  gh: boolean
+  node: boolean
+}
+
+export async function detectSystemTools(): Promise<DetectedTools> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    const API_BASE = getApiBase();
+    try {
+      const res = await fetch(`${API_BASE}/detect-tools`);
+      return await res.json();
+    } catch (e) {
+      console.error("Failed to detect tools from local server:", e);
+      return { docker: false, git: false, gh: false, node: false };
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<DetectedTools>('detect_system_tools')
+}
+
 export async function sendChatMessage(
   message: string,
   imageDataUri?: string | null,
@@ -293,6 +315,30 @@ export async function getRecentInteractions(limit = 50, chatId?: string | null):
   return invoke<InteractionMemory[]>('get_recent_interactions', { limit, chatId })
 }
 
+export async function saveSystemInteraction(
+  chatId: string,
+  userText: string,
+  provider: string,
+  model: string,
+): Promise<any> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    const API_BASE = getApiBase();
+    try {
+      const res = await fetch(`${API_BASE}/interactions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ chatId, userText, provider, model }),
+      });
+      return await res.json();
+    } catch (e) {
+      console.error("Failed to save system interaction on local server:", e);
+      return { success: false };
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('save_system_interaction', { chatId, userText, provider, model })
+}
+
 export async function saveInteractionAgentActivity(
   interactionId: number,
   activity: AgentProgress[],
@@ -553,12 +599,12 @@ export async function setDefaultImageProvider(provider: string): Promise<boolean
 
 
 
-export async function submitToolApproval(token: string, approved: boolean): Promise<void> {
+export async function submitToolApproval(token: string, approved: boolean, answer?: string): Promise<void> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     return;
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('submit_tool_approval', { token, approved })
+  return invoke('submit_tool_approval', { token, approved, answer })
 }
 
 export async function proposeCodeEdits(root: string, edits: CodeEdit[]): Promise<CodeEditProposal> {
@@ -638,6 +684,7 @@ export function installTauriAdapters() {
       openFolder: async () => ({ success: false, message: 'Opening local folders is only available in the desktop app.' }),
       openCustomWorkflows: async () => ({ success: false, message: 'Opening workflow files is only available in the desktop app.' }),
       reloadCustomWorkflows: async () => ({ success: false, message: 'Reloading workflow files is only available in the desktop app.' }),
+      saveCustomWorkflows: async () => ({ success: false, message: 'Saving workflow files is only available in the desktop app.' }),
     };
 
     (window as any).spotlightAPI = {
@@ -733,6 +780,9 @@ export function installTauriAdapters() {
       openSettings: () => {
         window.location.hash = '#/settings';
       },
+      openWorkflows: () => {
+        window.location.hash = '#/workflows';
+      },
       readClipboard: async () => '',
       writeClipboard: async () => {},
       getSystemInfo: async () => {
@@ -877,6 +927,10 @@ export function installTauriAdapters() {
       const { invoke } = await import('@tauri-apps/api/core')
       return invoke('reload_custom_workflows')
     },
+    saveCustomWorkflows: async (workflows) => {
+      const { invoke } = await import('@tauri-apps/api/core')
+      return invoke('save_custom_workflows', { workflows })
+    },
   }
 
   window.spotlightAPI = {
@@ -1003,6 +1057,10 @@ export function installTauriAdapters() {
       const { invoke } = await import('@tauri-apps/api/core')
       return invoke('open_window', { kind: 'settings' })
     },
+    openWorkflows: async () => {
+      const { invoke } = await import('@tauri-apps/api/core')
+      return invoke('open_window', { kind: 'workflows' })
+    },
     readClipboard: () => navigator.clipboard.readText(),
     writeClipboard: (text) => navigator.clipboard.writeText(text),
     getSystemInfo: async () => ({ backend: 'rust' }),

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())?