@pheem49/mint 1.14.0 → 1.16.0

package/src-tauri/src/native/discord_rpc.rs

@@ -0,0 +1,99 @@
+use std::io::{Read, Write};
+
+use mint_core::MintConfig;
+use serde_json::{Value, json};
+
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+pub fn set_activity(config: &MintConfig, instruction: &str) -> Result<String, String> {
+    let application_id = config
+        .extra
+        .get("discordApplicationId")
+        .and_then(Value::as_str)
+        .filter(|value| !value.trim().is_empty())
+        .ok_or("missing config value 'discordApplicationId'")?;
+    let input: Value = serde_json::from_str(instruction).unwrap_or_else(|_| {
+        json!({ "details": if instruction.trim().is_empty() { "Using Mint Assistant" } else { instruction } })
+    });
+    let activity = json!({
+        "details": input["details"].as_str().unwrap_or("Using Mint Assistant"),
+        "state": input["state"].as_str().unwrap_or("Native Tauri desktop"),
+        "instance": false
+    });
+    send(application_id, activity)?;
+    Ok("Discord Rich Presence activity updated.".into())
+}
+
+#[cfg(unix)]
+fn send(application_id: &str, activity: Value) -> Result<(), String> {
+    let mut socket = connect()?;
+    write_frame(
+        &mut socket,
+        0,
+        &json!({ "v": 1, "client_id": application_id }),
+    )?;
+    let _ = read_frame(&mut socket)?;
+    write_frame(
+        &mut socket,
+        1,
+        &json!({
+            "cmd": "SET_ACTIVITY",
+            "args": { "pid": std::process::id(), "activity": activity },
+            "nonce": format!("mint-{}", std::process::id())
+        }),
+    )?;
+    let _ = read_frame(&mut socket)?;
+    Ok(())
+}
+
+#[cfg(not(unix))]
+fn send(_application_id: &str, _activity: Value) -> Result<(), String> {
+    Err("Discord Rich Presence is currently implemented for Unix desktop IPC only".into())
+}
+
+#[cfg(unix)]
+fn connect() -> Result<UnixStream, String> {
+    let runtime = std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".into());
+    (0..10)
+        .find_map(|index| UnixStream::connect(format!("{runtime}/discord-ipc-{index}")).ok())
+        .ok_or_else(|| "Discord IPC socket was not found; start Discord desktop first".into())
+}
+
+fn write_frame(stream: &mut impl Write, opcode: u32, payload: &Value) -> Result<(), String> {
+    let payload = serde_json::to_vec(payload).map_err(|error| error.to_string())?;
+    stream
+        .write_all(&opcode.to_le_bytes())
+        .and_then(|_| stream.write_all(&(payload.len() as u32).to_le_bytes()))
+        .and_then(|_| stream.write_all(&payload))
+        .map_err(|error| format!("unable to write Discord IPC frame: {error}"))
+}
+
+fn read_frame(stream: &mut impl Read) -> Result<Value, String> {
+    let mut header = [0_u8; 8];
+    stream
+        .read_exact(&mut header)
+        .map_err(|error| format!("unable to read Discord IPC header: {error}"))?;
+    let length = u32::from_le_bytes(header[4..8].try_into().unwrap()) as usize;
+    let mut payload = vec![0; length];
+    stream
+        .read_exact(&mut payload)
+        .map_err(|error| format!("unable to read Discord IPC payload: {error}"))?;
+    serde_json::from_slice(&payload).map_err(|error| error.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn writes_discord_rpc_frame() {
+        let mut bytes = Vec::new();
+        write_frame(&mut bytes, 1, &json!({ "ok": true })).unwrap();
+        assert_eq!(u32::from_le_bytes(bytes[0..4].try_into().unwrap()), 1);
+        assert_eq!(
+            u32::from_le_bytes(bytes[4..8].try_into().unwrap()) as usize,
+            bytes.len() - 8
+        );
+    }
+}

package/src-tauri/src/native/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())
+    })
+}

package/src-tauri/src/native/mod.rs

@@ -0,0 +1,12 @@
+//! Native platform IO, windows, terminal ownership and Desktop integrations.
+pub(crate) mod actions;
+pub(crate) mod browser;
+pub(crate) mod capture;
+pub(crate) mod discord_rpc;
+pub(crate) mod integrations;
+pub(crate) mod notifications;
+pub(crate) mod plugins;
+pub(crate) mod system;
+pub(crate) mod terminal;
+pub(crate) mod updater;
+pub(crate) mod windows;

package/src-tauri/src/native/notifications.rs

