@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-core/src/media/library/migration.rs

@@ -51,6 +51,32 @@ impl LibraryStore {
             [],
         )?;
         tx.commit()?;
+        if connection
+            .query_row(
+                "SELECT 1 FROM library_migrations WHERE name='thumbnails-v2-800px'",
+                [],
+                |_| Ok(()),
+            )
+            .optional()?
+            .is_none()
+        {
+            connection.execute(
+                "UPDATE library_items SET thumbnail_status='pending' WHERE kind IN ('image', 'video')",
+                [],
+            )?;
+            let mut statement = connection
+                .prepare("SELECT id FROM library_items WHERE kind IN ('image', 'video')")?;
+            let ids: Vec<String> = statement
+                .query_map([], |row| row.get(0))?
+                .collect::<rusqlite::Result<Vec<_>>>()?;
+            for id in ids {
+                self.enqueue_thumbnail(id);
+            }
+            connection.execute(
+                "INSERT OR IGNORE INTO library_migrations(name) VALUES('thumbnails-v2-800px')",
+                [],
+            )?;
+        }
         Ok(())
     }
 }

package/crates/mint-core/src/media/library/tests.rs

@@ -54,7 +54,7 @@ fn thumbnails_are_generated_asynchronously_and_share_the_indexed_original() {
     }
     let (_, bytes) = store.read(&item.id, true).unwrap();
     let thumbnail = image::load_from_memory(&bytes).unwrap();
-    assert!(thumbnail.width() <= 360 && thumbnail.height() <= 360);
+    assert!(thumbnail.width() <= 800 && thumbnail.height() <= 800);
     let source = store
         .memory
         .conversation_sources("A")

package/crates/mint-core/src/media/library/thumbnails.rs

@@ -4,6 +4,7 @@ fn inflight() -> &'static Mutex<std::collections::HashSet<(PathBuf, String)>> {
     static JOBS: OnceLock<Mutex<std::collections::HashSet<(PathBuf, String)>>> = OnceLock::new();
     JOBS.get_or_init(Default::default)
 }
