@pheem49/mint 1.6.2 → 1.6.3

package/src-tauri/src/headless.rs

@@ -0,0 +1,222 @@
+use std::{path::Path, time::Duration};
+
+use mint_core::{
+    CodeEdit, KnowledgeStore, MintConfig, Task, TaskStore, load_config, parse_agent_json,
+    propose_code_edits, run_agent_loop,
+};
+use serde::Deserialize;
+use serde_json::{Value, json};
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::browser::{click, navigate, read_page_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"}
+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)]
+struct AgentAction {
+    #[serde(default)]
+    thought: String,
+    action: String,
+    #[serde(default)]
+    target: String,
+    #[serde(default)]
+    data: String,
+}
+
+pub fn start_headless_queue(app: AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        if let Ok(store) = TaskStore::open_default() {
+            let _ = store.resume_running();
+        }
+        loop {
+            tokio::time::sleep(Duration::from_secs(15)).await;
+            let Ok(config) = load_config() else {
+                continue;
+            };
+            if config
+                .extra
+                .get("enableHeadlessTaskQueue")
+                .and_then(Value::as_bool)
+                != Some(true)
+            {
+                continue;
+            }
+            let _ = run_next_task(&app).await;
+        }
+    });
+}
+
+pub async fn run_next_task(app: &AppHandle) -> Result<Option<Task>, String> {
+    let store = TaskStore::open_default().map_err(|error| error.to_string())?;
+    let Some(task) = store.pending().map_err(|error| error.to_string())? else {
+        return Ok(None);
+    };
+    store
+        .update_status(&task.id, "running", None)
+        .map_err(|error| error.to_string())?;
+    checkpoint(&store, &task.id, "started", &task.description)?;
+    emit(
+        app,
+        &format!("Started queued task: {}", task.description),
+        "info",
+    );
+
+    match execute_task(&store, &task).await {
+        Ok(result) => {
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "final_result", "content": result }),
+                )
+                .map_err(|error| error.to_string())?;
+            let completed = store
+                .update_status(&task.id, "completed", Some(Value::String(result.clone())))
+                .map_err(|error| error.to_string())?;
+            emit(app, &format!("Queued task completed: {result}"), "info");
+            Ok(completed)
+        }
+        Err(error) => {
+            let failed = store
+                .fail_with_retry(&task.id, &error)
+                .map_err(|store_error| store_error.to_string())?;
+            emit(app, &format!("Queued task failed: {error}"), "warning");
+            Ok(failed)
+        }
+    }
+}
+
+async fn execute_task(store: &TaskStore, task: &Task) -> Result<String, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    let observer_store = store.clone();
+    let observer_task = task.clone();
+    let executor_store = store.clone();
+    let executor_task = task.clone();
+    let executor_config = config.clone();
+    run_agent_loop(
+        &config,
+        SYSTEM_PROMPT,
+        format!("Task: {}\nChoose the first action.", task.description),
+        MAX_STEPS,
+        |raw| parse_agent_json(raw).map_err(|error| error.to_string()),
+        |action: &AgentAction| (action.action == "done").then(|| action.target.clone()),
+        move |step, action| {
+            let store = executor_store.clone();
+            let task = executor_task.clone();
+            let config = executor_config.clone();
+            Box::pin(async move {
+                let observation = execute_action(&config, &store, &task, step, &action).await?;
+                checkpoint(&store, &task.id, "observation", &observation)?;
+                Ok(observation)
+            })
+        },
+        move |step, action| {
+            observer_store
+                .add_checkpoint(
+                    &observer_task.id,
+                    json!({
+                        "phase": "native_agent_step",
+                        "step": step,
+                        "thought": action.thought,
+                        "action": action.action,
+                        "target": action.target,
+                    }),
+                )
+                .map(|_| ())
+                .map_err(|error| error.to_string())
+        },
+    )
+    .await
+    .map_err(|error| error.to_string())
+}
+
+async fn execute_action(
+    config: &MintConfig,
+    store: &TaskStore,
+    task: &Task,
+    step: usize,
+    action: &AgentAction,
+) -> Result<String, String> {
+    match action.action.as_str() {
+        "propose_folder" => {
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "folder_proposal", "path": action.target, "description": format!("Proposed by native task step {step}; explicit approval required") }),
+                )
+                .map_err(|error| error.to_string())?;
+            Ok(format!(
+                "folder proposal recorded but not applied: {}",
+                action.target
+            ))
+        }
+        "propose_write_file" => {
+            let root = std::env::current_dir().map_err(|error| error.to_string())?;
+            let proposal = propose_code_edits(
+                &root,
+                &[CodeEdit {
+                    path: Path::new(&action.target).to_path_buf(),
+                    content: action.data.clone(),
+                }],
+                config,
+            )
+            .map_err(|error| error.to_string())?;
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "file_edit_proposal", "proposal": proposal, "description": format!("Proposed by native task step {step}; explicit approval required") }),
+                )
+                .map_err(|error| error.to_string())?;
+            Ok(format!(
+                "file edit proposal recorded but not applied: {}",
+                action.target
+            ))
+        }
+        "open_url" => navigate(config, &action.target).await,
+        "browser_read" => read_page_text(config).await,
+        "browser_click" => click(config, &action.target).await,
+        "knowledge_search" => {
+            let hits = KnowledgeStore::open_default()
+                .map_err(|error| error.to_string())?
+                .search(&action.target, 5)
+                .map_err(|error| error.to_string())?;
+            serde_json::to_string(&hits).map_err(|error| error.to_string())
+        }
+        "propose_bash" => Ok(format!(
+            "command proposal recorded but not executed: {}",
+            action.target
+        )),
+        other => Err(format!("unsupported native background action '{other}'")),
+    }
+}
+
+fn checkpoint(store: &TaskStore, id: &str, phase: &str, message: &str) -> Result<(), String> {
+    store
+        .add_checkpoint(id, json!({ "phase": phase, "message": message }))
+        .map(|_| ())
+        .map_err(|error| error.to_string())
+}
+
+fn emit(app: &AppHandle, message: &str, kind: &str) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit(
+            "proactive-notification",
+            json!({ "message": message, "type": kind }),
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_json_wrapped_in_provider_text() {
+        let action: AgentAction =
+            parse_agent_json("```json\n{\"action\":\"done\",\"target\":\"ok\"}\n```").unwrap();
+        assert_eq!(action.action, "done");
+        assert_eq!(action.target, "ok");
+    }
+}