@@ -0,0 +1,51 @@
+use tauri::{AppHandle, Emitter, Manager};
+
+/// Keep delivery errors awaitable, while waiting for an OS action off the UI thread.
+#[tauri::command]
+pub async fn send_mint_notification(
+    app: AppHandle,
+    body: String,
+    chat_id: Option<String>,
+) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        #[cfg(target_os = "macos")]
+        notify_rust::set_application(if tauri::is_dev() {
+            "com.apple.Terminal"
+        } else {
+            &app.config().identifier
+        })
+        .map_err(|error| error.to_string())?;
+        let mut notification = notify_rust::Notification::new();
+        notification
+            .summary("Mint Agent")
+            .body(&body)
+            .appname("Mint Agent")
+            .action("default", "Open Mint");
+        #[cfg(target_os = "windows")]
+        if !tauri::is_dev() {
+            notification.app_id(&app.config().identifier);
+        }
+        let handle = notification.show().map_err(|error| error.to_string())?;
+        std::thread::spawn(move || {
+            handle.wait_for_action(|action| {
+                if action != "default" {
+                    return;
+                }
+                if let Some(main) = app.get_webview_window("main") {
+                    let _ = main.show();
+                    let _ = main.unminimize();
+                    let _ = main.set_focus();
+                    if let Some(chat_id) = &chat_id {
+                        let _ = main.emit(
+                            "notification-clicked",
+                            serde_json::json!({ "chatId": chat_id }),
+                        );
+                    }
+                }
+            });
+        });
+        Ok(())
+    })
+    .await
+    .map_err(|error| error.to_string())?
+}

package/src-tauri/src/native/plugins.rs

@@ -0,0 +1,14 @@
+use super::discord_rpc;
+use mint_core::MintConfig;
+pub async fn execute_plugin(
+    config: &MintConfig,
+    name: &str,
+    instruction: &str,
+) -> Result<String, String> {
+    match name {
+        "discord" => discord_rpc::set_activity(config, instruction),
+        other => mint_core::execute_native_plugin(config, other, instruction)
+            .await
+            .map_err(|error| error.to_string()),
+    }
+}

package/src-tauri/src/native/system.rs

