@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/system/config.rs

@@ -137,14 +137,16 @@ pub struct MintConfig {
     pub disabled_tools: Vec<String>,
     pub agents: Vec<AgentConfig>,
     pub enable_agent_collaboration: bool,
-    /// When true, a background reflection call runs after a task finishes and may
-    /// write a new `.agents/skills/<slug>/SKILL.md` file — or refine an existing
-    /// one, bumping its `revisions` count — if the task looks like a non-trivial,
-    /// reusable problem. On by default (`/skill off` or the Settings toggle turns
-    /// it off): it does cost an extra LLM call and write a file without
-    /// interactive approval each time `looks_skill_worthy` fires, but that's the
-    /// self-improving-over-time behavior this exists for. See
-    /// [`crate::orchestration::spawn_auto_skill_write`].
+    /// Maximum number of sub-agents run concurrently within a swarm batch
+    /// (1..=8, default 4). Clamped when used.
+    #[serde(default = "default_swarm_max_parallel")]
+    pub swarm_max_parallel: usize,
+    /// Maximum steps allowed per agent turn (default 40, clamped to 10..=200).
+    #[serde(default = "default_agent_max_steps")]
+    pub agent_max_steps: usize,
+    /// When true, reflection after a reusable task proposes a new or refined
+    /// workspace skill. Every proposal needs interactive approval before saving.
+    /// Off by default; `/autoskill on` enables proposals, not unattended writes.
     pub auto_skill_writing: bool,
     /// When true, each turn runs a full-text search over the current
     /// conversation's older messages and injects the few most relevant to the
@@ -156,7 +158,7 @@ pub struct MintConfig {
     /// carries something worth remembering (`looks_fact_worthy`) extracts durable
     /// facts/preferences the user stated and writes them into the long-term
     /// `facts` table, so they ride every future turn. On by default (`/autofacts
-    /// off` disables it): like `auto_skill_writing` it costs an extra LLM call on
+    /// off` disables it): it costs an extra LLM call on
     /// each qualifying turn, without interactive approval — that's the
     /// self-evolving-memory behavior it exists for. See
     /// [`crate::orchestration::spawn_auto_memory_update`].
@@ -196,6 +198,16 @@ fn default_thinking_effort() -> String {
     "medium".into()
 }
 
+fn default_swarm_max_parallel() -> usize {
+    crate::swarm::DEFAULT_MAX_PARALLEL
+}
+
+pub const DEFAULT_AGENT_MAX_STEPS: usize = 40;
+
+fn default_agent_max_steps() -> usize {
+    DEFAULT_AGENT_MAX_STEPS
+}
+
 /// Thinking/reasoning configuration for a specific model.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
@@ -290,6 +302,15 @@ impl MintConfig {
     ) -> Option<PermissionDecision> {
         permission_decision_for(&self.permission_rules, tool, subject, project_root)
     }
+
+    /// Resolved maximum steps per turn, clamped between 10 and 200 (defaults to 40).
+    pub fn resolved_agent_max_steps(&self) -> usize {
+        if self.agent_max_steps == 0 {
+            DEFAULT_AGENT_MAX_STEPS
+        } else {
+            self.agent_max_steps.clamp(10, 200)
+        }
+    }
 }
 
 /// Core matching logic behind [`MintConfig::permission_decision`], exposed as a
@@ -369,9 +390,12 @@ impl Default for MintConfig {
     fn default() -> Self {
         let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
         let current_directory = std::env::current_dir().unwrap_or_else(|_| home.clone());
-        let allowed_paths = vec![
+        let temp_dir = std::env::temp_dir();
+        let canonical_temp = temp_dir.canonicalize().ok();
+        let mut allowed_paths = vec![
             home.clone(),
             current_directory,
+            temp_dir.clone(),
             home.join("Desktop"),
             home.join("Documents"),
             home.join("Downloads"),
@@ -379,6 +403,25 @@ impl Default for MintConfig {
             home.join("Music"),
             home.join("Videos"),
         ];
+        if let Some(canonical) = canonical_temp {
+            if canonical != temp_dir && !allowed_paths.contains(&canonical) {
+                allowed_paths.push(canonical);
+            }
+        }
+        #[cfg(unix)]
+        {
+            let slash_tmp = PathBuf::from("/tmp");
+            if slash_tmp.exists() {
+                if !allowed_paths.contains(&slash_tmp) {
+                    allowed_paths.push(slash_tmp.clone());
+                }
+                if let Ok(canonical_slash_tmp) = slash_tmp.canonicalize() {
+                    if !allowed_paths.contains(&canonical_slash_tmp) {
+                        allowed_paths.push(canonical_slash_tmp);
+                    }
+                }
+            }
+        }
         Self {
             theme: "dark".into(),
             tui_theme: "dark".into(),
@@ -439,7 +482,9 @@ impl Default for MintConfig {
             disabled_tools: Vec::new(),
             agents: default_agents(),
             enable_agent_collaboration: false,
-            auto_skill_writing: true,
+            swarm_max_parallel: crate::swarm::DEFAULT_MAX_PARALLEL,
+            agent_max_steps: DEFAULT_AGENT_MAX_STEPS,
+            auto_skill_writing: false,
             memory_recall: true,
             auto_fact_extraction: true,
             semantic_fact_recall: true,
@@ -1017,6 +1062,11 @@ fn is_test_environment() -> bool {
     false
 }
 
+/// Returns the root configuration directory for Mint (`~/.config/mint`).
+pub fn mint_config_dir() -> Option<PathBuf> {
+    dirs::config_dir().map(|dir| dir.join("mint"))
+}
+
 pub fn config_path() -> Result<PathBuf, ConfigError> {
     if let Ok(override_path) = std::env::var("MINT_CONFIG_PATH") {
         return Ok(PathBuf::from(override_path));
@@ -1027,8 +1077,8 @@ pub fn config_path() -> Result<PathBuf, ConfigError> {
             .join("mint-config.json");
         return Ok(tmp);
     }
-    dirs::config_dir()
-        .map(|directory| directory.join("mint").join("mint-config.json"))
+    mint_config_dir()
+        .map(|directory| directory.join("mint-config.json"))
         .ok_or(ConfigError::ConfigDirectoryUnavailable)
 }
 
@@ -1177,6 +1227,11 @@ fn default_sandbox_command() -> &'static str {
 fn runtime_extra_defaults() -> BTreeMap<String, Value> {
     serde_json::from_value(serde_json::json!({
         "automationBrowser": "chromium",
+        "browserAutomationEnabled": true,
+        "browserAgentMode": "headless",
+        "browserExecutable": "",
+        "browserViewportWidth": 1440,
+        "browserViewportHeight": 900,
         "browserDebugUrl": "http://127.0.0.1:9222/json/list",
         "browserExtensionContextUrl": "http://127.0.0.1:3212/context",
         "proactiveInterval": 60,
@@ -1813,4 +1868,33 @@ mod tests {
         let (enabled, _) = config.resolved_thinking();
         assert!(!enabled);
     }
+
+    #[test]
+    fn test_agent_max_steps_config_and_clamping() {
+        let mut config = MintConfig::default();
+        assert_eq!(config.agent_max_steps, DEFAULT_AGENT_MAX_STEPS);
+        assert_eq!(config.resolved_agent_max_steps(), 40);
+
+        // Clamping to min 10
+        config.agent_max_steps = 3;
+        assert_eq!(config.resolved_agent_max_steps(), 10);
+
+        // Clamping to max 200
+        config.agent_max_steps = 500;
+        assert_eq!(config.resolved_agent_max_steps(), 200);
+
+        // Zero defaults to 40
+        config.agent_max_steps = 0;
+        assert_eq!(config.resolved_agent_max_steps(), 40);
+
+        // Custom in-range value
+        config.agent_max_steps = 75;
+        assert_eq!(config.resolved_agent_max_steps(), 75);
+
+        // Deserialization with camelCase agentMaxSteps
+        let json_str = r#"{"agentMaxSteps": 60}"#;
+        let deserialized: MintConfig = serde_json::from_str(json_str).unwrap();
+        assert_eq!(deserialized.agent_max_steps, 60);
+        assert_eq!(deserialized.resolved_agent_max_steps(), 60);
+    }
 }

package/crates/mint-core/src/system/html_preview.rs

@@ -0,0 +1,398 @@
+//! Dependency-free, loopback-only static HTML preview, tracked as a background job.
+use crate::{Capability, MintConfig, assert_path_capability};
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{Read, Write},
+    net::{TcpListener, TcpStream},
+    path::{Path, PathBuf},
+    sync::{
+        Arc, LazyLock, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+
+static SERVERS: LazyLock<Mutex<HashMap<(PathBuf, Option<String>), (String, String)>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
+
+pub fn start(
+    root: &Path,
+    relative: &str,
+    owner: Option<String>,
+    config: &MintConfig,
+) -> Result<serde_json::Value, String> {
+    let root = assert_path_capability(root, Capability::Read, config).map_err(|e| e.to_string())?;
+    let file = super::workspace::resolve(&root, relative)?;
+    assert_path_capability(&file, Capability::Read, config).map_err(|e| e.to_string())?;
+    let extension = file
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("")
+        .to_ascii_lowercase();
+    if !file.is_file()
+        || !(matches!(extension.as_str(), "html" | "htm" | "md" | "markdown") || is_image(&file))
+    {
+        return Err("Select an existing HTML, Markdown, or image file inside the workspace".into());
+    }
+    if Path::new(relative)
+        .components()
+        .any(|p| p.as_os_str().to_string_lossy().starts_with('.'))
+    {
+        return Err("Hidden files cannot be served by preview".into());
+    }
+    let mut servers = SERVERS.lock().map_err(|e| e.to_string())?;
+    servers.retain(|_, (id, _)| {
+        crate::bg_shell::job_json(id, false).is_ok_and(|j| j["status"] == "running")
+    });
+    let key = (root.clone(), owner.clone());
+    let existing = servers
+        .get(&key)
+        .filter(|(id, _)| {
+            crate::bg_shell::job_json(id, false).is_ok_and(|j| j["status"] == "running")
+        })
+        .cloned();
+    let (id, base) = if let Some(value) = existing {
+        value
+    } else {
+        let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
+        listener.set_nonblocking(true).map_err(|e| e.to_string())?;
+        let base = format!(
+            "http://{}",
+            listener.local_addr().map_err(|e| e.to_string())?
+        );
+        let served_root = root.clone();
+        let served_config = config.clone();
+        let id = crate::bg_shell::start_local_service(root, owner, base.clone(), move |stop| {
+            while !stop.load(Ordering::Acquire) {
+                match listener.accept() {
+                    Ok((stream, _)) => {
+                        let _ = serve(stream, &served_root, &served_config, &stop);
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                        std::thread::sleep(Duration::from_millis(20))
+                    }
+                    Err(e) => return Err(e.to_string()),
+                }
+            }
+            Ok(())
+        })?;
+        servers.insert(key, (id.clone(), base.clone()));
+        (id, base)
+    };
+    let encoded = relative
+        .replace('\\', "/")
+        .split('/')
+        .map(|segment| {
+            segment
+                .bytes()
+                .map(|b| {
+                    if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {
+                        (b as char).to_string()
+                    } else {
+                        format!("%{b:02X}")
+                    }
+                })
+                .collect::<String>()
+        })
+        .collect::<Vec<_>>()
+        .join("/");
+    Ok(serde_json::json!({"url": format!("{base}/{encoded}"), "jobId": id}))
+}
+
+fn is_image(path: &Path) -> bool {
+    path.extension().and_then(|e| e.to_str()).is_some_and(|e| {
+        matches!(
+            e.to_ascii_lowercase().as_str(),
+            "svg" | "png" | "jpg" | "jpeg" | "webp" | "gif" | "ico"
+        )
+    })
+}
+
+fn reply(stream: &mut TcpStream, code: &str, message: &str) -> std::io::Result<()> {
+    write!(
+        stream,
+        "HTTP/1.1 {code}\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{message}",
+        message.len()
+    )
+}
+fn serve(
+    mut stream: TcpStream,
+    root: &Path,
+    config: &MintConfig,
+    stop: &Arc<AtomicBool>,
+) -> std::io::Result<()> {
+    stream.set_read_timeout(Some(Duration::from_millis(500)))?;
+    stream.set_write_timeout(Some(Duration::from_millis(500)))?;
+    let mut request = Vec::new();
+    let mut chunk = [0; 1024];
+    let deadline = std::time::Instant::now() + Duration::from_secs(1);
+    while !request.windows(4).any(|w| w == b"\r\n\r\n") {
+        if stop.load(Ordering::Acquire) || std::time::Instant::now() > deadline {
+            return Ok(());
+        }
+        let n = stream.read(&mut chunk)?;
+        if n == 0 || request.len() + n > 16384 {
+            return reply(&mut stream, "400 Bad Request", "Invalid request");
+        }
+        request.extend_from_slice(&chunk[..n]);
+    }
+    let request = String::from_utf8_lossy(&request);
+    let headers: HashMap<_, _> = request
+        .lines()
+        .skip(1)
+        .filter_map(|line| {
+            line.split_once(':')
+                .map(|(k, v)| (k.to_ascii_lowercase(), v.trim().to_string()))
+        })
+        .collect();
+    let mut words = request.lines().next().unwrap_or("").split_whitespace();
+    let method = words.next().unwrap_or("");
+    let target = words.next().unwrap_or("");
+    if !matches!(method, "GET" | "HEAD") {
+        return reply(&mut stream, "405 Method Not Allowed", "Read-only preview");
+    }
+    let address = stream.local_addr()?.to_string();
+    if headers.get("host").is_none_or(|host| host != &address) {
+        return reply(&mut stream, "403 Forbidden", "Preview access denied");
+    }
+    let cross_site_resource = headers
+        .get("sec-fetch-site")
+        .is_some_and(|s| s == "cross-site")
+        && headers
+            .get("sec-fetch-mode")
+            .is_none_or(|m| m != "navigate");
+    let raw = target
+        .split('?')
+        .next()
+        .unwrap_or("")
+        .strip_prefix('/')
+        .unwrap_or("");
+    let mut decoded = Vec::new();
+    let bytes = raw.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'%' {
+            if i + 2 >= bytes.len() {
+                return reply(&mut stream, "400 Bad Request", "Invalid path");
+            }
+            let Some(value) = std::str::from_utf8(&bytes[i + 1..i + 3])
+                .ok()
+                .and_then(|s| u8::from_str_radix(s, 16).ok())
+            else {
+                return reply(&mut stream, "400 Bad Request", "Invalid path");
+            };
+            decoded.push(value);
+            i += 3;
+        } else {
+            decoded.push(bytes[i]);
+            i += 1;
+        }
+    }
+    let Ok(relative) = String::from_utf8(decoded) else {
+        return reply(&mut stream, "400 Bad Request", "Invalid path");
+    };
+    if relative.contains('\\')
+        || relative.contains('\0')
+        || relative.split('/').any(|s| s.starts_with('.'))
+    {
+        return reply(&mut stream, "403 Forbidden", "Path denied");
+    }
+    let relative = if relative.is_empty() {
+        "index.html".to_string()
+    } else if relative.ends_with('/') {
+        format!("{relative}index.html")
+    } else {
+        relative
+    };
+    let Ok(path) = super::workspace::resolve(root, &relative).and_then(|p| {
+        assert_path_capability(&p, Capability::Read, config).map_err(|e| e.to_string())
+    }) else {
+        return reply(&mut stream, "403 Forbidden", "Path denied");
+    };
+    // The app can embed images across origins. Other cross-site subresources stay blocked;
+    // no CORS permission is granted to read either images or workspace source files.
+    if cross_site_resource
+        && !(headers.get("sec-fetch-dest").is_some_and(|d| d == "image") && is_image(&path))
+    {
+        return reply(&mut stream, "403 Forbidden", "Preview access denied");
+    }
+    if !path.is_file() {
+        return reply(&mut stream, "404 Not Found", "File not found");
+    }
+    let mut file = File::open(&path)?;
+    let mime = match path
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("")
+        .to_ascii_lowercase()
+        .as_str()
+    {
+        "html" | "htm" => "text/html; charset=utf-8",
+        "md" | "markdown" => "text/plain; charset=utf-8",
+        "css" => "text/css; charset=utf-8",
+        "js" | "mjs" => "text/javascript; charset=utf-8",
+        "json" | "map" => "application/json",
+        "svg" => "image/svg+xml",
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "webp" => "image/webp",
+        "gif" => "image/gif",
+        "ico" => "image/x-icon",
+        "woff" => "font/woff",
+        "woff2" => "font/woff2",
+        "wasm" => "application/wasm",
+        _ => "application/octet-stream",
+    };
+    write!(
+        stream,
+        "HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nX-Content-Type-Options: nosniff\r\nConnection: close\r\n\r\n",
+        file.metadata()?.len()
+    )?;
+    if method == "HEAD" {
+        return Ok(());
+    }
+    let mut buffer = [0; 65536];
+    while !stop.load(Ordering::Acquire) {
+        let n = file.read(&mut buffer)?;
+        if n == 0 {
+            break;
+        }
+        stream.write_all(&buffer[..n])?;
+    }
+    Ok(())
+}
+
+/// Text interface for CLI/TUI and authenticated slash-command hosts.
+pub fn command(
+    root: &Path,
+    path: &str,
+    owner: Option<String>,
+    config: &MintConfig,
+) -> Result<String, String> {
+    let path = path.trim();
+    if path.is_empty() {
+        return Ok("Usage: /preview <workspace-relative HTML, Markdown, or image file>".into());
+    }
+    let path = if path.starts_with('"') && path.ends_with('"') && path.len() > 1 {
+        &path[1..path.len() - 1]
+    } else {
+        path
+    };
+    let preview = start(root, path, owner, config)?;
+    Ok(format!(
+        "File preview: {}\n\nBackground terminal: `{}` · `/shells stop {}`",
+        preview["url"].as_str().unwrap_or(""),
+        preview["jobId"].as_str().unwrap_or(""),
+        preview["jobId"].as_str().unwrap_or("")
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    struct PreviewFixture {
+        root: PathBuf,
+        job: Option<String>,
+    }
+    impl Drop for PreviewFixture {
+        fn drop(&mut self) {
+            if let Some(id) = &self.job {
+                let _ = crate::bg_shell::kill_job(id);
+            }
+            let _ = std::fs::remove_dir_all(&self.root);
+        }
+    }
+    #[tokio::test]
+    async fn workspace_image_preview_streams_binary_with_the_correct_content_type() {
+        let root =
+            std::env::temp_dir().join(format!("mint-image-preview-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(root.join("assets")).unwrap();
+        let mut fixture = PreviewFixture {
+            root: root.clone(),
+            job: None,
+        };
+        let bytes = [137, 80, 78, 71, 13, 10, 26, 10, 0, 255];
+        std::fs::write(root.join("assets/photo.PNG"), bytes).unwrap();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..MintConfig::default()
+        };
+        let result = start(&root, "assets/photo.PNG", None, &config);
+        assert!(
+            result.is_ok(),
+            "a workspace image must be previewable: {result:?}"
+        );
+        let preview = result.unwrap();
+        fixture.job = Some(preview["jobId"].as_str().unwrap().into());
+        let client = reqwest::Client::new();
+        let url = preview["url"].as_str().unwrap();
+        let response = client
+            .get(url)
+            .header("sec-fetch-site", "cross-site")
+            .header("sec-fetch-mode", "no-cors")
+            .header("sec-fetch-dest", "image")
+            .timeout(Duration::from_secs(2))
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(response.status(), 200);
+        assert_eq!(response.headers()["content-type"], "image/png");
+        assert_eq!(response.bytes().await.unwrap().as_ref(), &bytes);
+        std::fs::write(root.join("assets/style.css"), "body { color: red }").unwrap();
+        let css_url = url.replace("photo.PNG", "style.css");
+        let asset = client.get(&css_url).send().await.unwrap();
+        assert_eq!(asset.status(), 200);
+        assert!(
+            asset.headers()["content-type"]
+                .to_str()
+                .unwrap()
+                .starts_with("text/css")
+        );
+        let blocked = client
+            .get(&css_url)
+            .header("sec-fetch-site", "cross-site")
+            .header("sec-fetch-mode", "no-cors")
+            .header("sec-fetch-dest", "image")
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(blocked.status(), 403);
+        let hidden = client
+            .get(url.replace("photo.PNG", ".secret.png"))
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(hidden.status(), 403);
+    }
+    #[tokio::test]
+    async fn markdown_browser_preview_is_readable_text_instead_of_a_download() {
+        let root =
+            std::env::temp_dir().join(format!("mint-markdown-preview-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let mut fixture = PreviewFixture {
+            root: root.clone(),
+            job: None,
+        };
+        std::fs::write(root.join("README.md"), "# Hello\n\nMint").unwrap();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..MintConfig::default()
+        };
+        let preview = start(&root, "README.md", None, &config)
+            .expect("Markdown needs a URL that Mint Browser can open");
+        fixture.job = Some(preview["jobId"].as_str().unwrap().into());
+        let response = reqwest::Client::new()
+            .get(preview["url"].as_str().unwrap())
+            .timeout(Duration::from_secs(2))
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(response.status(), 200);
+        assert_eq!(
+            response.headers()["content-type"],
+            "text/plain; charset=utf-8"
+        );
+        assert_eq!(response.text().await.unwrap(), "# Hello\n\nMint");
+    }
+}