@pheem49/mint 1.15.0 → 1.17.0

package/src-tauri/src/app/lifecycle.rs

@@ -0,0 +1,320 @@
+use crate::app::shortcuts::install_shortcuts;
+use crate::app::tray::install_tray;
+use crate::background::events::start_system_events;
+use crate::background::headless::start_headless_queue;
+use crate::background::proactive::start_loop as start_proactive_loop;
+use crate::commands::approvals::ApprovalsState;
+use crate::commands::voice::{GeminiLiveState, MicRecordingState};
+use crate::native::terminal::TerminalSessions;
+use crate::native::windows::{open_desktop_window, position_widget};
+use crate::{app, background, commands, native};
+use mint_core::{load_config, start_channels, start_cron_scheduler};
+use tauri::{AppHandle, Emitter, Manager};
+
+#[derive(Default)]
+struct CompanionNavigation(std::sync::Mutex<Option<String>>);
+
+#[tauri::command]
+fn pending_companion_chat(
+    state: tauri::State<'_, CompanionNavigation>,
+    acknowledged_id: Option<String>,
+) -> Option<String> {
+    let mut pending = state.0.lock().unwrap();
+    if acknowledged_id
+        .as_ref()
+        .is_some_and(|id| pending.as_ref() == Some(id))
+    {
+        *pending = None;
+    }
+    pending.clone()
+}
+
+#[tauri::command]
+pub(crate) fn exit_app(app: AppHandle) {
+    app.exit(0);
+}
+
+/// WebKitGTK denies every `permission-request` (microphone, camera, geolocation, ...) by
+/// default unless something handles the signal — Tauri/wry doesn't wire this up on Linux,
+/// which is why `getUserMedia()` rejects with `NotAllowedError` even though the user never
+/// saw (or could act on) a prompt. Auto-allow only mic/camera requests here; everything
+/// else falls through to WebKit's default (deny).
+#[cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+fn allow_media_permission_requests(window: &tauri::WebviewWindow) {
+    use webkit2gtk::{PermissionRequestExt, WebViewExt, glib::prelude::ObjectExt};
+    let _ = window.with_webview(|platform_webview| {
+        let webview = platform_webview.inner();
+        webview.connect_permission_request(|_webview, request| {
+            if request.is::<webkit2gtk::UserMediaPermissionRequest>() {
+                request.allow();
+                true
+            } else {
+                false
+            }
+        });
+    });
+}
+
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+)))]
+fn allow_media_permission_requests(_window: &tauri::WebviewWindow) {}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    if std::env::args().nth(1).as_deref() == Some("--mint-mod-host") {
+        if let Err(error) = mint_core::mods::worker_main() {
+            eprintln!("{error}");
+        }
+        return;
+    }
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .manage(CompanionNavigation::default())
+        .manage(ApprovalsState::default())
+        .manage(GeminiLiveState::default())
+        .manage(MicRecordingState::default())
+        .manage(TerminalSessions::default())
+        .manage(mint_core::avatar_bridge::AvatarBridge::new(
+            load_config()
+                .map(|c| mint_core::avatar_bridge::AvatarBridgeConfig::from_mint_config(&c))
+                .unwrap_or_else(|_| mint_core::avatar_bridge::AvatarBridgeConfig::from_env()),
+        ))
+        .setup(|app| {
+            // The embedded API also observes these signals, but its completion
+            // does not stop Tauri's event loop. Keep the host watcher independent
+            // so Ctrl+C still exits when the API port could not be bound.
+            let shutdown_app = app.handle().clone();
+            tauri::async_runtime::spawn(mint_core::api_server::shutdown_on_signal(move || {
+                shutdown_app.exit(0);
+            }));
+            if let Some(main_window) = app.get_webview_window("main") {
+                allow_media_permission_requests(&main_window);
+            }
+            std::thread::spawn(|| {
+                if let Err(error) = mint_core::library::LibraryStore::open_default() {
+                    eprintln!("[mint] Library startup: {error}")
+                }
+            });
+            let navigation_app = app.handle().clone();
+            mint_core::companion::navigation::configure(
+                mint_core::companion::navigation::Surface::Desktop,
+                move |session, _| {
+                    let main = navigation_app
+                        .get_webview_window("main")
+                        .ok_or("Mint window is unavailable")?;
+                    *navigation_app
+                        .state::<CompanionNavigation>()
+                        .0
+                        .lock()
+                        .unwrap() = Some(session.chat_id);
+                    main.show().map_err(|error| error.to_string())?;
+                    main.unminimize().map_err(|error| error.to_string())?;
+                    main.set_focus().map_err(|error| error.to_string())?;
+                    main.emit("companion-open-chat", ())
+                        .map_err(|error| error.to_string())?;
+                    Ok(mint_core::companion::navigation::NavigationOutcome::Opened)
+                },
+            );
+            install_tray(app.handle())?;
+            install_shortcuts(app.handle())?;
+            start_system_events(app.handle().clone());
+            start_headless_queue(app.handle().clone());
+            start_proactive_loop(app.handle().clone());
+            tauri::async_runtime::spawn(async {
+                mint_core::companion::start();
+                if let Err(error) = mint_core::start_api_server(3000).await {
+                    eprintln!("[mint] embedded API unavailable: {error}");
+                    start_channels();
+                    start_cron_scheduler();
+                }
+            });
+            if load_config()
+                .map(|config| config.show_desktop_widget)
+                .unwrap_or(false)
+            {
+                let _ = open_desktop_window(app.handle(), "widget");
+                position_widget(app.handle());
+            }
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            pending_companion_chat,
+            commands::mods::mods_operation,
+            native::notifications::send_mint_notification,
+            native::terminal::start_interactive_terminal,
+            native::terminal::write_interactive_terminal,
+            native::terminal::resize_interactive_terminal,
+            native::terminal::stop_interactive_terminal,
+            native::browser::open_mint_browser,
+            native::browser::close_mint_browser,
+            native::browser::show_mint_browser_suggestions,
+            native::browser::hide_mint_browser_suggestions,
+            native::browser::get_mint_browser_suggestion_query,
+            native::browser::navigate_mint_browser,
+            native::browser::browser_go_back,
+            native::browser::browser_go_forward,
+            native::browser::browser_reload,
+            commands::settings::get_runtime_status,
+            commands::settings::detect_system_tools,
+            commands::integrations::reauth_mcp_server,
+            commands::integrations::list_mcp_server_tools,
+            commands::integrations::test_mcp_connection,
+            commands::integrations::read_mcp_artifact,
+            commands::settings::fetch_provider_models,
+            commands::media::fetch_image_provider_models,
+            commands::media::fetch_video_provider_models,
+            commands::media::fetch_gemini_live_models,
+            commands::workspace::get_workspace_snapshot,
+            commands::workspace::get_git_branch_info,
+            commands::workspace::switch_git_branch,
+            commands::workspace::create_git_branch,
+            commands::workspace::checkout_remote_git_branch,
+            commands::workspace::get_git_graph,
+            commands::workspace::get_workspace_git_diff,
+            commands::workspace::create_workspace_file,
+            commands::workspace::create_workspace_folder,
+            commands::workspace::delete_workspace_item,
+            commands::workspace::move_workspace_item,
+            commands::workspace::list_workspace_history,
+            commands::workspace::undo_workspace_action,
+            commands::media::generate_images,
+            commands::media::generate_video,
+            commands::workspace::select_workspace_directory,
+            commands::settings::get_config,
+            commands::settings::get_updater_status,
+            commands::settings::check_for_updates,
+            commands::settings::install_available_update,
+            commands::settings::update_config,
+            commands::settings::set_active_model,
+            commands::settings::inspect_shell_command,
+            commands::conversation::send_chat_message,
+            commands::conversation::stream_chat_message,
+            commands::conversation::cancel_chat_message,
+            commands::voice::start_gemini_live_session,
+            commands::voice::send_gemini_live_audio_chunk,
+            commands::voice::stop_gemini_live_session,
+            commands::voice::start_mic_recording,
+            commands::voice::stop_mic_recording_and_transcribe,
+            commands::voice::cancel_mic_recording,
+            commands::conversation::submit_tool_approval,
+            commands::conversation::get_recent_interactions,
+            commands::conversation::get_conversation_snapshot,
+            commands::conversation::get_conversation_sources,
+            commands::conversation::save_source_attachments,
+            commands::conversation::get_conversation_changes,
+            commands::conversation::save_interaction_agent_activity,
+            commands::conversation::list_chat_sessions,
+            commands::conversation::delete_chat_session,
+            commands::conversation::rename_chat_session,
+            commands::auth::get_profile_value,
+            commands::auth::set_profile_value,
+            commands::auth::auth_register,
+            commands::auth::auth_login,
+            commands::auth::auth_logout,
+            commands::auth::auth_current_user,
+            commands::auth::auth_update_profile,
+            commands::auth::auth_upload_avatar,
+            commands::conversation::clear_chat_history,
+            commands::integrations::list_learned_skills,
+            commands::integrations::add_learned_skill,
+            commands::integrations::delete_learned_skill,
+            commands::integrations::list_subagents,
+            commands::integrations::save_subagent,
+            commands::integrations::delete_subagent,
+            commands::conversation::run_slash_command,
+            commands::workspace::list_background_jobs,
+            commands::workspace::start_html_preview,
+            commands::workspace::get_background_job,
+            commands::workspace::stop_background_job,
+            commands::workspace::remove_background_job,
+            commands::integrations::list_cron_jobs,
+            commands::integrations::add_cron_job,
+            commands::integrations::remove_cron_job,
+            commands::integrations::set_cron_job_enabled,
+            commands::workspace::list_linked_folders,
+            commands::workspace::add_linked_folder,
+            commands::workspace::remove_linked_folder,
+            commands::workspace::linked_folder_status,
+            commands::workspace::refresh_linked_folder,
+            commands::workspace::list_linked_folder_notes,
+            commands::workspace::read_linked_folder_note,
+            commands::workspace::save_linked_folder_note,
+            commands::workspace::open_linked_folder_note,
+            commands::media::list_library,
+            commands::media::get_library_item,
+            commands::media::set_library_trashed,
+            commands::media::remove_library_item,
+            commands::media::read_library_file,
+            commands::media::list_pictures,
+            commands::media::delete_picture,
+            commands::media::save_pictures,
+            commands::media::upload_file,
+            commands::workspace::open_folder,
+            commands::media::get_tts_urls,
+            commands::media::speech_request,
+            commands::media::get_weather,
+            commands::workspace::propose_desktop_code_edits,
+            commands::workspace::apply_desktop_code_edits,
+            commands::workspace::list_git_checkpoints,
+            commands::workspace::rollback_git_checkpoint,
+            commands::workspace::undo_git_checkpoint,
+            commands::workspace::read_workspace_file,
+            commands::workspace::read_workspace_image,
+            commands::workspace::prepare_workspace_media,
+            native::windows::open_window,
+            native::windows::hide_desktop_window,
+            native::windows::close_desktop_window,
+            native::windows::resize_desktop_window,
+            native::actions::run_desktop_action,
+            commands::integrations::get_integration_inventory,
+            commands::integrations::run_native_plugin,
+            native::capture::capture_chat_screen,
+            native::capture::read_clipboard_image,
+            native::capture::capture_translation_frame,
+            native::capture::translate_captured_frame,
+            native::actions::get_smart_context,
+            native::browser::get_browser_tabs,
+            native::browser::navigate_browser,
+            native::browser::read_browser_page,
+            native::browser::click_browser_selector,
+            native::browser::type_in_browser,
+            native::capture::start_live_translate,
+            native::capture::open_live_translate_controls,
+            native::capture::live_translate_geometry,
+            native::capture::set_live_translate_passthrough,
+            native::windows::submit_spotlight,
+            native::windows::set_ai_state,
+            background::proactive::toggle_proactive,
+            background::proactive::save_behavior_context,
+            background::headless::run_next_queued_task,
+            app::lifecycle::exit_app,
+            commands::conversation::save_system_interaction,
+            commands::conversation::update_chat_session_workspace
+        ])
+        .build(tauri::generate_context!())
+        .expect("error while running Mint desktop")
+        .run(|_app_handle, event| {
+            // Kill any stdio MCP child processes we spawned before the process
+            // goes away — `SESSIONS` is a `static`, so `McpSession::Drop` never
+            // runs at exit on its own. Fires for tray "Quit", `exit_app`, and
+            // the last window closing.
+            if let tauri::RunEvent::Exit = event {
+                mint_core::companion::shutdown();
+                mint_core::close_all_mcp_sessions();
+                mint_core::bg_shell::shutdown();
+            }
+        });
+}

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

