@pheem49/mint 1.15.0 → 1.16.0

package/src-tauri/src/commands/integrations.rs

@@ -0,0 +1,157 @@
+use crate::commands::workspace::workspace_root;
+use crate::native::integrations::{channel_inventory, list_plugins};
+use crate::native::plugins::execute_plugin;
+use mint_core::{
+    CronJob, CronJobDraft, CronStore, MemoryStore, SubagentDefinition, SubagentDraft,
+    delete_subagent as core_delete_subagent, list_subagents as core_list_subagents, load_config,
+    reauth_mcp_server as core_reauth_mcp_server, save_subagent as core_save_subagent,
+};
+use serde_json::Value;
+
+type LearnedSkillDto = mint_core::skill_inventory::AvailableSkill;
+
+/// Re-runs a configured MCP server's OAuth login in the foreground (fixes an
+/// expired/invalid refresh token, e.g. `invalid_grant` from a Gmail MCP
+/// server). The underlying core call is blocking (spawns a child process and
+/// waits on it while streaming its output), so it runs on a blocking thread
+/// pool task rather than the async runtime.
+#[tauri::command]
+pub(crate) async fn reauth_mcp_server(server_name: String) -> Result<bool, String> {
+    tokio::task::spawn_blocking(move || core_reauth_mcp_server(&server_name))
+        .await
+        .map_err(|error| format!("reauth task failed: {error}"))?
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn list_mcp_server_tools(name: String) -> Result<Vec<String>, String> {
+    tokio::task::spawn_blocking(move || mint_core::mcp_server_tool_names(&name))
+        .await
+        .map_err(|error| format!("list-tools task failed: {error}"))?
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn test_mcp_connection(
+    url: String,
+    headers: Option<std::collections::BTreeMap<String, String>>,
+) -> Result<serde_json::Value, String> {
+    tokio::task::spawn_blocking(move || mint_core::test_remote_mcp_connection(&url, headers))
+        .await
+        .map_err(|error| format!("test-mcp-connection task failed: {error}"))?
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn read_mcp_artifact(id: String) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || {
+        use base64::Engine as _;
+        let (entry, bytes) = mint_core::integrations::mcp_result::read_artifact(&id)?;
+        let mime = if entry.kind == "image" {
+            entry.mime_type
+        } else {
+            "application/octet-stream".into()
+        };
+        Ok(format!(
+            "data:{mime};base64,{}",
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        ))
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+pub(crate) fn list_learned_skills(
+    workspace_path: Option<String>,
+) -> Result<Vec<LearnedSkillDto>, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    let root = workspace_root(workspace_path.as_deref()).ok();
+    mint_core::skill_inventory::list_available_skills(&store, root.as_deref())
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn add_learned_skill(name: String, content: String) -> Result<LearnedSkillDto, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    let skill = store
+        .add_learned_skill(&name, "ui_manual", &content)
+        .map_err(|e| e.to_string())?;
+    Ok(skill.into())
+}
+
+#[tauri::command]
+pub(crate) fn delete_learned_skill(name: String) -> Result<usize, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    store.delete_learned_skill(&name).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn list_subagents(
+    workspace_path: Option<String>,
+) -> Result<Vec<SubagentDefinition>, String> {
+    let root = workspace_root(workspace_path.as_deref()).ok();
+    Ok(core_list_subagents(root.as_deref()))
+}
+
+#[tauri::command]
+pub(crate) fn save_subagent(
+    draft: SubagentDraft,
+    workspace_path: Option<String>,
+) -> Result<SubagentDefinition, String> {
+    let root = workspace_root(workspace_path.as_deref()).ok();
+    core_save_subagent(&draft, root.as_deref())
+}
+
+#[tauri::command]
+pub(crate) fn delete_subagent(source_path: String) -> Result<(), String> {
+    core_delete_subagent(&source_path)
+}
+
+#[tauri::command]
+pub(crate) fn list_cron_jobs() -> Result<Vec<CronJob>, String> {
+    CronStore::open_default()
+        .and_then(|store| store.list())
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn add_cron_job(draft: CronJobDraft) -> Result<CronJob, String> {
+    let store = CronStore::open_default().map_err(|e| e.to_string())?;
+    store
+        .add(draft.name, draft.schedule, draft.task, draft.workspace)
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn remove_cron_job(id: String) -> Result<bool, String> {
+    CronStore::open_default()
+        .and_then(|store| store.remove(&id))
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn set_cron_job_enabled(id: String, enabled: bool) -> Result<Option<CronJob>, String> {
+    CronStore::open_default()
+        .and_then(|store| store.set_enabled(&id, enabled))
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn get_integration_inventory() -> Result<Value, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    Ok(serde_json::json!({
+        "mcpServers": mint_core::configured_mcp_servers(&config)
+            .map_err(|error| error.to_string())?
+            .keys()
+            .collect::<Vec<_>>(),
+        "plugins": list_plugins(&config),
+        "channels": channel_inventory(&config)
+    }))
+}
+
+#[tauri::command]
+pub(crate) async fn run_native_plugin(name: String, instruction: String) -> Result<String, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    execute_plugin(&config, &name, &instruction).await
+}

package/src-tauri/src/commands/media.rs

@@ -0,0 +1,179 @@
+use mint_core::{
+    ImageGenRequest, PictureEntry, TtsUrl, VideoGenRequest, VideoGenResponse, WeatherReport,
+    delete_saved_picture, google_tts_urls, list_saved_pictures, load_config, save_chat_images,
+    weather,
+};
+pub(crate) type DesktopImageGenResponse = mint_core::image_workflow::SavedImageGenResponse;
+
+/// Returns discovered image models followed by missing presets.
+#[tauri::command]
+pub(crate) async fn fetch_image_provider_models(
+    provider: String,
+    api_key: String,
+) -> Result<Vec<String>, String> {
+    let config = load_config().map_err(|e| e.to_string())?;
+    Ok(mint_core::model_catalog::image_models(&config, &provider, &api_key).await)
+}
+
+/// Returns discovered video models followed by missing presets.
+#[tauri::command]
+pub(crate) async fn fetch_video_provider_models(
+    provider: String,
+    api_key: String,
+) -> Result<Vec<String>, String> {
+    let config = load_config().map_err(|e| e.to_string())?;
+    Ok(mint_core::model_catalog::video_models(&config, &provider, &api_key).await)
+}
+
+/// Returns discovered Gemini Live models followed by missing presets.
+#[tauri::command]
+pub(crate) async fn fetch_gemini_live_models(api_key: String) -> Result<Vec<String>, String> {
+    let config = load_config().map_err(|e| e.to_string())?;
+    Ok(mint_core::model_catalog::live_models(&config, &api_key).await)
+}
+
+#[tauri::command]
+pub(crate) async fn generate_images(
+    request: ImageGenRequest,
+) -> Result<DesktopImageGenResponse, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+
+    mint_core::image_workflow::generate_and_save_images(&config, &request)
+        .await
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn generate_video(request: VideoGenRequest) -> Result<VideoGenResponse, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    mint_core::generate_video(&config, &request)
+        .await
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn list_pictures() -> Result<Vec<PictureEntry>, String> {
+    list_saved_pictures().map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn delete_picture(id: String) -> Result<(), String> {
+    delete_saved_picture(&id).map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn save_pictures(
+    images: Vec<String>,
+    source: Option<String>,
+    message: Option<String>,
+) -> Result<Vec<PictureEntry>, String> {
+    save_chat_images(images, source, message).map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn upload_file(filename: String, data_b64: String) -> Result<String, String> {
+    // Determine mime from filename
+    let mime = filename
+        .rsplit_once('.')
+        .map(|(_, ext)| match ext.to_ascii_lowercase().as_str() {
+            "mp4" => "video/mp4",
+            "webm" => "video/webm",
+            "mov" => "video/quicktime",
+            "mkv" => "video/x-matroska",
+            "avi" => "video/x-msvideo",
+            _ => "application/octet-stream",
+        })
+        .unwrap_or("application/octet-stream");
+
+    let data_uri = format!("data:{};base64,{}", mime, data_b64);
+    match save_chat_images(
+        vec![data_uri],
+        Some("upload".into()),
+        Some("uploaded".into()),
+    ) {
+        Ok(mut saved) => {
+            if let Some(entry) = saved.pop() {
+                return Ok(format!("/api/pictures/{}", entry.filename));
+            }
+            Err("no entry saved".into())
+        }
+        Err(e) => Err(e.to_string()),
+    }
+}
+
+#[tauri::command]
+pub(crate) fn get_tts_urls(text: String) -> Result<Vec<TtsUrl>, String> {
+    let language = load_config().map_err(|error| error.to_string())?.language;
+    Ok(google_tts_urls(&text, &language))
+}
+
+#[tauri::command]
+pub(crate) async fn get_weather(city: String) -> Result<WeatherReport, String> {
+    weather(&city).await.map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn list_library(
+    query: mint_core::library::LibraryQuery,
+) -> Result<mint_core::library::LibraryPage, String> {
+    tokio::task::spawn_blocking(move || {
+        mint_core::library::LibraryStore::open_default()
+            .and_then(|s| s.list(&query))
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+#[tauri::command]
+pub(crate) async fn get_library_item(
+    id: String,
+) -> Result<mint_core::library::LibraryItem, String> {
+    tokio::task::spawn_blocking(move || {
+        mint_core::library::LibraryStore::open_default()
+            .and_then(|s| s.get(&id))
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+#[tauri::command]
+pub(crate) async fn set_library_trashed(id: String, trashed: bool) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        mint_core::library::LibraryStore::open_default()
+            .and_then(|s| s.set_trashed(&id, trashed))
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+#[tauri::command]
+pub(crate) async fn read_library_file(id: String, thumbnail: bool) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || {
+        use base64::Engine;
+        let (item, bytes) = mint_core::library::LibraryStore::open_default()
+            .and_then(|s| s.read(&id, thumbnail))
+            .map_err(|e| e.to_string())?;
+        Ok(format!(
+            "data:{};base64,{}",
+            if thumbnail {
+                "image/png"
+            } else {
+                &item.mime_type
+            },
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        ))
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+pub(crate) async fn remove_library_item(id: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        mint_core::library::LibraryStore::open_default()
+            .and_then(|s| s.remove(&id))
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}

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

@@ -0,0 +1,11 @@
+//! Domain IPC adapters. Keep wire command names and payloads stable.
+pub(crate) mod approvals;
+pub(crate) mod auth;
+pub(crate) mod conversation;
+pub(crate) mod integrations;
+pub(crate) mod media;
+pub(crate) mod settings;
+pub(crate) mod voice;
+pub(crate) mod workspace;
+
+pub(crate) mod mods;

package/src-tauri/src/commands/mods.rs

@@ -0,0 +1,6 @@
+#[tauri::command]
+pub(crate) async fn mods_operation(
+    operation: mint_core::mods::Operation,
+) -> Result<serde_json::Value, String> {
+    mint_core::mods::operate_async(operation).await
+}

package/src-tauri/src/commands/settings.rs

@@ -0,0 +1,141 @@
+use crate::native::actions::integration_status;
+use crate::native::updater::{
+    AvailableUpdate, UpdateChannelStatus, check as check_update, install as install_update,
+    status as updater_status,
+};
+use crate::native::windows::{close_window, open_desktop_window, position_widget};
+use mint_core::{MintConfig, classify_shell_command, config_path, load_config, save_config};
+use serde::Serialize;
+use serde_json::Value;
+use tauri::{AppHandle, Emitter, Manager};
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct RuntimeStatus {
+    backend: &'static str,
+    config_path: String,
+    active_provider: String,
+    active_model: String,
+    available_providers: Vec<String>,
+    integrations: Value,
+}
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DetectedTools {
+    pub docker: bool,
+    pub git: bool,
+    pub gh: bool,
+    pub node: bool,
+}
+
+#[tauri::command]
+pub(crate) fn get_runtime_status() -> Result<RuntimeStatus, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    Ok(RuntimeStatus {
+        backend: "rust",
+        config_path: config_path()
+            .map_err(|error| error.to_string())?
+            .display()
+            .to_string(),
+        active_provider: config.ai_provider.clone(),
+        active_model: config.active_model().to_string(),
+        available_providers: config.available_providers(),
+        integrations: integration_status(&config),
+    })
+}
+
+#[tauri::command]
+pub(crate) fn get_config() -> Result<MintConfig, String> {
+    load_config().map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn get_updater_status() -> Result<UpdateChannelStatus, String> {
+    Ok(updater_status(
+        &load_config().map_err(|error| error.to_string())?,
+    ))
+}
+
+#[tauri::command]
+pub(crate) async fn check_for_updates(app: AppHandle) -> Result<AvailableUpdate, String> {
+    check_update(&app, &load_config().map_err(|error| error.to_string())?).await
+}
+
+#[tauri::command]
+pub(crate) async fn install_available_update(
+    app: AppHandle,
+    approved: bool,
+) -> Result<String, String> {
+    install_update(
+        &app,
+        &load_config().map_err(|error| error.to_string())?,
+        approved,
+    )
+    .await
+}
+
+#[tauri::command]
+pub(crate) fn update_config(app: AppHandle, config: MintConfig) -> Result<(), String> {
+    save_config(&config).map_err(|error| error.to_string())?;
+    let _ = app.emit("settings-changed", &config);
+    if config.show_desktop_widget {
+        let _ = open_desktop_window(&app, "widget");
+        position_widget(&app);
+    } else if app.get_webview_window("widget").is_some() {
+        let _ = close_window(&app, "widget");
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub(crate) fn set_active_model(
+    app: AppHandle,
+    provider: String,
+    model: Option<String>,
+) -> Result<String, String> {
+    let mut config = load_config().map_err(|error| error.to_string())?;
+    let display_name = config
+        .set_active_model(&provider, model.as_deref())
+        .map_err(|error| error.to_string())?;
+    let _ = app.emit("settings-changed", &config);
+    Ok(display_name)
+}
+
+#[tauri::command]
+pub(crate) fn inspect_shell_command(command: String) -> mint_core::ShellClassification {
+    classify_shell_command(&command)
+}
+
+#[tauri::command]
+pub(crate) async fn detect_system_tools() -> Result<DetectedTools, String> {
+    Ok(DetectedTools {
+        docker: mint_core::config::which("docker"),
+        git: mint_core::config::which("git"),
+        gh: mint_core::config::which("gh"),
+        node: mint_core::config::which("node"),
+    })
+}
+
+/// Fetch the live model list for `provider` from its API.
+///
+/// Returns the provider list with the same preset fallback policy
+/// used by the CLI picker. The UI form can supply an API key not yet saved to
+/// config.
+#[tauri::command]
+pub(crate) async fn fetch_provider_models(
+    provider: String,
+    api_key: String,
+    base_url: Option<String>,
+) -> Result<Vec<String>, String> {
+    let config = load_config().map_err(|e| e.to_string())?;
+    Ok(
+        mint_core::slash::models::model_options_for_provider_with_credentials_async(
+            &config,
+            &provider,
+            &api_key,
+            base_url.as_deref(),
+        )
+        .await,
+    )
+}

package/src-tauri/src/commands/voice.rs

@@ -0,0 +1,153 @@
+use crate::commands::approvals;
+use crate::commands::workspace::workspace_root;
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
+use mint_core::{
+    GeminiLiveEvent, GeminiLiveHandle, MicRecordingHandle, load_config,
+    start_gemini_live_session as core_start_gemini_live_session,
+    start_recording as core_start_mic_recording, stop_recording as core_stop_mic_recording,
+    transcribe_recording as core_transcribe_mic_recording,
+};
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::sync::atomic::{AtomicU64, Ordering};
+use tauri::AppHandle;
+use tauri::ipc::Channel;
+
+#[derive(Default)]
+pub struct GeminiLiveState {
+    pub sessions: Mutex<HashMap<String, GeminiLiveHandle>>,
+}
+
+#[derive(Default)]
+pub struct MicRecordingState {
+    pub active: Mutex<Option<MicRecordingHandle>>,
+}
+
+#[derive(serde::Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct GeminiLiveStartRequest {
+    #[serde(default)]
+    workspace_path: Option<String>,
+    #[serde(default)]
+    chat_id: Option<String>,
+}
+
+static COUNTER: AtomicU64 = AtomicU64::new(1);
+
+/// Starts a Gemini Live realtime voice session (beta, opt-in voice mode) and returns a
+/// session id used by `send_gemini_live_audio_chunk`/`stop_gemini_live_session`. Session
+/// events (audio replies, transcripts, tool-call status) stream back through `on_event`.
+/// Tool calls triggered by voice go through the same approval flow as typed chat, reusing
+/// the existing `tool-approval-requested` event / `ApprovalsState` bridge.
+#[tauri::command]
+pub(crate) async fn start_gemini_live_session(
+    app: AppHandle,
+    state: tauri::State<'_, GeminiLiveState>,
+    request: GeminiLiveStartRequest,
+    on_event: Channel<GeminiLiveEvent>,
+) -> Result<String, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    let root = workspace_root(request.workspace_path.as_deref())?;
+    let chat_id = request.chat_id.unwrap_or_default();
+    let session_id = format!("gemini-live-{}", COUNTER.fetch_add(1, Ordering::SeqCst));
+
+    let approve_cb = approvals::callback(app.clone(), chat_id.clone());
+
+    let handle = core_start_gemini_live_session(config, root, chat_id, approve_cb, move |event| {
+        let _ = on_event.send(event);
+    });
+
+    state
+        .sessions
+        .lock()
+        .map_err(|e| e.to_string())?
+        .insert(session_id.clone(), handle);
+    Ok(session_id)
+}
+
+#[tauri::command]
+pub(crate) async fn send_gemini_live_audio_chunk(
+    state: tauri::State<'_, GeminiLiveState>,
+    session_id: String,
+    chunk_base64: String,
+) -> Result<(), String> {
+    let pcm = BASE64
+        .decode(chunk_base64)
+        .map_err(|e| format!("invalid audio chunk: {e}"))?;
+    let sessions = state.sessions.lock().map_err(|e| e.to_string())?;
+    let handle = sessions
+        .get(&session_id)
+        .ok_or_else(|| "Gemini Live session not found".to_string())?;
+    handle.push_audio(pcm)
+}
+
+#[tauri::command]
+pub(crate) async fn stop_gemini_live_session(
+    state: tauri::State<'_, GeminiLiveState>,
+    session_id: String,
+) -> Result<(), String> {
+    state
+        .sessions
+        .lock()
+        .map_err(|e| e.to_string())?
+        .remove(&session_id);
+    Ok(())
+}
+
+/// Starts native push-to-talk mic recording (Rust-side, via `cpal`) for the desktop
+/// build's voice input button. Call `stop_mic_recording_and_transcribe` to stop and
+/// get the transcript back.
+#[tauri::command]
+pub(crate) fn start_mic_recording(
+    state: tauri::State<'_, MicRecordingState>,
+) -> Result<(), String> {
+    let mut active = state.active.lock().map_err(|e| e.to_string())?;
+    if active.is_some() {
+        return Err("A recording is already in progress".into());
+    }
+    let handle = core_start_mic_recording().map_err(|e| e.to_string())?;
+    *active = Some(handle);
+    Ok(())
+}
+
+/// Stops the in-progress recording and transcribes it using whichever provider is
+/// configured for chat (`MintConfig.ai_provider`). Rejects with a clear message if
+/// that provider doesn't support audio input.
+#[tauri::command]
+pub(crate) async fn stop_mic_recording_and_transcribe(
+    state: tauri::State<'_, MicRecordingState>,
+) -> Result<String, String> {
+    let handle = state
+        .active
+        .lock()
+        .map_err(|e| e.to_string())?
+        .take()
+        .ok_or_else(|| "No recording is in progress".to_string())?;
+
+    // stop_recording() blocks joining the recorder thread — run it off the async
+    // executor so it doesn't stall this command's tokio task.
+    let wav_bytes = tokio::task::spawn_blocking(move || core_stop_mic_recording(handle))
+        .await
+        .map_err(|e| format!("recording thread panicked: {e}"))?
+        .map_err(|e| e.to_string())?;
+
+    let config = load_config().map_err(|error| error.to_string())?;
+    core_transcribe_mic_recording(&config, wav_bytes)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+/// Stops and discards a canceled recording without invoking a transcription provider.
+#[tauri::command]
+pub(crate) async fn cancel_mic_recording(
+    state: tauri::State<'_, MicRecordingState>,
+) -> Result<(), String> {
+    let handle = state.active.lock().map_err(|e| e.to_string())?.take();
+    if let Some(handle) = handle {
+        tokio::task::spawn_blocking(move || core_stop_mic_recording(handle))
+            .await
+            .map_err(|e| format!("recording thread panicked: {e}"))?
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}