@pheem49/mint 1.6.1 → 1.6.3

package/src-tauri/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    mint_desktop_lib::run()
+}

package/src-tauri/src/plugins.rs

@@ -0,0 +1,16 @@
+use mint_core::MintConfig;
+
+use crate::discord_rpc;
+
+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/proactive.rs

@@ -0,0 +1,254 @@
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::PathBuf,
+    sync::{
+        LazyLock, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
+};
+
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use mint_core::{MintConfig, config_path, load_config};
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use tauri::{AppHandle, Emitter, Manager};
+
+use crate::desktop::capture_screen_bytes;
+
+const DEFAULT_INTERVAL_SECONDS: u64 = 60;
+const DEFAULT_COOLDOWN_SECONDS: u64 = 120;
+const MAX_CONTEXT_HISTORY: usize = 20;
+const PROMPT: &str = r#"You are Mint's desktop suggestion engine. Analyze the screenshot and return only JSON:
+{"context":"short English description","message":"short Thai message or null","suggestions":[{"label":"1-3 words","action":{"type":"open_url|open_app|search|none","target":"..."}}]}
+Return an empty suggestions array when there is no clear useful opportunity. Provide at most 4 suggestions. Never suggest shell commands."#;
+
+static ENABLED: AtomicBool = AtomicBool::new(false);
+static LAST_SUGGESTION: LazyLock<Mutex<Option<(Instant, String)>>> =
+    LazyLock::new(|| Mutex::new(None));
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct BehaviorMemory {
+    #[serde(default)]
+    app_frequency: BTreeMap<String, u64>,
+    #[serde(default)]
+    context_history: Vec<BehaviorEntry>,
+    #[serde(default)]
+    last_updated: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct BehaviorEntry {
+    context: String,
+    time: String,
+}
+
+pub fn set_enabled(enabled: bool) {
+    ENABLED.store(enabled, Ordering::Relaxed);
+}
+
+pub fn record_behavior(context: &str) -> Result<(), String> {
+    let context = context.trim();
+    if context.is_empty() {
+        return Ok(());
+    }
+    let mut memory = load_behavior()?;
+    memory.context_history.insert(
+        0,
+        BehaviorEntry {
+            context: context.into(),
+            time: timestamp(),
+        },
+    );
+    memory.context_history.truncate(MAX_CONTEXT_HISTORY);
+    for app in [
+        "YouTube", "Chrome", "Firefox", "VS Code", "Spotify", "Terminal", "Google", "Discord",
+        "Slack", "Gmail", "GitHub", "Figma", "Notion",
+    ] {
+        if context
+            .to_ascii_lowercase()
+            .contains(&app.to_ascii_lowercase())
+        {
+            *memory.app_frequency.entry(app.into()).or_default() += 1;
+        }
+    }
+    memory.last_updated = Some(timestamp());
+    save_behavior(&memory)
+}
+
+pub fn start_loop(app: AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        loop {
+            if !ENABLED.load(Ordering::Relaxed) {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                continue;
+            }
+            let config = match load_config() {
+                Ok(config) => config,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_secs(DEFAULT_INTERVAL_SECONDS)).await;
+                    continue;
+                }
+            };
+            if let Ok(Some(suggestion)) = analyze(&config).await {
+                if let Some(context) = suggestion["context"].as_str() {
+                    let _ = record_behavior(context);
+                }
+                if let Some(main) = app.get_webview_window("main") {
+                    let _ = main.emit("proactive-suggestion", suggestion);
+                }
+            }
+            tokio::time::sleep(Duration::from_secs(config_u64(
+                &config,
+                "proactiveInterval",
+                DEFAULT_INTERVAL_SECONDS,
+            )))
+            .await;
+        }
+    });
+}
+
+async fn analyze(config: &MintConfig) -> Result<Option<Value>, String> {
+    let key = if config.api_key.trim().is_empty() {
+        std::env::var("GEMINI_API_KEY").unwrap_or_default()
+    } else {
+        config.api_key.clone()
+    };
+    if key.trim().is_empty() || cooling_down(config) {
+        return Ok(None);
+    }
+    let image = capture_screen_bytes()?;
+    let response: Value = mint_core::HTTP_CLIENT
+        .clone()
+        .post(format!(
+            "https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent?key={key}",
+            config.gemini_model
+        ))
+        .json(&json!({
+            "systemInstruction": { "parts": [{ "text": PROMPT }] },
+            "contents": [{ "role": "user", "parts": [
+                { "text": format!("Behavior context: {}", behavior_summary()?) },
+                { "inlineData": { "mimeType": "image/png", "data": STANDARD.encode(image) } }
+            ]}],
+            "generationConfig": { "responseMimeType": "application/json" }
+        }))
+        .send()
+        .await
+        .map_err(|error| error.to_string())?
+        .error_for_status()
+        .map_err(|error| error.to_string())?
+        .json()
+        .await
+        .map_err(|error| error.to_string())?;
+    let Some(raw) = response["candidates"][0]["content"]["parts"][0]["text"].as_str() else {
+        return Ok(None);
+    };
+    let mut suggestion: Value = serde_json::from_str(raw).map_err(|error| error.to_string())?;
+    let has_message = suggestion["message"].as_str().is_some();
+    let Some(items) = suggestion["suggestions"].as_array_mut() else {
+        return Ok(None);
+    };
+    items.retain(|item| {
+        item["action"]["type"]
+            .as_str()
+            .is_some_and(|kind| matches!(kind, "open_url" | "open_app" | "search" | "none"))
+    });
+    items.truncate(4);
+    if !has_message || items.is_empty() {
+        return Ok(None);
+    }
+    let context = suggestion["context"]
+        .as_str()
+        .unwrap_or_default()
+        .to_owned();
+    let mut last = LAST_SUGGESTION.lock().map_err(|error| error.to_string())?;
+    if last
+        .as_ref()
+        .is_some_and(|(_, previous)| previous == &context)
+    {
+        return Ok(None);
+    }
+    *last = Some((Instant::now(), context));
+    Ok(Some(suggestion))
+}
+
+fn cooling_down(config: &MintConfig) -> bool {
+    LAST_SUGGESTION
+        .lock()
+        .ok()
+        .and_then(|value| value.as_ref().map(|(time, _)| time.elapsed()))
+        .is_some_and(|elapsed| {
+            elapsed
+                < Duration::from_secs(config_u64(
+                    config,
+                    "proactiveCooldown",
+                    DEFAULT_COOLDOWN_SECONDS,
+                ))
+        })
+}
+
+fn behavior_summary() -> Result<String, String> {
+    let memory = load_behavior()?;
+    let recent = memory
+        .context_history
+        .iter()
+        .take(3)
+        .map(|entry| entry.context.as_str())
+        .collect::<Vec<_>>()
+        .join(" | ");
+    let mut apps = memory.app_frequency.into_iter().collect::<Vec<_>>();
+    apps.sort_by(|left, right| right.1.cmp(&left.1));
+    let apps = apps
+        .into_iter()
+        .take(5)
+        .map(|(app, count)| format!("{app} ({count}x)"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    Ok(format!(
+        "Frequent apps: {apps}. Recent activities: {recent}."
+    ))
+}
+
+fn behavior_path() -> Result<PathBuf, String> {
+    Ok(config_path()
+        .map_err(|error| error.to_string())?
+        .with_file_name("behavior_memory.json"))
+}
+
+fn load_behavior() -> Result<BehaviorMemory, String> {
+    let path = behavior_path()?;
+    if !path.exists() {
+        return Ok(BehaviorMemory::default());
+    }
+    serde_json::from_str(&fs::read_to_string(&path).map_err(|error| error.to_string())?)
+        .map_err(|error| error.to_string())
+}
+
+fn save_behavior(memory: &BehaviorMemory) -> Result<(), String> {
+    let path = behavior_path()?;
+    let directory = path
+        .parent()
+        .ok_or_else(|| "behavior memory directory is unavailable".to_string())?;
+    fs::create_dir_all(directory).map_err(|error| error.to_string())?;
+    let raw = serde_json::to_string_pretty(memory).map_err(|error| error.to_string())?;
+    fs::write(path, format!("{raw}\n")).map_err(|error| error.to_string())
+}
+
+fn config_u64(config: &MintConfig, key: &str, default: u64) -> u64 {
+    config
+        .extra
+        .get(key)
+        .and_then(Value::as_u64)
+        .unwrap_or(default)
+        .max(5)
+}
+
+fn timestamp() -> String {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+        .to_string()
+}

package/src-tauri/src/system.rs

@@ -0,0 +1,250 @@
+use std::process::{Command, Stdio};
+
+use mint_core::load_config;
+use serde::Serialize;
+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())
+}