@@ -0,0 +1,4 @@
+//! Desktop composition, startup/shutdown, tray and global shortcuts.
+pub(crate) mod lifecycle;
+pub(crate) mod shortcuts;
+pub(crate) mod tray;

package/src-tauri/src/app/shortcuts.rs

@@ -0,0 +1,40 @@
+use crate::native::capture::toggle_live_translate_interaction;
+use crate::native::windows::open_desktop_window;
+use tauri::{AppHandle, Manager};
+use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, Modifiers, Shortcut, ShortcutState};
+
+pub(crate) fn install_shortcuts(app: &AppHandle) -> tauri::Result<()> {
+    let main_shortcut = Shortcut::new(Some(Modifiers::CONTROL | Modifiers::SHIFT), Code::Space);
+    let spotlight_shortcut = Shortcut::new(Some(Modifiers::ALT), Code::Space);
+    let live_translate_shortcut =
+        Shortcut::new(Some(Modifiers::ALT | Modifiers::SHIFT), Code::KeyL);
+    let main_handler = main_shortcut;
+    let spotlight_handler = spotlight_shortcut;
+    let live_translate_handler = live_translate_shortcut;
+    app.plugin(
+        tauri_plugin_global_shortcut::Builder::new()
+            .with_handler(move |app, shortcut, event| {
+                if event.state() != ShortcutState::Pressed {
+                    return;
+                }
+                if shortcut == &main_handler {
+                    if let Some(window) = app.get_webview_window("main") {
+                        let _ = if window.is_visible().unwrap_or(false) {
+                            window.hide()
+                        } else {
+                            window.show()
+                        };
+                    }
+                } else if shortcut == &spotlight_handler {
+                    let _ = open_desktop_window(app, "spotlight");
+                } else if shortcut == &live_translate_handler {
+                    toggle_live_translate_interaction(app);
+                }
+            })
+            .build(),
+    )?;
+    let _ = app.global_shortcut().register(main_shortcut);
+    let _ = app.global_shortcut().register(spotlight_shortcut);
+    let _ = app.global_shortcut().register(live_translate_shortcut);
+    Ok(())
+}

