@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-cli/src/terminal_theme.rs

@@ -110,7 +110,7 @@ pub fn apply_tui_theme(buffer: &mut Buffer, theme: TuiTheme) {
     for cell in &mut buffer.content {
         match theme {
             TuiTheme::Auto => {
-                if cell.fg == Color::White {
+                if cell.fg == Color::White && cell.bg != USER_MESSAGE_BACKGROUND {
                     cell.fg = Color::Reset;
                 }
                 if cell.bg == PANEL_BACKGROUND {
@@ -141,6 +141,7 @@ pub fn apply_tui_theme(buffer: &mut Buffer, theme: TuiTheme) {
                 cell.bg = match cell.bg {
                     Color::Reset => Color::Rgb(247, 249, 246),
                     PANEL_BACKGROUND => Color::Rgb(228, 238, 230),
+                    USER_MESSAGE_BACKGROUND => Color::Rgb(225, 225, 225),
                     Color::Gray => Color::Rgb(185, 215, 196),
                     other => other,
                 };
@@ -162,6 +163,7 @@ pub const WARNING: Color = Color::Yellow;
 pub const SELECTION_TEXT: Color = Color::Black;
 pub const SELECTION_BACKGROUND: Color = Color::Gray;
 pub const PANEL_BACKGROUND: Color = Color::Rgb(38, 48, 45); // #26302D
+pub const USER_MESSAGE_BACKGROUND: Color = Color::Rgb(64, 64, 64); // #404040
 /// Endpoints for the animated white glow used by the TUI thinking status.
 pub const THINKING_GLOW_DIM: (u8, u8, u8) = (100, 100, 110);
 pub const THINKING_GLOW_BRIGHT: (u8, u8, u8) = (255, 255, 255);

package/crates/mint-cli/src/updater.rs

@@ -102,6 +102,44 @@ pub fn run(check_only: bool, dry_run: bool, approved: bool) -> Result<()> {
     Ok(())
 }
 
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+struct UpdatePreferences {
+    skipped_version: Option<String>,
+}
+
+fn preferences_path() -> Option<PathBuf> {
+    cache_path().map(|path| path.with_file_name("update-preferences.json"))
+}
+
+fn update_is_visible_at(path: &std::path::Path, latest: &str) -> bool {
+    let preferences: UpdatePreferences = std::fs::read(path)
+        .ok()
+        .and_then(|bytes| serde_json::from_slice(&bytes).ok())
+        .unwrap_or_default();
+    preferences.skipped_version.as_deref() != Some(latest)
+}
+
+fn skip_version_at(path: &std::path::Path, latest: &str) -> Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let preferences = UpdatePreferences {
+        skipped_version: Some(latest.to_owned()),
+    };
+    std::fs::write(path, serde_json::to_vec_pretty(&preferences)?)?;
+    Ok(())
+}
+
+pub fn skip_version(latest: &str) -> Result<()> {
+    let path =
+        preferences_path().ok_or_else(|| anyhow::anyhow!("could not locate update preferences"))?;
+    skip_version_at(&path, latest)
+}
+
+fn update_is_visible(latest: &str) -> bool {
+    preferences_path().is_none_or(|path| update_is_visible_at(&path, latest))
+}
+
 fn npm() -> &'static str {
     if cfg!(target_os = "windows") {
         "npm.cmd"
@@ -156,7 +194,9 @@ pub fn get_cached_update_notice() -> Option<(String, String)> {
     let data = std::fs::read_to_string(path).ok()?;
     let cache: UpdateCache = serde_json::from_str(&data).ok()?;
     let current = env!("CARGO_PKG_VERSION");
-    if compare_versions(current, &cache.latest_version) < 0 {
+    if compare_versions(current, &cache.latest_version) < 0
+        && update_is_visible(&cache.latest_version)
+    {
         Some((current.to_owned(), cache.latest_version))
     } else {
         None
@@ -201,7 +241,7 @@ pub fn check_for_update_quietly() -> Option<(String, String)> {
         return None;
     }
     write_cache(&latest);
-    if compare_versions(current, &latest) < 0 {
+    if compare_versions(current, &latest) < 0 && update_is_visible(&latest) {
         Some((current.to_owned(), latest))
     } else {
         None
@@ -351,6 +391,20 @@ fn compare_versions(left: &str, right: &str) -> i8 {
 mod tests {
     use super::*;
 
+    #[test]
+    fn skipped_version_survives_reload_but_does_not_hide_next_release() {
+        let path = std::env::temp_dir().join(format!(
+            "mint-update-preferences-{}.json",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_file(&path);
+        assert!(update_is_visible_at(&path, "2.0.0"));
+        skip_version_at(&path, "2.0.0").unwrap();
+        assert!(!update_is_visible_at(&path, "2.0.0"));
+        assert!(update_is_visible_at(&path, "2.1.0"));
+        std::fs::remove_file(&path).unwrap();
+    }
+
     #[test]
     fn compares_semantic_versions() {
         assert_eq!(compare_versions("1.5.4", "1.6.0"), -1);

package/crates/mint-cli/tests/library_intake.rs

@@ -0,0 +1,77 @@
+//! CLI and Full-Screen TUI use the same agent execution entry point.
+use std::{
+    fs,
+    process::Command,
+    time::{SystemTime, UNIX_EPOCH},
+};
+#[test]
+fn cli_agent_and_plain_chat_save_attachments_before_provider_failure() {
+    for plain in [false, true] {
+        let root = std::env::temp_dir().join(format!(
+            "mint-cli-library-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        let config = mint_core::MintConfig {
+            ai_provider: "unsupported-library-test".into(),
+            ..Default::default()
+        };
+        fs::write(
+            root.join("config.json"),
+            serde_json::to_vec(&config).unwrap(),
+        )
+        .unwrap();
+        fs::write(root.join("reference.png"), b"fixture-image").unwrap();
+        let mut command = Command::new(env!("CARGO_BIN_EXE_mint"));
+        command
+            .args(["--fast", "chat", "Inspect image", "--image"])
+            .arg(root.join("reference.png"));
+        if plain {
+            command.args(["--system", "Describe the attached image"]);
+        }
+        let output = command
+            .current_dir(&root)
+            .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"))
+            .env_remove("GEMINI_API_KEY")
+            .env_remove("OPENAI_API_KEY")
+            .env_remove("ANTHROPIC_API_KEY")
+            .output()
+            .unwrap();
+        assert!(
+            !output.status.success(),
+            "unsupported provider unexpectedly succeeded"
+        );
+        let store = mint_core::library::LibraryStore::open(
+            mint_core::MemoryStore::open(root.join("config/mint/mint-knowledge.sqlite")),
+            root.join("Library"),
+            root.join("Pictures"),
+        )
+        .unwrap();
+        let page = store
+            .list(&mint_core::library::LibraryQuery {
+                chat_id: Some("cli".into()),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(
+            page.items.len(),
+            1,
+            "attachment missing after failed {plain:?} run: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        assert_eq!(page.items[0].name, "reference.png");
+        assert_eq!(
+            store.read(&page.items[0].id, false).unwrap().1,
+            b"fixture-image"
+        );
+        assert!(page.items[0].references[0].interaction_id.is_some());
+        let _ = fs::remove_dir_all(root);
+    }
+}

package/crates/mint-cli/tests/mods_testing.rs

@@ -0,0 +1,137 @@
+use std::process::Command;
+
+#[test]
+fn mod_export_requires_replace_and_preserves_quoted_paths() {
+    let root = std::env::temp_dir().join(format!(
+        "mint-mod-export-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    let dir = root.join("mint-mods/sample");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(
+        dir.join("manifest.json"),
+        r#"{"id":"sample","name":"Sample","version":"1","sdkVersion":1,"entry":"main.ts"}"#,
+    )
+    .unwrap();
+    std::fs::write(dir.join("main.ts"), "export function register(mint) {}").unwrap();
+    let config = mint_core::MintConfig {
+        allowed_read_paths: vec![root.clone()],
+        allowed_write_paths: vec![root.clone()],
+        ..Default::default()
+    };
+    std::fs::write(
+        root.join("config.json"),
+        serde_json::to_vec(&config).unwrap(),
+    )
+    .unwrap();
+    let run = |args: &[&str]| {
+        Command::new(env!("CARGO_BIN_EXE_mint"))
+            .args(args)
+            .current_dir(&root)
+            .env("MINT_CONFIG_PATH", root.join("config.json"))
+            .env("XDG_DATA_HOME", root.join("data"))
+            .output()
+            .unwrap()
+    };
+    let filename = "sample's exported file.mintmod";
+    std::fs::write(root.join(filename), "keep this").unwrap();
+    assert!(
+        !run(&["mods", "export", "sample", filename])
+            .status
+            .success()
+    );
+    assert_eq!(
+        std::fs::read_to_string(root.join(filename)).unwrap(),
+        "keep this"
+    );
+    let replaced = run(&["mods", "export", "sample", filename, "--replace"]);
+    assert!(
+        replaced.status.success(),
+        "{}",
+        String::from_utf8_lossy(&replaced.stderr)
+    );
+    assert!(mint_mod_runtime::unpack(&std::fs::read(root.join(filename)).unwrap()).is_ok());
+    assert!(
+        run(&["mods", "export", "sample", "--replace"])
+            .status
+            .success()
+    );
+    assert!(root.join("sample.mintmod").exists());
+    assert!(!root.join("--replace").exists());
+    let outside = if cfg!(windows) {
+        std::path::PathBuf::from(r"C:\mint_disallowed_outside\sample.mintmod")
+    } else {
+        std::path::PathBuf::from("/mint_disallowed_outside/sample.mintmod")
+    };
+    assert!(
+        !run(&["mods", "export", "sample", outside.to_str().unwrap()])
+            .status
+            .success()
+    );
+    assert!(!outside.exists());
+    // A package exported from a legacy mod installs into the new directory.
+    std::fs::rename(root.join("mint-mods"), root.join("legacy-backup")).unwrap();
+    let imported = run(&["mods", "import", filename]);
+    assert!(
+        imported.status.success(),
+        "{}",
+        String::from_utf8_lossy(&imported.stderr)
+    );
+    assert!(root.join(".mint-mods/sample/main.ts").is_file());
+    assert!(!root.join("mint-mods").exists());
+    assert!(
+        run(&["mods", "export", "sample", "hidden.mintmod"])
+            .status
+            .success()
+    );
+    std::fs::remove_dir_all(root).unwrap();
+}
+
+#[test]
+fn mod_test_command_reports_failures_with_a_nonzero_exit_code() {
+    let root = std::env::temp_dir().join(format!(
+        "mint-mod-cli-tests-{}",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    let dir = root.join("mint-mods/sample/tests");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(root.join("config.json"), "{}").unwrap();
+    std::fs::write(
+        dir.parent().unwrap().join("manifest.json"),
+        r#"{"id":"sample","name":"Sample","version":"1","sdkVersion":1,"entry":"main.ts"}"#,
+    )
+    .unwrap();
+    std::fs::write(dir.parent().unwrap().join("main.ts"),"export function register(mint){mint.commands.register('add',()=>mint.state.set('added',true));}").unwrap();
+    let run = || {
+        Command::new(env!("CARGO_BIN_EXE_mint"))
+            .args(["mods", "test", "sample"])
+            .current_dir(&root)
+            .env("MINT_CONFIG_PATH", root.join("config.json"))
+            .output()
+            .unwrap()
+    };
+    std::fs::write(dir.join("sample.test.ts"),"export function registerTests(test){test('fails',({equal})=>equal(1,2,'Expected update'));}").unwrap();
+    let failed = run();
+    assert!(
+        !failed.status.success(),
+        "{}",
+        String::from_utf8_lossy(&failed.stdout)
+    );
+    assert!(String::from_utf8_lossy(&failed.stdout).contains("Expected update"));
+    std::fs::write(dir.join("sample.test.ts"),"export function registerTests(test){test('passes',async({command,state,equal})=>{await command('add');equal(state('added'),true);});}").unwrap();
+    let passed = run();
+    assert!(
+        passed.status.success(),
+        "{}",
+        String::from_utf8_lossy(&passed.stderr)
+    );
+    assert!(String::from_utf8_lossy(&passed.stdout).contains("passes"));
+    std::fs::remove_dir_all(root).unwrap();
+}

package/crates/mint-companion-protocol/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "mint-companion-protocol"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+dirs.workspace = true
+serde.workspace = true
+serde_json.workspace = true

package/crates/mint-companion-protocol/src/lib.rs

@@ -0,0 +1,276 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+pub const VERSION: u32 = 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HostDescriptor {
+    pub version: u32,
+    pub host_id: String,
+    pub name: String,
+    pub endpoint: String,
+    pub token: String,
+    /// Stable executable and launch-directory identity; absent on older hosts.
+    #[serde(default)]
+    pub identity: Option<String>,
+}
+
+pub fn hosts_dir() -> Option<std::path::PathBuf> {
+    dirs::config_dir().map(|p| p.join("mint/companion/hosts"))
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Status {
+    Queued,
+    #[default]
+    Thinking,
+    Working,
+    Responding,
+    Waiting,
+    Completed,
+    Failed,
+    Interrupted,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Surface {
+    Desktop,
+    Web,
+    Tui,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum NavigationOutcome {
+    Opened,
+    NeedsTerminal,
+    MissingSession,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Session {
+    pub chat_id: String,
+    pub title: String,
+    pub workspace: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Turn {
+    pub chat_id: String,
+    pub turn_id: i64,
+    pub seq: u64,
+    pub status: Status,
+    pub tool: Option<String>,
+    pub text: String,
+    #[serde(default)]
+    pub prompt: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(
+    tag = "operation",
+    rename_all = "snake_case",
+    rename_all_fields = "camelCase",
+    deny_unknown_fields
+)]
+pub enum SpeechRequest {
+    Prefer {
+        owner: String,
+        chat_id: String,
+        enabled: bool,
+    },
+    Prepare {
+        owner: String,
+        chat_id: String,
+        turn_id: Option<i64>,
+        text: Option<String>,
+        #[serde(default)]
+        automatic: bool,
+        #[serde(default)]
+        audio_only: bool,
+        #[serde(default)]
+        route_owner: Option<String>,
+    },
+    Audio {
+        owner: String,
+        index: usize,
+    },
+    Renew {
+        owner: String,
+    },
+    Release {
+        owner: String,
+    },
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(
+    tag = "kind",
+    rename_all = "snake_case",
+    rename_all_fields = "camelCase"
+)]
+pub enum SpeechReply {
+    Prepared {
+        text: String,
+        provider: String,
+        volume: f64,
+        speed: f64,
+        pitch: f64,
+        chunks: usize,
+    },
+    Audio {
+        data: String,
+    },
+    Lease {
+        active: bool,
+    },
+    Released,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
+pub enum Command {
+    ListSessions,
+    Speech {
+        request: SpeechRequest,
+    },
+    OpenChat {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+        #[serde(default, rename = "newTerminal")]
+        new_terminal: bool,
+    },
+    Subscribe {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+    },
+    SendChat {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+        #[serde(rename = "requestId")]
+        request_id: String,
+        message: String,
+    },
+    Interact {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+        #[serde(rename = "requestId")]
+        request_id: String,
+        area: String,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Event {
+    Speech {
+        reply: SpeechReply,
+    },
+    Navigation {
+        outcome: NavigationOutcome,
+    },
+    Snapshot {
+        #[serde(rename = "hostId")]
+        host_id: String,
+        version: u32,
+        #[serde(default)]
+        surface: Option<Surface>,
+        #[serde(default)]
+        speech: bool,
+        #[serde(default, rename = "chatId")]
+        chat_id: Option<String>,
+        sessions: Vec<Session>,
+        turns: Vec<Turn>,
+    },
+    Update {
+        #[serde(rename = "hostId")]
+        host_id: String,
+        turn: Turn,
+    },
+    Accepted {
+        #[serde(rename = "requestId")]
+        request_id: String,
+        #[serde(rename = "turnId")]
+        turn_id: Option<i64>,
+    },
+    Error {
+        #[serde(rename = "requestId")]
+        request_id: Option<String>,
+        message: String,
+    },
+}
+
+#[derive(Default)]
+pub struct TurnBook(pub BTreeMap<(String, i64), Turn>);
+
+impl TurnBook {
+    pub fn apply(&mut self, turn: Turn) -> bool {
+        let key = (turn.chat_id.clone(), turn.turn_id);
+        if self.0.get(&key).is_some_and(|old| old.seq >= turn.seq) {
+            return false;
+        }
+        self.0.insert(key, turn);
+        true
+    }
+    pub fn session(&self, chat_id: &str) -> Vec<Turn> {
+        self.0
+            .values()
+            .filter(|t| t.chat_id == chat_id)
+            .cloned()
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn turn(chat: &str, id: i64, seq: u64, status: Status) -> Turn {
+        Turn {
+            chat_id: chat.into(),
+            turn_id: id,
+            seq,
+            status,
+            tool: None,
+            text: String::new(),
+            prompt: String::new(),
+        }
+    }
+    #[test]
+    fn snapshots_keep_concurrent_sessions_separate() {
+        let mut book = TurnBook::default();
+        book.apply(turn("one", 1, 1, Status::Working));
+        book.apply(turn("two", 2, 2, Status::Responding));
+        assert_eq!(book.session("one").len(), 1);
+        assert_eq!(book.session("one")[0].status, Status::Working);
+    }
+    #[test]
+    fn late_updates_cannot_overwrite_completed_turns() {
+        let mut book = TurnBook::default();
+        assert!(book.apply(turn("one", 1, 3, Status::Completed)));
+        assert!(!book.apply(turn("one", 1, 2, Status::Thinking)));
+        assert_eq!(book.session("one")[0].status, Status::Completed);
+    }
+    #[test]
+    fn clients_cannot_inject_tools_or_system_instructions() {
+        let wire =
+            r#"{"type":"send_chat","chatId":"one","requestId":"req","message":"hi","tools":[{}]}"#;
+        assert!(serde_json::from_str::<Command>(wire).is_err());
+    }
+}
+
+#[cfg(test)]
+mod navigation_tests {
+    use super::*;
+    #[test]
+    fn open_chat_is_an_explicit_navigation_request_without_chat_submission() {
+        let request =
+            serde_json::json!({"type":"open_chat","chatId":"cli::saved","newTerminal":false});
+        assert!(serde_json::from_value::<Command>(request).is_ok());
+        let injected = serde_json::json!({"type":"open_chat","chatId":"cli::saved","newTerminal":false,"executable":"evil"});
+        assert!(serde_json::from_value::<Command>(injected).is_err());
+    }
+}

package/crates/mint-core/Cargo.toml

@@ -21,6 +21,10 @@ hmac.workspace = true
 hound = "3"
 ignore.workspace = true
 image.workspace = true
+mint-companion-protocol = { path = "../mint-companion-protocol" }
+mint-mod-runtime = { path = "../mint-mod-runtime" }
+jsonschema = { version = "0.58.6", default-features = false }
+libc = "0.2"
 quick-xml.workspace = true
 regex.workspace = true
 reqwest.workspace = true
@@ -34,11 +38,10 @@ similar.workspace = true
 srtlib.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
+tokio-util = { version = "0.7", features = ["rt"] }
 tokio-tungstenite.workspace = true
+trash = "5.2"
 tree-sitter.workspace = true
 tree-sitter-rust.workspace = true
 tree-sitter-typescript.workspace = true
 uuid.workspace = true
-
-
-

package/crates/mint-core/build.rs

@@ -0,0 +1,26 @@
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    let manifest = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
+    let root = manifest.join("../..");
+    let notes = root.join("Release_Note.md");
+    let bundle =
+        env::var("MINT_BUNDLE_RELEASE_NOTES").as_deref() == Ok("1") || !root.join(".git").exists();
+
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-env-changed=MINT_BUNDLE_RELEASE_NOTES");
+    if bundle {
+        println!("cargo:rerun-if-changed={}", notes.display());
+    }
+    println!(
+        "cargo:rustc-env=MINT_LIVE_RELEASE_NOTES={}",
+        if bundle { "0" } else { "1" }
+    );
+
+    // Keep the snapshot in OUT_DIR: a dev notes edit must not invalidate Rust's
+    // include_str dependency. Shipping builds explicitly track the source file.
+    let snapshot =
+        fs::read(&notes).expect("Release_Note.md is required when creating the snapshot");
+    let output = PathBuf::from(env::var_os("OUT_DIR").unwrap()).join("release-notes.md");
+    fs::write(output, snapshot).expect("write the release notes snapshot");
+}