package/src-tauri/src/updater.rs

@@ -0,0 +1,148 @@
+use mint_core::MintConfig;
+use serde::Serialize;
+use tauri::{AppHandle, Runtime};
+use tauri_plugin_updater::UpdaterExt;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateChannelStatus {
+    pub current_version: &'static str,
+    pub configured: bool,
+    pub endpoint: String,
+    pub public_key_configured: bool,
+    pub automatic_install: bool,
+    pub message: &'static str,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AvailableUpdate {
+    pub current_version: String,
+    pub version: String,
+    pub notes: Option<String>,
+    pub available: bool,
+}
+
+pub fn status(config: &MintConfig) -> UpdateChannelStatus {
+    let endpoint = string_value(config, "updaterEndpoint");
+    let public_key_configured = !string_value(config, "updaterPublicKey").trim().is_empty();
+    UpdateChannelStatus {
+        current_version: env!("CARGO_PKG_VERSION"),
+        configured: !endpoint.trim().is_empty() && public_key_configured,
+        endpoint,
+        public_key_configured,
+        automatic_install: false,
+        message: "Signed Tauri update channel status only; automatic installation is disabled.",
+    }
+}
+
+pub async fn check<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+) -> Result<AvailableUpdate, String> {
+    let updater = updater(app, config)?;
+    let current_version = env!("CARGO_PKG_VERSION").to_owned();
+    match updater.check().await.map_err(|error| error.to_string())? {
+        Some(update) => Ok(AvailableUpdate {
+            current_version,
+            version: update.version.clone(),
+            notes: update.body.clone(),
+            available: true,
+        }),
+        None => Ok(AvailableUpdate {
+            version: current_version.clone(),
+            current_version,
+            notes: None,
+            available: false,
+        }),
+    }
+}
+
+pub async fn install<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+    approved: bool,
+) -> Result<String, String> {
+    require_install_approval(approved)?;
+    let Some(update) = updater(app, config)?
+        .check()
+        .await
+        .map_err(|error| error.to_string())?
+    else {
+        return Ok("Mint is already up to date.".into());
+    };
+    let version = update.version.clone();
+    update
+        .download_and_install(|_, _| {}, || {})
+        .await
+        .map_err(|error| error.to_string())?;
+    Ok(format!(
+        "Installed Mint {version}. Restart Mint to use the new version."
+    ))
+}
+
+fn require_install_approval(approved: bool) -> Result<(), String> {
+    approved
+        .then_some(())
+        .ok_or_else(|| "update installation requires explicit user approval".into())
+}
+
+fn updater<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+) -> Result<tauri_plugin_updater::Updater, String> {
+    let endpoint = string_value(config, "updaterEndpoint");
+    let public_key = string_value(config, "updaterPublicKey");
+    if endpoint.trim().is_empty() || public_key.trim().is_empty() {
+        return Err(
+            "configure updaterEndpoint and updaterPublicKey before checking updates".into(),
+        );
+    }
+    app.updater_builder()
+        .pubkey(public_key)
+        .endpoints(vec![
+            endpoint
+                .parse()
+                .map_err(|error| format!("invalid updater endpoint: {error}"))?,
+        ])
+        .map_err(|error| error.to_string())?
+        .build()
+        .map_err(|error| error.to_string())
+}
+
+fn string_value(config: &MintConfig, key: &str) -> String {
+    config
+        .extra
+        .get(key)
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or_default()
+        .to_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn requires_endpoint_and_public_key_without_enabling_installation() {
+        let mut config = MintConfig::default();
+        config.extra.insert(
+            "updaterEndpoint".into(),
+            "https://updates.example.com/latest.json".into(),
+        );
+        config
+            .extra
+            .insert("updaterPublicKey".into(), "RWQexample".into());
+        let status = status(&config);
+        assert!(status.configured);
+        assert!(!status.automatic_install);
+    }
+
+    #[test]
+    fn rejects_install_without_explicit_approval() {
+        assert_eq!(
+            require_install_approval(false).unwrap_err(),
+            "update installation requires explicit user approval"
+        );
+    }
+}