package/src-tauri/src/app/tray.rs

@@ -0,0 +1,52 @@
+use crate::native::windows::{emit_to_main, open_desktop_window};
+use tauri::menu::{Menu, MenuItem};
+use tauri::tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent};
+use tauri::{AppHandle, Manager};
+
+pub(crate) fn install_tray(app: &AppHandle) -> tauri::Result<()> {
+    let show = MenuItem::with_id(app, "show", "Show Mint", true, None::<&str>)?;
+    let settings = MenuItem::with_id(app, "settings", "Settings", true, None::<&str>)?;
+    let spotlight = MenuItem::with_id(app, "spotlight", "Spotlight", true, None::<&str>)?;
+    let quit = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
+    let menu = Menu::with_items(app, &[&show, &settings, &spotlight, &quit])?;
+    let mut builder = TrayIconBuilder::new()
+        .tooltip("Mint AI Assistant")
+        .menu(&menu)
+        .on_menu_event(|app, event| match event.id().as_ref() {
+            "show" => {
+                let _ = app.get_webview_window("main").map(|window| window.show());
+            }
+            "settings" => {
+                emit_to_main(app, "open-settings", ());
+            }
+            "spotlight" => {
+                let _ = open_desktop_window(app, "spotlight");
+            }
+            "quit" => app.exit(0),
+            _ => {}
+        })
+        .on_tray_icon_event(|tray, event| {
+            if matches!(
+                event,
+                TrayIconEvent::Click {
+                    button: MouseButton::Left,
+                    button_state: MouseButtonState::Up,
+                    ..
+                }
+            ) {
+                let app = tray.app_handle();
+                if let Some(window) = app.get_webview_window("main") {
+                    let _ = if window.is_visible().unwrap_or(false) {
+                        window.hide()
+                    } else {
+                        window.show()
+                    };
+                }
+            }
+        });
+    if let Some(icon) = app.default_window_icon() {
+        builder = builder.icon(icon.clone());
+    }
+    builder.build(app)?;
+    Ok(())
+}