@@ -0,0 +1,250 @@
+use mint_core::load_config;
+use serde::Serialize;
+use std::process::{Command, Stdio};
+
+use serde_json::{Value, json};
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SmartContext {
+    pub captured_at: String,
+    pub platform: &'static str,
+    pub host: String,
+    pub active_window: Option<Value>,
+    pub current_app: Option<Value>,
+    pub browser: Option<Value>,
+    pub selected_text: String,
+}
+
+pub async fn smart_context() -> SmartContext {
+    let active_window = linux_active_window();
+    let current_app = active_window.as_ref().map(|window| {
+        json!({
+            "name": window["appName"],
+            "processName": window["processName"],
+            "pid": window["pid"]
+        })
+    });
+    SmartContext {
+        captured_at: unix_timestamp().to_string(),
+        platform: std::env::consts::OS,
+        host: hostname(),
+        browser: browser_context(&active_window).await,
+        active_window,
+        current_app,
+        selected_text: selected_text(),
+    }
+}
+
+async fn browser_context(active_window: &Option<Value>) -> Option<Value> {
+    let is_chromium = active_window
+        .as_ref()
+        .and_then(|window| window["appName"].as_str())
+        .map(str::to_ascii_lowercase)
+        .is_some_and(|name| {
+            ["chrome", "chromium", "brave", "edge"]
+                .iter()
+                .any(|browser| name.contains(browser))
+        });
+    if is_chromium && let Some(context) = chromium_context().await {
+        return Some(context);
+    }
+    browser_extension_context().await
+}
+
+async fn chromium_context() -> Option<Value> {
+    let endpoint = load_config()
+        .ok()
+        .and_then(|config| {
+            config
+                .extra
+                .get("browserDebugUrl")
+                .and_then(Value::as_str)
+                .map(str::to_owned)
+        })
+        .unwrap_or_else(|| "http://127.0.0.1:9222/json/list".into());
+    let pages: Value = mint_core::HTTP_CLIENT
+        .clone()
+        .get(endpoint)
+        .send()
+        .await
+        .ok()?
+        .json()
+        .await
+        .ok()?;
+    pages
+        .as_array()?
+        .iter()
+        .find(|page| page["type"] == "page")
+        .map(|page| {
+            json!({
+                "title": page["title"],
+                "url": page["url"],
+                "source": "chromium-remote-debug"
+            })
+        })
+}
+
+async fn browser_extension_context() -> Option<Value> {
+    let endpoint = load_config()
+        .ok()
+        .and_then(|config| {
+            config
+                .extra
+                .get("browserExtensionContextUrl")
+                .and_then(Value::as_str)
+                .map(str::to_owned)
+        })
+        .unwrap_or_else(|| "http://127.0.0.1:3212/context".into());
+    if !(endpoint.starts_with("http://127.0.0.1:") || endpoint.starts_with("http://localhost:")) {
+        return None;
+    }
+    let context: Value = mint_core::HTTP_CLIENT
+        .clone()
+        .get(endpoint)
+        .send()
+        .await
+        .ok()?
+        .json()
+        .await
+        .ok()?;
+    Some(json!({
+        "title": context["title"],
+        "url": context["url"],
+        "source": "browser-extension"
+    }))
+}
+
+pub fn run_system_automation(target: &str, approved: bool) -> Result<String, String> {
+    let (command, value) = target.split_once(':').unwrap_or((target, ""));
+    match command {
+        "volume" => {
+            let value = percent(value)?;
+            run_first(&[
+                ("pactl", vec!["set-sink-volume", "@DEFAULT_SINK@", &value]),
+                ("amixer", vec!["-D", "pulse", "sset", "Master", &value]),
+            ])?;
+            Ok(format!("Volume set to {value}"))
+        }
+        "mute" => {
+            run_first(&[
+                ("pactl", vec!["set-sink-mute", "@DEFAULT_SINK@", "toggle"]),
+                ("amixer", vec!["-D", "pulse", "sset", "Master", "toggle"]),
+            ])?;
+            Ok("Volume toggled".into())
+        }
+        "brightness" => {
+            let value = percent(value)?;
+            run_first(&[
+                ("brightnessctl", vec!["set", &value]),
+                ("xbacklight", vec!["-set", value.trim_end_matches('%')]),
+            ])?;
+            Ok(format!("Brightness set to {value}"))
+        }
+        "minimize_all" => {
+            run("xdotool", &["key", "Super+d"])?;
+            Ok("Minimized all windows".into())
+        }
+        "sleep" => {
+            run("systemctl", &["suspend"])?;
+            Ok("Suspend requested".into())
+        }
+        "restart" | "shutdown" if !approved => {
+            Err(format!("'{command}' requires explicit approval"))
+        }
+        "restart" => {
+            run("systemctl", &["reboot"])?;
+            Ok("Restart requested".into())
+        }
+        "shutdown" => {
+            run("systemctl", &["poweroff"])?;
+            Ok("Shutdown requested".into())
+        }
+        _ => Err(format!("unsupported system automation command '{command}'")),
+    }
+}
+
+fn linux_active_window() -> Option<Value> {
+    let id = output("xdotool", &["getactivewindow"])?;
+    let title = output("xdotool", &["getwindowname", &id]).unwrap_or_default();
+    let pid = output("xdotool", &["getwindowpid", &id]).unwrap_or_default();
+    let process_name = output("ps", &["-p", &pid, "-o", "comm="]).unwrap_or_default();
+    Some(json!({
+        "id": id,
+        "title": title,
+        "appName": process_name,
+        "processName": process_name,
+        "pid": pid.parse::<u32>().ok(),
+        "platform": "linux"
+    }))
+}
+
+fn selected_text() -> String {
+    [
+        ("wl-paste", vec!["--primary", "--no-newline"]),
+        ("xclip", vec!["-selection", "primary", "-out"]),
+        ("xsel", vec!["--primary", "--output"]),
+    ]
+    .into_iter()
+    .find_map(|(program, args)| output(program, &args))
+    .unwrap_or_default()
+    .chars()
+    .take(2000)
+    .collect()
+}
+
+fn hostname() -> String {
+    output("hostname", &[]).unwrap_or_else(|| "unknown".into())
+}
+
+fn unix_timestamp() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or_default()
+}
+
+fn percent(raw: &str) -> Result<String, String> {
+    raw.parse::<u8>()
+        .ok()
+        .filter(|value| *value <= 100)
+        .map(|value| format!("{value}%"))
+        .ok_or_else(|| "percentage must be between 0 and 100".into())
+}
+
+fn run_first(commands: &[(&str, Vec<&str>)]) -> Result<(), String> {
+    let mut errors = Vec::new();
+    for (program, args) in commands {
+        match run(program, args) {
+            Ok(()) => return Ok(()),
+            Err(error) => errors.push(error),
+        }
+    }
+    Err(errors.join(" | "))
+}
+
+fn run(program: &str, args: &[&str]) -> Result<(), String> {
+    Command::new(program)
+        .args(args)
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map_err(|error| format!("unable to run '{program}': {error}"))
+        .and_then(|status| {
+            status
+                .success()
+                .then_some(())
+                .ok_or_else(|| format!("'{program}' exited with {status}"))
+        })
+}
+
+fn output(program: &str, args: &[&str]) -> Option<String> {
+    Command::new(program)
+        .args(args)
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
+        .filter(|output| !output.is_empty())
+}