@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-core/src/companion.rs

@@ -1,4 +1,6 @@
 //! Local, optional companion transport. Never boots an API server or integrations.
+pub mod navigation;
+
 use futures_util::{SinkExt, StreamExt};
 use mint_companion_protocol::{
     Command, Event, HostDescriptor, Session, Status, Turn, TurnBook, VERSION,
@@ -135,6 +137,9 @@ impl Hub {
         Event::Snapshot {
             host_id: self.host_id.clone(),
             version: VERSION,
+            surface: navigation::surface(),
+            speech: true,
+            chat_id: selected.map(str::to_owned),
             sessions: self.sessions.lock().unwrap().clone(),
             turns,
         }
@@ -300,6 +305,10 @@ async fn listen(hub: Arc<Hub>) -> std::io::Result<()> {
         name: format!("{name} · {}", std::process::id()),
         endpoint: format!("ws://{}/companion/v1", listener.local_addr()?),
         token: token.clone(),
+        identity: std::env::current_exe()
+            .ok()
+            .zip(std::env::current_dir().ok())
+            .and_then(|paths| serde_json::to_string(&paths).ok()),
     };
     let path = dir.join(format!("{}.json", hub.host_id));
     let mut options = std::fs::OpenOptions::new();
@@ -393,6 +402,28 @@ async fn serve(socket: TcpStream, hub: Arc<Hub>, token: String) {
                 if let Message::Ping(bytes) = message { if socket.send(Message::Pong(bytes)).await.is_err() { break; } continue; }
                 let Message::Text(text) = message else { continue; };
                 let reply = match serde_json::from_str::<Command>(&text) {
+                    Ok(Command::Speech { request }) => {
+                        let allowed = match &request {
+                            mint_companion_protocol::SpeechRequest::Prepare { turn_id, text, audio_only, .. } => turn_id.is_some() && text.is_none() && *audio_only,
+                            _ => true,
+                        };
+                        if !allowed { Event::Error { request_id: None, message: "Companion can only read a saved completed reply".into() } }
+                        else { match crate::tts::playback::request(request).await {
+                            Ok(reply) => Event::Speech { reply },
+                            Err(message) => Event::Error { request_id: None, message },
+                        } }
+                    }
+                    Ok(Command::OpenChat { chat_id, new_terminal }) => {
+                        hub.refresh_sessions();
+                        let session = hub.sessions.lock().unwrap().iter().find(|s| s.chat_id == chat_id).cloned();
+                        match session {
+                            None => Event::Navigation { outcome: mint_companion_protocol::NavigationOutcome::MissingSession },
+                            Some(session) => match navigation::open(session, new_terminal).await {
+                                Ok(outcome) => Event::Navigation { outcome },
+                                Err(message) => Event::Error { request_id: None, message },
+                            }
+                        }
+                    }
                     Ok(Command::ListSessions) => hub.snapshot(selected.as_deref()),
                     Ok(Command::Subscribe { chat_id }) => {
                         if !hub.sessions.lock().unwrap().iter().any(|s| s.chat_id == chat_id) {
@@ -675,12 +706,21 @@ mod tests {
     ) -> Result<
         tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<TcpStream>>,
         tokio_tungstenite::tungstenite::Error,
+    > {
+        connect_hub(token, Arc::new(Hub::default())).await
+    }
+    async fn connect_hub(
+        token: &str,
+        hub: Arc<Hub>,
+    ) -> Result<
+        tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<TcpStream>>,
+        tokio_tungstenite::tungstenite::Error,
     > {
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
         let addr = listener.local_addr().unwrap();
         tokio::spawn(async move {
             let (socket, _) = listener.accept().await.unwrap();
-            serve(socket, std::sync::Arc::new(Hub::default()), "secret".into()).await;
+            serve(socket, hub, "secret".into()).await;
         });
         let mut request = format!("ws://{addr}/companion/v1")
             .into_client_request()
@@ -709,6 +749,74 @@ mod tests {
             Event::Snapshot { version: 1, .. }
         ));
     }
+    #[tokio::test]
+    async fn navigation_uses_the_saved_session_and_rechecks_deleted_sessions() {
+        let path =
+            std::env::temp_dir().join(format!("mint-handoff-{}.sqlite", uuid::Uuid::new_v4()));
+        let memory = crate::MemoryStore::open(&path);
+        memory
+            .register_cli_session("cli::handoff", Some("/workspace/selected"), None, None)
+            .unwrap();
+        let hub = Arc::new(Hub::default());
+        *hub.memory.lock().unwrap() = Some(memory.clone());
+        let calls = Arc::new(std::sync::atomic::AtomicU64::new(0));
+        let observed = Arc::clone(&calls);
+        navigation::configure(
+            mint_companion_protocol::Surface::Tui,
+            move |session, new_terminal| {
+                assert_eq!(session.chat_id, "cli::handoff");
+                assert_eq!(session.workspace.as_deref(), Some("/workspace/selected"));
+                assert!(!new_terminal);
+                observed.fetch_add(1, Ordering::Relaxed);
+                Ok(mint_companion_protocol::NavigationOutcome::NeedsTerminal)
+            },
+        );
+        let mut socket = connect_hub("secret", hub).await.unwrap();
+        async fn request(
+            socket: &mut tokio_tungstenite::WebSocketStream<
+                tokio_tungstenite::MaybeTlsStream<TcpStream>,
+            >,
+        ) -> mint_companion_protocol::NavigationOutcome {
+            socket
+                .send(Message::Text(
+                    r#"{"type":"open_chat","chatId":"cli::handoff","newTerminal":false}"#.into(),
+                ))
+                .await
+                .unwrap();
+            tokio::time::timeout(std::time::Duration::from_secs(3), async {
+                loop {
+                    let response = socket.next().await.unwrap().unwrap();
+                    if let Event::Navigation { outcome } =
+                        serde_json::from_str::<Event>(&response.to_string()).unwrap()
+                    {
+                        return outcome;
+                    }
+                }
+            })
+            .await
+            .unwrap()
+        }
+        assert_eq!(
+            request(&mut socket).await,
+            mint_companion_protocol::NavigationOutcome::NeedsTerminal
+        );
+        memory.delete_chat_session("cli::handoff").unwrap();
+        assert_eq!(
+            request(&mut socket).await,
+            mint_companion_protocol::NavigationOutcome::MissingSession
+        );
+        assert_eq!(calls.load(Ordering::Relaxed), 1);
+        assert!(
+            memory
+                .recent_interactions_for_chat("cli::handoff", 10)
+                .unwrap()
+                .is_empty()
+        );
+        let _ = socket.close(None).await;
+        drop(memory);
+        let _ = std::fs::remove_file(path);
+    }
+
     #[tokio::test]
     async fn invalid_token_cannot_read_sessions() {
         assert!(connect("wrong").await.is_err());

package/crates/mint-core/src/cron/store.rs

@@ -270,8 +270,8 @@ impl CronStore {
 }
 
 pub fn cron_jobs_path() -> Result<PathBuf, CronError> {
-    dirs::config_dir()
-        .map(|directory| directory.join("mint").join("cron-jobs.json"))
+    crate::mint_config_dir()
+        .map(|directory| directory.join("cron-jobs.json"))
         .ok_or(CronError::ConfigDirectoryUnavailable)
 }
 

package/crates/mint-core/src/integrations/mcp.rs

@@ -1055,7 +1055,7 @@ impl McpRemoteSession {
 
                 let handle = MCP_ASYNC_RUNTIME.spawn(async move {
                     let mut stream = resp.bytes_stream();
-                    let mut buffer = String::new();
+                    let mut buffer = Vec::new();
                     let mut current_event: Option<String> = None;
                     let mut current_data: Vec<String> = Vec::new();
 
@@ -1064,14 +1064,12 @@ impl McpRemoteSession {
                             Ok(b) => b,
                             Err(_) => break,
                         };
-                        let text = match std::str::from_utf8(&bytes) {
-                            Ok(t) => t,
-                            Err(_) => continue,
-                        };
-                        buffer.push_str(text);
+                        buffer.extend_from_slice(&bytes);
 
-                        while let Some(pos) = buffer.find('\n') {
-                            let line = buffer[..pos].trim_end_matches('\r').to_string();
+                        while let Some(pos) = buffer.iter().position(|&b| b == b'\n') {
+                            let line = String::from_utf8_lossy(&buffer[..pos])
+                                .trim_end_matches('\r')
+                                .to_string();
                             buffer.drain(..=pos);
 
                             if line.is_empty() {

package/crates/mint-core/src/integrations/mcp_result.rs

@@ -18,6 +18,9 @@ pub enum ToolStatus {
     Failed,
     TimedOut,
     Cancelled,
+    Running,
+    Unknown,
+    Skipped,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -33,6 +36,8 @@ pub struct McpArtifact {
     pub server: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub uri: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Value>,
 }
 
 #[derive(Debug, Default)]
@@ -53,6 +58,8 @@ impl From<String> for ToolOutcome {
             || text.starts_with("User denied")
         {
             ToolStatus::Failed
+        } else if text.starts_with("Skipped") {
+            ToolStatus::Skipped
         } else {
             ToolStatus::Success
         };
@@ -76,6 +83,42 @@ pub fn read_artifact(id: &str) -> Result<(McpArtifact, Vec<u8>), String> {
     read_artifact_in(&artifact_directory()?, id)
 }
 
+pub fn delete_chat_artifacts(chat: &str) -> Result<usize, String> {
+    let directory = artifact_directory()?;
+    if !directory.exists() {
+        return Ok(0);
+    }
+    let mut removed = 0;
+    for file in fs::read_dir(&directory).map_err(|e| e.to_string())? {
+        let file = file.map_err(|e| e.to_string())?;
+        let path = file.path();
+        if path.extension().and_then(|s| s.to_str()) != Some("json")
+            || file.metadata().map_err(|e| e.to_string())?.len() > 1_048_576
+        {
+            continue;
+        }
+        let Ok(bytes) = fs::read(&path) else {
+            continue;
+        };
+        let Ok(entry) = serde_json::from_slice::<McpArtifact>(&bytes) else {
+            continue;
+        };
+        if entry.chat_id != chat
+            || uuid::Uuid::parse_str(&entry.id).is_err()
+            || path != directory.join(format!("{}.json", entry.id))
+        {
+            continue;
+        }
+        let data = directory.join(&entry.id);
+        if data.exists() {
+            fs::remove_file(data).map_err(|e| e.to_string())?;
+        }
+        fs::remove_file(path).map_err(|e| e.to_string())?;
+        removed += 1;
+    }
+    Ok(removed)
+}
+
 fn read_artifact_in(directory: &Path, id: &str) -> Result<(McpArtifact, Vec<u8>), String> {
     uuid::Uuid::parse_str(id).map_err(|_| "Invalid artifact ID")?;
     let entry: McpArtifact = serde_json::from_slice(
@@ -142,6 +185,7 @@ fn normalize_in(
                         call_id: call.into(),
                         server: server.into(),
                         uri: Some(uri.into()),
+                        metadata: None,
                     });
                 }
                 continue;
@@ -229,6 +273,7 @@ fn normalize_in(
                 call_id: call.into(),
                 server: server.into(),
                 uri: None,
+                metadata: None,
             };
             if entry.name.is_empty() {
                 entry.name = "MCP attachment".into();

package/crates/mint-core/src/lib.rs

@@ -22,6 +22,7 @@ pub mod orchestration;
 pub mod prompts;
 pub mod search;
 pub mod slash;
+pub mod swarm;
 pub mod system;
 
 pub use agent::agent_loop;
@@ -37,6 +38,7 @@ pub use agent::tasks;
 pub use media::auto_shorts;
 pub use media::gemini_live;
 pub use media::image_gen;
+pub use media::image_proxy;
 pub use media::image_search;
 pub use media::image_workflow;
 pub use media::library;
@@ -81,8 +83,8 @@ pub use system::workspace;
 pub use agent_loop::{AgentActionFuture, AgentLoopError, parse_agent_json, run_agent_loop};
 pub use auth::{
     AuthError, AuthUser, create_session, destroy_session, get_user, login_user,
-    profile_pictures_dir, register_user, save_avatar_file, session_user_id, update_profile,
-    user_db_path,
+    profile_pictures_dir, profile_pictures_dir_path, register_user, resolve_avatar_file_path,
+    save_avatar_file, session_user_id, update_profile, user_db_path,
 };
 pub use chat::{
     ChatError, ChatMessage, ChatRequest, ChatResponse, ChatRole, ChatStreamEvent, ContentBlock,
@@ -94,11 +96,6 @@ pub use auto_shorts::{
     AiEditStepResult, AiEditVideoRequest, AiEditVideoResult, AutoShortsError, MakeShortsRequest,
     MakeShortsResult, ShortClipInfo, ai_edit_video, make_shorts,
 };
-pub use browser::{
-    BrowserTab, click, enable_browser_tools, get_element_coordinates, is_browser_running,
-    key_press, list_tabs, mouse_click, mouse_move, navigate, read_page_text, screenshot,
-    spawn_automation_browser, spawn_automation_browser_with_url, type_text, type_text_native,
-};
 pub use calculation::{CalculationError, CalculationReport, calculate};
 pub use code_tools::{
     AppliedCodeEdit, CodeEdit, CodeEditPreview, CodeEditProposal, CodeFile, CodeInspectionError,
@@ -109,7 +106,8 @@ pub use code_tools::{
 pub use config::{
     AgentConfig, ConfigError, CustomProvider, CustomProviderHeader, CustomProviderModel,
     MintConfig, PermissionDecision, PermissionRule, ToolCallingMode, config_path,
-    initialize_config, load_config, permission_decision_for, save_config, set_config_value,
+    initialize_config, load_config, mint_config_dir, permission_decision_for, save_config,
+    set_config_value,
 };
 pub use cron::{
     CronError, CronJob, CronJobDraft, CronStore, localize_schedule, start_cron_scheduler,
@@ -169,9 +167,10 @@ pub use mic_transcribe::{
 };
 pub use orchestration::{
     ActivePlan, AgentApproval, AgentProgress, AgentResult, ApprovalOutcome, AskUserOption,
-    MCP_ALLOW_ALL_SENTINEL, OrchestrationError, PlanTaskItem, RunTelemetrySummary,
-    ToolExecutionRecord, compact_agent_progress, orchestrate_agent_loop, orchestrate_chat,
-    orchestrate_chat_stream, orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
+    ExecutionEvidence, ExecutionState, MCP_ALLOW_ALL_SENTINEL, OrchestrationError, PlanTaskItem,
+    RunTelemetrySummary, ToolExecutionRecord, compact_agent_progress, is_dummy_value,
+    orchestrate_agent_loop, orchestrate_chat, orchestrate_chat_stream,
+    orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
     with_turn_start_listener,
 };
 pub use pictures::{