package/src-tauri/src/background/events.rs

@@ -0,0 +1,70 @@
+use serde_json::json;
+use std::{
+    fs,
+    net::{SocketAddr, TcpStream},
+    path::Path,
+    thread,
+    time::Duration,
+};
+
+use tauri::{AppHandle, Emitter, Manager};
+
+pub fn start_system_events(app: AppHandle) {
+    thread::spawn(move || {
+        let mut last_battery = None;
+        let mut last_online = None;
+        loop {
+            let battery = battery_level(Path::new("/sys/class/power_supply"));
+            if let Some(level) = battery
+                .filter(|level| *level <= 20 && last_battery.is_none_or(|previous| previous > 20))
+            {
+                emit_notification(
+                    &app,
+                    json!({ "message": format!("Battery is low ({level}%). Please plug in your charger."), "type": "warning" }),
+                );
+            }
+            last_battery = battery;
+
+            let online = network_online();
+            if last_online.is_some_and(|previous| previous != online) {
+                emit_notification(
+                    &app,
+                    json!({
+                        "message": if online { "Internet connection restored." } else { "Internet connection lost." },
+                        "type": "info"
+                    }),
+                );
+            }
+            last_online = Some(online);
+            thread::sleep(Duration::from_secs(60));
+        }
+    });
+}
+
+fn emit_notification(app: &AppHandle, payload: serde_json::Value) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit("proactive-notification", payload);
+    }
+}
+
+fn battery_level(root: &Path) -> Option<u8> {
+    fs::read_dir(root).ok()?.flatten().find_map(|entry| {
+        let name = entry.file_name().to_string_lossy().to_ascii_uppercase();
+        if !name.starts_with("BAT") {
+            return None;
+        }
+        fs::read_to_string(entry.path().join("capacity"))
+            .ok()?
+            .trim()
+            .parse()
+            .ok()
+    })
+}
+
+fn network_online() -> bool {
+    "1.1.1.1:53"
+        .parse::<SocketAddr>()
+        .ok()
+        .and_then(|address| TcpStream::connect_timeout(&address, Duration::from_secs(2)).ok())
+        .is_some()
+}