@pheem49/mint 1.15.0 → 1.16.0

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

@@ -0,0 +1,187 @@
+use ratatui::{
+    style::{Color, Style},
+    text::{Line, Span},
+};
+use serde_json::Value;
+#[derive(Clone)]
+pub(crate) struct Control {
+    pub id: String,
+    pub instance: String,
+    pub action: String,
+    pub label: String,
+    pub input: bool,
+    pub value: String,
+}
+fn clean(text: &str) -> String {
+    text.chars()
+        .filter(|c| !c.is_control() || *c == '\n')
+        .take(4096)
+        .collect()
+}
+pub(crate) fn node_lines(node: &Value) -> Vec<String> {
+    match node["type"].as_str().unwrap_or("") {
+        "text" | "badge" => clean(node["text"].as_str().unwrap_or(""))
+            .lines()
+            .map(str::to_owned)
+            .collect(),
+        "stack" => node["children"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .flat_map(node_lines)
+            .collect(),
+        "button" => vec![format!(
+            "[ {} ]",
+            clean(node["label"].as_str().unwrap_or(""))
+        )],
+        "input" => vec![format!(
+            "{}: {}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_str().unwrap_or("")
+        )],
+        "progress" => vec![format!(
+            "{}: {:.0}/{:.0}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_f64().unwrap_or(0.0),
+            node["max"].as_f64().unwrap_or(1.0)
+        )],
+        "table" => {
+            let mut lines = vec![
+                node["columns"]
+                    .as_array()
+                    .map(|c| {
+                        c.iter()
+                            .map(|s| clean(s.as_str().unwrap_or("")))
+                            .collect::<Vec<_>>()
+                            .join(" | ")
+                    })
+                    .unwrap_or_default(),
+            ];
+            for row in node["rows"].as_array().into_iter().flatten() {
+                lines.push(
+                    row.as_array()
+                        .map(|r| {
+                            r.iter()
+                                .map(|v| {
+                                    clean(
+                                        &v.as_str()
+                                            .map(str::to_owned)
+                                            .unwrap_or_else(|| v.to_string()),
+                                    )
+                                })
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        })
+                        .unwrap_or_default(),
+                );
+            }
+            lines
+        }
+        _ => vec![],
+    }
+}
+fn styled_lines(node: &Value, inherited: Style) -> Vec<Line<'static>> {
+    let color = match node["color"].as_str() {
+        Some("yellow") => Some(Color::Yellow),
+        Some("cyan") => Some(Color::Cyan),
+        Some("blue") => Some(Color::Blue),
+        Some("magenta") => Some(Color::Magenta),
+        Some("red") => Some(Color::Red),
+        Some("default") => Some(Color::Reset),
+        _ => None,
+    };
+    let style = color.map(|c| inherited.fg(c)).unwrap_or(inherited);
+    if node["type"] == "stack" {
+        let children = node["children"].as_array().into_iter().flatten();
+        if node["direction"] == "row" {
+            let mut spans = vec![];
+            for child in children {
+                let lines = styled_lines(child, style);
+                for line in lines {
+                    if !spans.is_empty() {
+                        spans.push(Span::raw(" "));
+                    }
+                    spans.extend(line.spans);
+                }
+            }
+            vec![Line::from(spans)]
+        } else {
+            children
+                .flat_map(|child| styled_lines(child, style))
+                .collect()
+        }
+    } else {
+        node_lines(node)
+            .into_iter()
+            .map(|text| Line::from(Span::styled(text, style)))
+            .collect()
+    }
+}
+pub(crate) fn controls(mods: &[Value]) -> Vec<Control> {
+    fn walk(node: &Value, m: &Value, result: &mut Vec<Control>) {
+        if matches!(node["type"].as_str(), Some("button" | "input")) {
+            result.push(Control {
+                id: m["id"].as_str().unwrap_or("").into(),
+                instance: m["instanceId"].as_str().unwrap_or("").into(),
+                action: node["action"].as_str().unwrap_or("").into(),
+                label: clean(node["label"].as_str().unwrap_or("")),
+                input: node["type"] == "input",
+                value: node["value"].as_str().unwrap_or("").into(),
+            });
+        }
+        for child in node["children"].as_array().into_iter().flatten() {
+            walk(child, m, result);
+        }
+    }
+    let mut result = vec![];
+    for m in mods {
+        if m["enabled"] == true {
+            walk(&m["snapshot"]["ui"]["above_composer"], m, &mut result);
+            walk(&m["snapshot"]["ui"]["side_panel"], m, &mut result);
+        }
+    }
+    result
+}
+pub(crate) fn slot_lines(mods: &[Value], slot: &str) -> Vec<Line<'static>> {
+    let mut lines = vec![];
+    for m in mods {
+        if m["enabled"] != true {
+            continue;
+        }
+        if slot == "side_panel" {
+            lines.push(Line::raw(clean(m["name"].as_str().unwrap_or("Mod"))));
+        }
+        lines.extend(styled_lines(&m["snapshot"]["ui"][slot], Style::default()));
+        if let Some(error) = m["error"].as_str() {
+            lines.push(Line::raw(format!("Error: {}", clean(error))));
+        }
+        if let Some(error) = m["reloadError"].as_str() {
+            lines.push(Line::raw(format!("Reload: {}", clean(error))));
+        }
+    }
+    lines
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn keyboard_controls_include_actions_from_both_ui_slots() {
+        let mods = vec![
+            json!({"id":"example","enabled":true,"instanceId":"revision",
+            "snapshot":{"ui":{
+                "above_composer":{"type":"button","label":"Inspect","action":"inspect"},
+                "side_panel":{"type":"input","label":"Draft","action":"save","value":"existing"}
+            }}}),
+        ];
+        let available = controls(&mods);
+        assert_eq!(available.len(), 2);
+        assert!(
+            available
+                .iter()
+                .any(|c| c.action == "inspect" && c.instance == "revision")
+        );
+    }
+}

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