package/src-tauri/src/integrations.rs

@@ -0,0 +1,126 @@
+use mint_core::MintConfig;
+use serde::Serialize;
+use serde_json::{Value, json};
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PluginInfo {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub migrated: bool,
+    pub configured: bool,
+}
+
+pub fn list_plugins(config: &MintConfig) -> Vec<PluginInfo> {
+    let mut plugins = vec![
+        PluginInfo {
+            name: "desktop-actions",
+            description: "Allowlisted URL and desktop application launcher",
+            migrated: true,
+            configured: true,
+        },
+        PluginInfo {
+            name: "mcp-stdio",
+            description: "Configured MCP server bridge over stdio JSON-RPC",
+            migrated: true,
+            configured: config.extra.get("mcpServers").is_some_and(|servers| {
+                servers
+                    .as_object()
+                    .is_some_and(|servers| !servers.is_empty())
+            }),
+        },
+        PluginInfo {
+            name: "gmail",
+            description: "Gmail OAuth search bridge",
+            migrated: true,
+            configured: has_values(
+                config,
+                &["gmailClientId", "gmailClientSecret", "gmailRefreshToken"],
+            ),
+        },
+        PluginInfo {
+            name: "google_calendar",
+            description: "Google Calendar OAuth list and browser-open bridge",
+            migrated: true,
+            configured: has_values(
+                config,
+                &[
+                    "googleCalendarClientId",
+                    "googleCalendarClientSecret",
+                    "googleCalendarRefreshToken",
+                ],
+            ),
+        },
+        PluginInfo {
+            name: "notion",
+            description: "Notion page creation bridge",
+            migrated: true,
+            configured: has_values(config, &["notionApiKey", "notionDatabaseId"]),
+        },
+        PluginInfo {
+            name: "discord",
+            description: "Discord Rich Presence over native desktop IPC",
+            migrated: true,
+            configured: has_values(config, &["discordApplicationId"]),
+        },
+    ];
+    plugins.extend(
+        mint_core::native_plugins()
+            .into_iter()
+            .map(|plugin| PluginInfo {
+                name: plugin.name,
+                description: plugin.description,
+                migrated: true,
+                configured: true,
+            }),
+    );
+    plugins
+}
+
+pub fn channel_inventory(config: &MintConfig) -> Value {
+    json!([
+        channel(
+            config,
+            "telegram",
+            &["telegramBotToken"],
+            "native-long-poll"
+        ),
+        channel(config, "discord", &["discordBotToken"], "native-gateway"),
+        channel(
+            config,
+            "slack",
+            &["slackBotToken", "slackAppToken"],
+            "native-socket-mode"
+        ),
+        channel(
+            config,
+            "line",
+            &["lineChannelAccessToken", "lineChannelSecret"],
+            "native-webhook-127.0.0.1:3000"
+        ),
+        channel(
+            config,
+            "whatsapp",
+            &[
+                "whatsappCloudAccessToken",
+                "whatsappPhoneNumberId",
+                "whatsappVerifyToken"
+            ],
+            "native-cloud-api-webhook-127.0.0.1:3001"
+        )
+    ])
+}
+
+fn channel(config: &MintConfig, name: &str, keys: &[&str], runtime: &str) -> Value {
+    json!({ "name": name, "configured": has_values(config, keys), "runtime": runtime })
+}
+
+fn has_values(config: &MintConfig, keys: &[&str]) -> bool {
+    keys.iter().all(|key| {
+        config
+            .extra
+            .get(*key)
+            .and_then(Value::as_str)
+            .is_some_and(|value| !value.trim().is_empty())
+    })
+}