+
 impl LibraryStore {
     pub(super) fn enqueue_thumbnail(&self, id: String) {
         let key = (self.root.clone(), id.clone());
@@ -37,15 +38,20 @@ impl LibraryStore {
         if item.thumbnail_status != "pending" {
             return Ok(());
         }
+        let dir = if item.origin == "legacy" {
+            &self.legacy
+        } else {
+            &self.root
+        };
         let thumbnail = self
             .managed_path(&item.path)
             .ok()
             .and_then(|path| fs::read(path).ok())
             .and_then(|bytes| {
                 if item.kind == "video" {
-                    crate::pictures::extract_video_thumbnail_from_bytes(&self.root, id, &bytes)
+                    crate::pictures::extract_video_thumbnail_from_bytes(dir, id, &bytes)
                 } else {
-                    crate::pictures::create_thumbnail_from_bytes(&self.root, id, &bytes)
+                    crate::pictures::create_thumbnail_from_bytes(dir, id, &bytes)
                 }
             });
         let updated = self.memory.connection()?.execute(

package/crates/mint-core/src/media/pictures.rs

@@ -11,7 +11,7 @@ use thiserror::Error;
 
 use crate::ConfigError;
 
-const THUMBNAIL_MAX_SIZE: u32 = 360;
+const THUMBNAIL_MAX_SIZE: u32 = 800;
 
 #[derive(Debug, Error)]
 pub enum PictureError {

package/crates/mint-core/src/media/tool_images.rs

@@ -3,6 +3,7 @@
 use crate::mcp_result::{McpArtifact, ToolOutcome};
 use base64::{Engine as _, engine::general_purpose::STANDARD};
 use serde_json::Value;
+use sha2::{Digest, Sha256};
 use std::{fs, io::Cursor};
 
 pub const ORIGINAL_LIMIT: usize = 20 * 1024 * 1024;
@@ -82,6 +83,51 @@ pub fn prepare(bytes: &[u8], mime: &str) -> Result<PreparedImage, String> {
     }
 }
 
+/// Which stored image a `view_image` call refers to.
+#[derive(Debug, PartialEq, Eq)]
+pub enum ViewTarget<'a> {
+    Artifact(&'a str),
+    Path(&'a str),
+}
+
+/// Single place that interprets `view_image` arguments. An artifact wins when
+/// both are given (it is already in the conversation); blank values count as
+/// missing; supplying neither explains how to recover instead of just failing.
+pub fn resolve_view_target<'a>(
+    path: &'a str,
+    artifact_id: &'a str,
+) -> Result<ViewTarget<'a>, String> {
+    let (path, artifact_id) = (path.trim(), artifact_id.trim());
+    if !artifact_id.is_empty() {
+        Ok(ViewTarget::Artifact(artifact_id))
+    } else if !path.is_empty() {
+        Ok(ViewTarget::Path(path))
+    } else {
+        Err(
+            "view_image needs a `path` (an image file, e.g. the --screenshot file you just wrote) \
+             or an `artifactId` (from an earlier tool result). Images you already viewed in this \
+             turn are already in your context; do not request them again."
+                .into(),
+        )
+    }
+}
+
+/// Stable identity of image bytes, used to avoid attaching the same picture twice.
+pub fn content_key(bytes: &[u8]) -> String {
+    let digest = Sha256::digest(bytes);
+    let mut key = String::from("sha256:");
+    for byte in digest {
+        key.push_str(&format!("{byte:02x}"));
+    }
+    key
+}
+
+fn metadata_with_hash(metadata: Option<Value>, bytes: &[u8]) -> Value {
+    let mut metadata = metadata.unwrap_or_else(|| serde_json::json!({}));
+    metadata["contentHash"] = content_key(bytes).into();
+    metadata
+}
+
 pub fn save(
     bytes: &[u8],
     mime: &str,
@@ -92,7 +138,7 @@ pub fn save(
     metadata: Option<Value>,
 ) -> Result<ToolOutcome, String> {
     let prepared = prepare(bytes, mime)?;
-    let mut metadata = metadata.unwrap_or_else(|| serde_json::json!({}));
+    let mut metadata = metadata_with_hash(metadata, bytes);
     metadata["width"] = prepared.width.into();
     metadata["height"] = prepared.height.into();
     let entry = McpArtifact {
@@ -155,6 +201,51 @@ pub fn view_artifact(id: &str, chat: &str) -> Result<ToolOutcome, String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn view_target_prefers_artifact_when_both_are_supplied() {
+        assert_eq!(
+            resolve_view_target("/tmp/a.png", "abc").unwrap(),
+            ViewTarget::Artifact("abc")
+        );
+    }
+
+    #[test]
+    fn view_target_accepts_either_single_argument_ignoring_blank_whitespace() {
+        assert_eq!(
+            resolve_view_target("  /tmp/a.png ", "  ").unwrap(),
+            ViewTarget::Path("/tmp/a.png")
+        );
+        assert_eq!(
+            resolve_view_target("", "abc").unwrap(),
+            ViewTarget::Artifact("abc")
+        );
+    }
+
+    #[test]
+    fn empty_view_target_error_tells_the_model_what_to_do() {
+        let error = resolve_view_target("", " ").unwrap_err();
+        assert!(error.contains("path"), "{error}");
+        assert!(error.contains("artifactId"), "{error}");
+        assert!(error.contains("already"), "{error}");
+    }
+
+    #[test]
+    fn content_key_is_stable_and_content_sensitive() {
+        assert_eq!(content_key(b"abc"), content_key(b"abc"));
+        assert_ne!(content_key(b"abc"), content_key(b"abd"));
+        assert!(content_key(b"abc").starts_with("sha256:"));
+    }
+
+    #[test]
+    fn saved_artifact_metadata_records_the_content_hash() {
+        let mut bytes = Cursor::new(Vec::new());
+        image::RgbImage::new(4, 4)
+            .write_to(&mut bytes, image::ImageFormat::Png)
+            .unwrap();
+        let metadata = metadata_with_hash(None, bytes.get_ref());
+        assert_eq!(metadata["contentHash"], content_key(bytes.get_ref()));
+    }
+
     #[test]
     fn small_images_under_max_dimension_are_not_reduced() {
         let mut bytes = Cursor::new(Vec::new());

package/crates/mint-core/src/mods/manager.rs

@@ -318,9 +318,14 @@ fn binding_ids(root: &Path) -> Result<BTreeSet<String>, String> {
     Ok(ids)
 }
 
+enum WorkerInput {
+    Process(ChildStdin),
+    Thread(mpsc::Sender<Value>),
+}
+
 struct Worker {
-    child: Child,
-    input: ChildStdin,
+    child: Option<Child>,
+    input: WorkerInput,
     output: mpsc::Receiver<Result<Value, String>>,
     preview: bool,
     phase: String,
@@ -331,39 +336,23 @@ struct Worker {
 }
 impl Drop for Worker {
     fn drop(&mut self) {
-        let _ = self.child.kill();
-        let _ = self.child.wait();
+        if let Some(mut child) = self.child.take() {
+            let _ = child.kill();
+            let _ = child.wait();
+        }
     }
 }
 impl Worker {
-    fn start(
-        root: &Path,
-        chat: &str,
-        compiled: &str,
-        state: &Value,
-        permissions: Vec<String>,
-        preview: bool,
-    ) -> Result<(Self, Value), String> {
-        let exe = std::env::current_exe().map_err(|e| e.to_string())?;
-        let name = if cfg!(windows) {
-            "mint-mod-host.exe"
-        } else {
-            "mint-mod-host"
-        };
-        let sibling = exe
-            .parent()
-            .ok_or("Executable directory missing")?
-            .join(name);
-        let development = exe.parent().and_then(Path::parent).map(|p| p.join(name));
-        let mut command = if sibling.is_file() {
-            Command::new(sibling)
-        } else if let Some(p) = development.filter(|p| p.is_file()) {
-            Command::new(p)
-        } else {
-            let mut c = Command::new(exe);
-            c.arg("--mint-mod-host");
-            c
-        };
+    fn spawn_process(
+        mut command: Command,
+    ) -> Result<
+        (
+            Option<Child>,
+            WorkerInput,
+            mpsc::Receiver<Result<Value, String>>,
+        ),
+        String,
+    > {
         let mut child = command
             .current_dir(std::env::temp_dir())
             .env_clear()
@@ -395,6 +384,80 @@ impl Worker {
                 }
             }
         });
+        Ok((Some(child), WorkerInput::Process(input), rx))
+    }
+
+    fn spawn_thread() -> Result<
+        (
+            Option<Child>,
+            WorkerInput,
+            mpsc::Receiver<Result<Value, String>>,
+        ),
+        String,
+    > {
+        let (to_worker_tx, to_worker_rx) = mpsc::channel::<Value>();
+        let (from_worker_tx, from_worker_rx) = mpsc::channel::<Result<Value, String>>();
+        let rx = Arc::new(Mutex::new(to_worker_rx));
+        let tx = Arc::new(Mutex::new(from_worker_tx));
+        std::thread::spawn(move || {
+            let rx_clone = Arc::clone(&rx);
+            let tx_clone = Arc::clone(&tx);
+            let _ = mint_mod_runtime::run_worker_loop(
+                move || {
+                    rx_clone
+                        .lock()
+                        .map_err(|e| e.to_string())?
+                        .recv()
+                        .map_err(|e| e.to_string())
+                },
+                move |val| {
+                    if let Ok(tx) = tx_clone.lock() {
+                        let _ = tx.send(Ok(val));
+                    }
+                },
+            );
+        });
+        Ok((None, WorkerInput::Thread(to_worker_tx), from_worker_rx))
+    }
+
+    fn find_mod_host(exe: &Path, name: &str) -> Option<PathBuf> {
+        let sibling = exe.parent()?.join(name);
+        if sibling.is_file() {
+            return Some(sibling);
+        }
+        // Cargo places test binaries in `target/<profile>/deps/` or
+        // `target/<profile>/build/<pkg>/<hash>/out/`, while `mint-mod-host`
+        // lives in `target/<profile>/`.
+        exe.ancestors()
+            .skip(2)
+            .take(5)
+            .map(|dir| dir.join(name))
+            .find(|candidate| candidate.is_file())
+    }
+
+    fn start(
+        root: &Path,
+        chat: &str,
+        compiled: &str,
+        state: &Value,
+        permissions: Vec<String>,
+        preview: bool,
+    ) -> Result<(Self, Value), String> {
+        let exe = std::env::current_exe().map_err(|e| e.to_string())?;
+        let name = if cfg!(windows) {
+            "mint-mod-host.exe"
+        } else {
+            "mint-mod-host"
+        };
+        let (child, input, rx) = if let Some(host) = Self::find_mod_host(&exe, name) {
+            Self::spawn_process(Command::new(host))?
+        } else if !cfg!(test) && exe.file_stem().and_then(|s| s.to_str()) == Some("mint") {
+            let mut c = Command::new(exe);
+            c.arg("--mint-mod-host");
+            Self::spawn_process(c)?
+        } else {
+            Self::spawn_thread()?
+        };
         let mut worker = Self {
             child,
             input,
@@ -469,9 +532,12 @@ impl Worker {
         }
     }
     fn send(&mut self, value: &Value) -> Result<(), String> {
-        writeln!(self.input, "{value}")
-            .and_then(|_| self.input.flush())
-            .map_err(|e| e.to_string())
+        match &mut self.input {
+            WorkerInput::Process(stdin) => writeln!(stdin, "{value}")
+                .and_then(|_| stdin.flush())
+                .map_err(|e| e.to_string()),
+            WorkerInput::Thread(tx) => tx.send(value.clone()).map_err(|e| e.to_string()),
+        }
     }
     fn exchange(&mut self, request: &Value) -> Result<Value, String> {
         self.phase = request["kind"].as_str().unwrap_or("register").to_owned();