@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-core/tests/library_http.rs

@@ -0,0 +1,209 @@
+//! Exercise the real authenticated Web intake and catalog without contacting an AI provider.
+use serde_json::{Value, json};
+use std::{
+    io::{Read, Write},
+    net::{SocketAddr, TcpListener, TcpStream},
+    path::PathBuf,
+    process::{Child, Command, Stdio},
+    time::{Duration, Instant},
+};
+struct Server {
+    child: Child,
+    address: SocketAddr,
+    root: PathBuf,
+}
+impl Drop for Server {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+        let _ = std::fs::remove_dir_all(&self.root);
+    }
+}
+impl Server {
+    fn start() -> Self {
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let address = listener.local_addr().unwrap();
+        let root = std::env::temp_dir().join(format!("mint-library-http-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let mut config = mint_core::MintConfig::default();
+        config
+            .extra
+            .insert("apiAuthToken".into(), json!("library-test-token"));
+        std::fs::write(
+            root.join("config.json"),
+            serde_json::to_vec(&config).unwrap(),
+        )
+        .unwrap();
+        drop(listener);
+        let child = Command::new(std::env::current_exe().unwrap())
+            .args(["--exact", "library_http_worker", "--nocapture"])
+            .env("MINT_LIBRARY_TEST_ADDRESS", address.to_string())
+            .env("MINT_CONFIG_PATH", root.join("config.json"))
+            .env("XDG_CONFIG_HOME", root.join("config"))
+            .env("XDG_DATA_HOME", root.join("data"))
+            .env("XDG_CACHE_HOME", root.join("cache"))
+            .current_dir(&root)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .unwrap();
+        let mut server = Self {
+            child,
+            address,
+            root,
+        };
+        let deadline = Instant::now() + Duration::from_secs(10);
+        while TcpStream::connect(address).is_err() {
+            assert!(server.child.try_wait().unwrap().is_none());
+            assert!(Instant::now() < deadline);
+            std::thread::sleep(Duration::from_millis(20));
+        }
+        server
+    }
+    fn request(
+        &self,
+        method: &str,
+        path: &str,
+        body: &str,
+        authenticated: bool,
+    ) -> (String, String) {
+        let mut socket = TcpStream::connect(self.address).unwrap();
+        socket
+            .set_read_timeout(Some(Duration::from_secs(10)))
+            .unwrap();
+        let auth = if authenticated {
+            "Authorization: Bearer library-test-token\r\n"
+        } else {
+            ""
+        };
+        write!(socket,"{method} {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-Type: application/json\r\nContent-Length: {}\r\n{auth}\r\n{body}",body.len()).unwrap();
+        let mut bytes = Vec::new();
+        socket.read_to_end(&mut bytes).unwrap();
+        let response = String::from_utf8(bytes).unwrap();
+        let (header, body) = response.split_once("\r\n\r\n").unwrap();
+        (header.lines().next().unwrap().into(), body.into())
+    }
+    fn json(&self, method: &str, path: &str, body: &str) -> (String, Value) {
+        let (status, body) = self.request(method, path, body, true);
+        (status, serde_json::from_str(&body).unwrap())
+    }
+}
+#[test]
+fn library_http_worker() {
+    let Ok(address) = std::env::var("MINT_LIBRARY_TEST_ADDRESS") else {
+        return;
+    };
+    tokio::runtime::Runtime::new().unwrap().block_on(async {
+        mint_core::api_server::start_api_server_on(address.parse().unwrap())
+            .await
+            .unwrap()
+    });
+}
+#[test]
+fn library_http_intake_retry_trash_restore_and_history_deletion_preserve_original() {
+    let server = Server::start();
+    assert!(
+        server
+            .request("GET", "/api/library", "", false)
+            .0
+            .contains("401")
+    );
+    let body=json!({"message":"/chat Read this","chatId":"A","documentAttachment":{"filename":"failed-extraction.pdf","dataUri":"data:application/pdf;base64,aGVsbG8="},"attachmentMetadata":{"requestId":"same-submission","imageNames":[],"videoNames":[]}}).to_string();
+    for _ in 0..2 {
+        assert!(
+            server
+                .request("POST", "/api/chat-stream", &body, true)
+                .0
+                .contains("400")
+        );
+    }
+    let (status, page) = server.json("GET", "/api/library?kind=file&chatId=A", "");
+    assert!(status.contains("200"));
+    assert_eq!(page["items"].as_array().unwrap().len(), 1);
+    let item = &page["items"][0];
+    let id = item["id"].as_str().unwrap();
+    assert_eq!(item["name"], "failed-extraction.pdf");
+    assert_eq!(item["size"], 5);
+    assert!(item.get("path").is_none());
+    let content = format!("/api/library/{id}/content");
+    assert_eq!(server.request("GET", &content, "", true).1, "hello");
+    let (_, sources) = server.json("GET", "/api/conversation-sources?chatId=A", "");
+    assert_eq!(sources["attachments"][0]["libraryItemId"], id);
+    assert!(sources["attachments"][0]["interactionId"].is_null());
+    assert!(
+        server
+            .json("POST", &format!("/api/library/{id}/trash"), "")
+            .0
+            .contains("200")
+    );
+    assert!(server.request("GET", &content, "", true).0.contains("400"));
+    let (_, active) = server.json("GET", "/api/library", "");
+    assert!(active["items"].as_array().unwrap().is_empty());
+    let (_, trash) = server.json("GET", "/api/library?trashed=true", "");
+    assert_eq!(trash["items"][0]["id"], id);
+    let (_, sources) = server.json("GET", "/api/conversation-sources?chatId=A", "");
+    assert_eq!(sources["attachments"][0]["trashed"], true);
+    assert!(
+        server
+            .json("POST", &format!("/api/library/{id}/restore"), "")
+            .0
+            .contains("200")
+    );
+    assert_eq!(server.request("GET", &content, "", true).1, "hello");
+    assert!(
+        server
+            .json("POST", "/api/interactions/clear?chatId=A", "")
+            .0
+            .contains("200")
+    );
+    let (_, sources) = server.json("GET", "/api/conversation-sources?chatId=A", "");
+    assert!(sources["attachments"].as_array().unwrap().is_empty());
+    let (_, page) = server.json("GET", "/api/library", "");
+    assert_eq!(page["items"][0]["id"], id);
+    assert!(
+        page["items"][0]["references"]
+            .as_array()
+            .unwrap()
+            .is_empty()
+    );
+    assert_eq!(server.request("GET", &content, "", true).1, "hello");
+    assert!(
+        server
+            .request("DELETE", &format!("/api/library/{id}"), "", false)
+            .0
+            .contains("401")
+    );
+    assert!(
+        server
+            .request("DELETE", &format!("/api/library/{id}"), "", true)
+            .0
+            .contains("400")
+    );
+    server.json("POST", &format!("/api/library/{id}/trash"), "");
+    assert!(
+        server
+            .request("DELETE", &format!("/api/library/{id}"), "", true)
+            .0
+            .contains("200")
+    );
+    assert!(
+        server
+            .request("GET", &format!("/api/library/{id}"), "", true)
+            .0
+            .contains("400")
+    );
+    let (_, trash) = server.json("GET", "/api/library?trashed=true", "");
+    assert!(trash["items"].as_array().unwrap().is_empty());
+    // The child process uses an isolated XDG_DATA_HOME, so this is the actual
+    // desktop Trash implementation without touching the user's Trash.
+    #[cfg(target_os = "linux")]
+    {
+        let files = server.root.join("data/Trash/files");
+        assert!(
+            std::fs::read_dir(files)
+                .unwrap()
+                .filter_map(Result::ok)
+                .any(|entry| std::fs::read(entry.path()).is_ok_and(|bytes| bytes == b"hello"))
+        );
+    }
+}

package/crates/mint-core/tests/mcp_contract.rs

@@ -0,0 +1,283 @@
+#![cfg(unix)]
+use mint_core::{MintConfig, mcp};
+use serde_json::{Value, json};
+
+#[test]
+fn review_reconnect_cannot_dispatch_using_the_previous_sessions_schema() {
+    let state = std::env::temp_dir().join(format!("mint-review-restart-{}", uuid::Uuid::new_v4()));
+    let log = state.with_extension("calls");
+    let name = format!("review-restart-{}", uuid::Uuid::new_v4());
+    let script = format!(
+        r#"
+import sys,json,os,pathlib
+state=pathlib.Path({:?});version=int(state.read_text())+1 if state.exists() else 1;state.write_text(str(version))
+for line in sys.stdin:
+ r=json.loads(line);m=r.get('method')
+ if m=='initialize': result={{}}
+ elif m=='tools/list': result={{'tools':[{{'name':'move','description':'x'*240000,'inputSchema':{{'type':'object','properties':{{'rpm':{{'type':'integer','maximum':100 if version==1 else 0}}}},'required':['rpm']}}}}]}}
+ elif m=='tools/call':
+  open({:?},'a').write(str(version)+'\n')
+  result={{'executed':version}}
+ else: continue
+ print(json.dumps({{'jsonrpc':'2.0','id':r['id'],'result':result}}),flush=True)
+ if m=='tools/list' and version==1: os._exit(0)
+"#,
+        state.to_string_lossy(),
+        log.to_string_lossy()
+    );
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",script],"timeoutSecs":3}}),
+    );
+    cfg.extra
+        .insert("allowedMcpTools".into(), json!({name.clone():["*"]}));
+    let result = mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":50}));
+    let sent = std::fs::read_to_string(&log).unwrap_or_default();
+    assert!(
+        sent.is_empty(),
+        "a replacement server received an unvalidated command: {sent}"
+    );
+    assert!(
+        result.is_err(),
+        "session loss must reject dispatch: {result:?}"
+    );
+    // A later explicit invocation may reconnect, but must load the new schema.
+    assert!(mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":50})).is_err());
+    assert_eq!(
+        mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":0})).unwrap()["executed"],
+        2
+    );
+    mcp::close_mcp_session(&name);
+    assert_eq!(std::fs::read_to_string(&log).unwrap(), "2\n");
+    let _ = std::fs::remove_file(state);
+    let _ = std::fs::remove_file(log);
+}
+
+#[test]
+fn review_pagination_session_loss_cannot_mix_catalogs_or_start_a_replacement() {
+    let state = std::env::temp_dir().join(format!("mint-page-session-{}", uuid::Uuid::new_v4()));
+    let script = format!(
+        r#"
+import sys,json,os,pathlib
+state=pathlib.Path({:?});version=int(state.read_text())+1 if state.exists() else 1;state.write_text(str(version))
+for line in sys.stdin:
+ r=json.loads(line);m=r.get('method')
+ if m=='initialize': result={{}}
+ elif m=='tools/list':
+  result={{'tools':[{{'name':'first' if version==1 else 'last','description':'x'*240000,'inputSchema':{{'type':'object'}}}}]}}
+  if version==1: result['nextCursor']='next'
+ else: continue
+ print(json.dumps({{'jsonrpc':'2.0','id':r['id'],'result':result}}),flush=True)
+ if m=='tools/list' and version==1: os._exit(0)
+"#,
+        state.to_string_lossy()
+    );
+    let name = format!("page-session-{}", uuid::Uuid::new_v4());
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",script]}}),
+    );
+    let result = mcp::list_server_tools(&cfg, &name);
+    mcp::close_mcp_session(&name);
+    let starts = std::fs::read_to_string(&state).unwrap();
+    let _ = std::fs::remove_file(state);
+    assert!(
+        result.is_err(),
+        "mixed or partial catalog escaped: {result:?}"
+    );
+    assert_eq!(starts, "1", "pagination silently reconnected");
+}
+
+fn server(tools: Value, extra: &str) -> (MintConfig, String) {
+    let name = format!("contract-{}", uuid::Uuid::new_v4());
+    let script = format!(
+        r#"
+import sys,json
+tools=json.loads({:?}); lists=0; calls=0
+def emit(r,result): print(json.dumps({{'jsonrpc':'2.0','id':r['id'],'result':result}}),flush=True)
+for line in sys.stdin:
+ r=json.loads(line); method=r.get('method')
+ if method=='initialize': emit(r,{{}})
+ elif method=='tools/list':
+  lists+=1
+  emit(r,{{'tools':tools}})
+ elif method=='tools/call':
+  calls+=1
+  {}
+  emit(r,{{'arguments':r['params']['arguments'],'lists':lists,'calls':calls}})
+"#,
+        tools.to_string(),
+        extra
+    );
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",script],"timeoutSecs":5}}),
+    );
+    cfg.extra
+        .insert("allowedMcpTools".into(), json!({name.clone():["*"]}));
+    (cfg, name)
+}
+
+#[test]
+fn schema_failures_never_send_commands_and_valid_arguments_are_unchanged() {
+    let (cfg, name) = server(
+        json!([{"name":"move","description":"Move motor","inputSchema":{"type":"object","$defs":{"point":{"type":"integer","minimum":0,"maximum":100}},"properties":{"position":{"$ref":"#/$defs/point"},"mode":{"enum":["absolute","relative"]}},"required":["position","mode"],"additionalProperties":false}}]),
+        "pass",
+    );
+    for args in [
+        json!({}),
+        json!({"position":"2","mode":"absolute"}),
+        json!({"position":101,"mode":"absolute"}),
+        json!({"position":2,"mode":"guessed"}),
+        json!({"position":2,"mode":"absolute","extra":1}),
+    ] {
+        let error = mcp::call_mcp_tool(&cfg, &name, "move", args).unwrap_err();
+        assert!(error.to_string().contains("no tool was executed"));
+    }
+    assert!(mcp::call_mcp_tool(&cfg, &name, "invented", json!({})).is_err());
+    let result =
+        mcp::call_mcp_tool(&cfg, &name, "move", json!({"position":2,"mode":"absolute"})).unwrap();
+    assert_eq!(result["arguments"], json!({"position":2,"mode":"absolute"}));
+    assert_eq!(result["calls"], 1);
+    assert_eq!(result["lists"], 1);
+    mcp::close_mcp_session(&name);
+}
+
+#[test]
+fn missing_and_external_schemas_are_blocked_without_reading_files_or_network() {
+    let (cfg, name) = server(
+        json!([{"name":"missing"},{"name":"external","inputSchema":{"type":"object","$ref":"file:///etc/passwd"}},{"name":"network","inputSchema":{"type":"object","$ref":"http://127.0.0.1:1/schema"}},{"name":"valid","inputSchema":{"type":"object"}}]),
+        "pass",
+    );
+    for tool in ["missing", "external", "network"] {
+        assert!(mcp::call_mcp_tool(&cfg, &name, tool, json!({})).is_err());
+    }
+    assert_eq!(
+        mcp::call_mcp_tool(&cfg, &name, "valid", json!({})).unwrap()["calls"],
+        1
+    );
+    mcp::close_mcp_session(&name);
+}
+
+#[test]
+fn list_changed_invalidates_schema_before_the_next_command() {
+    let (cfg, name) = server(
+        json!([{"name":"move","inputSchema":{"type":"object","properties":{"rpm":{"type":"integer","maximum":100}},"required":["rpm"]}}]),
+        "tools[0]['inputSchema']['properties']['rpm']['maximum']=1\n  print(json.dumps({'jsonrpc':'2.0','method':'notifications/tools/list_changed'}),flush=True)",
+    );
+    mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":50})).unwrap();
+    assert!(mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":50})).is_err());
+    let result = mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":1})).unwrap();
+    assert_eq!(result["lists"], 2);
+    assert_eq!(result["calls"], 2);
+    mcp::close_mcp_session(&name);
+}
+
+#[test]
+fn discovery_walks_every_page() {
+    let name = format!("pages-{}", uuid::Uuid::new_v4());
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",r#"
+import sys,json
+for line in sys.stdin:
+ r=json.loads(line); m=r.get('method')
+ if m=='initialize': result={}
+ elif m=='tools/list':
+  second=r.get('params',{}).get('cursor')=='next'
+  result={'tools':[{'name':'last' if second else 'first','inputSchema':{'type':'object'}}]}
+  if not second: result['nextCursor']='next'
+ elif m=='tools/call': result={'ok':True}
+ else: continue
+ print(json.dumps({'jsonrpc':'2.0','id':r['id'],'result':result}),flush=True)
+"#]}}),
+    );
+    cfg.extra
+        .insert("allowedMcpTools".into(), json!({name.clone():["*"]}));
+    assert_eq!(
+        mcp::call_mcp_tool(&cfg, &name, "last", json!({})).unwrap(),
+        json!({"ok":true})
+    );
+    assert_eq!(
+        mcp::list_server_tools(&cfg, &name).unwrap()["tools"]
+            .as_array()
+            .unwrap()
+            .len(),
+        2
+    );
+    mcp::close_mcp_session(&name);
+}
+
+#[test]
+fn changed_server_configuration_starts_a_fresh_catalog() {
+    let (cfg, name) = server(
+        json!([{"name":"move","inputSchema":{"type":"object","properties":{"rpm":{"maximum":100}},"required":["rpm"]}}]),
+        "pass",
+    );
+    mcp::call_mcp_tool(&cfg, &name, "move", json!({"rpm":50})).unwrap();
+    let mut changed = cfg.clone();
+    let script = changed.extra["mcpServers"][&name]["args"][2]
+        .as_str()
+        .unwrap()
+        .replace("100", "1");
+    changed.extra.get_mut("mcpServers").unwrap()[&name]["args"][2] = json!(script);
+    assert!(mcp::call_mcp_tool(&changed, &name, "move", json!({"rpm":50})).is_err());
+    assert_eq!(
+        mcp::call_mcp_tool(&changed, &name, "move", json!({"rpm":1})).unwrap()["lists"],
+        1
+    );
+    mcp::close_mcp_session(&name);
+}
+
+#[test]
+fn repeated_pagination_cursor_never_exposes_a_partial_catalog() {
+    let name = format!("cursor-{}", uuid::Uuid::new_v4());
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",r#"
+import sys,json
+for line in sys.stdin:
+ r=json.loads(line);m=r.get('method')
+ if m=='initialize': result={}
+ elif m=='tools/list': result={'tools':[],'nextCursor':'repeat'}
+ elif m=='tools/call': result={'sent':True}
+ else: continue
+ print(json.dumps({'jsonrpc':'2.0','id':r['id'],'result':result}),flush=True)
+"#]}}),
+    );
+    let error = mcp::list_server_tools(&cfg, &name).unwrap_err();
+    assert!(error.to_string().contains("repeated a cursor"));
+    mcp::close_mcp_session(&name);
+}
+
+#[tokio::test]
+async fn discovery_deadline_covers_all_pages_in_agent_listing() {
+    let name = format!("deadline-{}", uuid::Uuid::new_v4());
+    let mut cfg = MintConfig::default();
+    cfg.extra.insert(
+        "mcpServers".into(),
+        json!({name.clone():{"command":"python3","args":["-u","-c",r#"
+import sys,json,time
+for line in sys.stdin:
+ r=json.loads(line);m=r.get('method')
+ if m=='initialize': result={}
+ elif m=='tools/list':
+  time.sleep(16)
+  result={'tools':[]}
+  if not r.get('params',{}).get('cursor'): result['nextCursor']='next'
+ else: continue
+ print(json.dumps({'jsonrpc':'2.0','id':r['id'],'result':result}),flush=True)
+"#]}}),
+    );
+    let result = mcp::catalog::list_tools(&cfg, &name, "catalog-deadline").await;
+    mcp::close_mcp_session(&name);
+    assert!(
+        matches!(result, Err(mcp::McpError::Timeout)),
+        "all pages must share one discovery deadline: {result:?}"
+    );
+}

package/crates/mint-core/tests/mcp_stdio.rs

@@ -27,16 +27,17 @@ fn calls_stdio_mcp_tool() {
         "mcpServers".into(),
         json!({
             "fake": {
-                "command": "sh",
-                "args": [
-                    "-c",
-                    // The client blocks on the `initialize` response before sending
-                    // `notifications/initialized` or the tool call (see McpSession::start),
-                    // so this must answer id 1 as soon as it's read rather than draining
-                    // all three lines before replying once — otherwise it deadlocks
-                    // waiting for input the client will never send.
-                    "read init; printf '{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{}}\\n'; read ready; read call; printf '{\"jsonrpc\":\"2.0\",\"id\":2,\"result\":{\"ok\":true}}\\n'"
-                ]
+                "command": "python3",
+                "args": ["-u","-c",r#"
+import sys,json
+for line in sys.stdin:
+ r=json.loads(line);m=r.get('method')
+ if m=='initialize': result={}
+ elif m=='tools/list': result={'tools':[{'name':'ping','inputSchema':{'type':'object'}}]}
+ elif m=='tools/call': result={'ok':True}
+ else: continue
+ print(json.dumps({'jsonrpc':'2.0','id':r['id'],'result':result}),flush=True)
+"#]
             }
         }),
     );