@@ -46,17 +46,6 @@ async fn fetch_video_models_with_notice(
     models
 }
 
-// ── Realtime Live Model (Gemini Live voice) ─────────────────────────────────
-// Note: gemini-3.1-flash-live-preview requires requesting allowlist access from Google
-// before it works; gemini-2.5-flash-native-audio-preview-12-2025 needs no such request as
-// of writing, so it's listed first and used as the default. gemini-3.1-flash-tts-preview is
-// deliberately NOT offered here — it's a generateContent-only TTS model, not a Live/
-// BidiGenerateContent model, and will never work with this feature.
-const GEMINI_LIVE_MODEL_PRESETS: &[&str] = &[
-    "gemini-2.5-flash-native-audio-preview-12-2025",
-    "gemini-3.1-flash-live-preview",
-];
-
 async fn fetch_models_with_notice(config: &mint_core::MintConfig, provider: &str) -> Vec<String> {
     print!("\x1b[90mFetching available {provider} models...\x1b[0m\r");
     let _ = std::io::Write::flush(&mut std::io::stdout());
@@ -66,29 +55,14 @@ async fn fetch_models_with_notice(config: &mint_core::MintConfig, provider: &str
     models
 }
 
-/// Fetch Gemini Live–capable models (BidiGenerateContent / native-audio) with a
-/// short spinner. Falls back to `GEMINI_LIVE_MODEL_PRESETS` on any error so the
-/// UI is never empty.
-async fn fetch_live_models_with_notice(api_key: &str) -> Vec<String> {
+/// Fetch Gemini Live model choices while displaying the CLI progress notice.
+async fn fetch_live_models_with_notice(config: &mint_core::MintConfig) -> Vec<String> {
     print!("\x1b[90mFetching available Gemini Live models...\x1b[0m\r");
     let _ = std::io::Write::flush(&mut std::io::stdout());
-    let live = mint_core::slash::model_fetcher::fetch_gemini_live_models(api_key).await;
+    let models = mint_core::model_catalog::live_models(config, "").await;
     print!("\r\x1b[2K");
     let _ = std::io::Write::flush(&mut std::io::stdout());
-
-    if live.is_empty() {
-        // Fallback: static presets.
-        static_model_options(GEMINI_LIVE_MODEL_PRESETS)
-    } else {
-        // Merge: live first, then any presets not already present.
-        let mut merged = live;
-        for p in GEMINI_LIVE_MODEL_PRESETS {
-            if !merged.iter().any(|m| m == p) {
-                merged.push(p.to_string());
-            }
-        }
-        merged
-    }
+    models
 }
 
 pub async fn run() -> Result<()> {
@@ -1112,7 +1086,7 @@ pub async fn run() -> Result<()> {
             .unwrap_or("gemini-2.5-flash-native-audio-preview-12-2025")
             .to_string();
         // Fetch live-capable models dynamically; fallback to presets if offline/no key.
-        let live_model_options = fetch_live_models_with_notice(&config.api_key).await;
+        let live_model_options = fetch_live_models_with_notice(&config).await;
         let selected_live_model = prompt_select_or_custom(
             "Realtime Live Model",
             live_model_options,

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,133 @@
+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 = root.with_extension("outside.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