@pheem49/mint 1.16.0 → 1.17.0

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

@@ -40,21 +40,83 @@ pub struct AuthUser {
 
 /// Path to the shared identity database: `~/.config/mint/mint-user.sqlite`.
 pub fn user_db_path() -> Result<PathBuf, AuthError> {
-    dirs::config_dir()
-        .map(|dir| dir.join("mint").join("mint-user.sqlite"))
+    crate::system::config::mint_config_dir()
+        .map(|dir| dir.join("mint-user.sqlite"))
         .ok_or(AuthError::ConfigDirectoryUnavailable)
 }
 
-/// Path to the shared profile pictures directory:
-/// `~/.config/mint/Pictures/profile`.
+/// Computes the path to the profile pictures directory: `~/.config/mint/profile`,
+/// without creating it on disk. Use for read-only path resolution queries.
+pub fn profile_pictures_dir_path() -> Result<PathBuf, AuthError> {
+    crate::system::config::mint_config_dir()
+        .map(|dir| dir.join("profile"))
+        .ok_or(AuthError::ConfigDirectoryUnavailable)
+}
+
+/// Path to the shared profile pictures directory: `~/.config/mint/profile`,
+/// ensuring the directory exists on disk. Use when saving new avatar files.
 pub fn profile_pictures_dir() -> Result<PathBuf, AuthError> {
-    let dir = dirs::config_dir()
-        .map(|dir| dir.join("mint").join("Pictures").join("profile"))
-        .ok_or(AuthError::ConfigDirectoryUnavailable)?;
+    let dir = profile_pictures_dir_path()?;
     std::fs::create_dir_all(&dir).ok();
     Ok(dir)
 }
 
+/// Legacy path to the profile pictures directory (`~/.config/mint/Pictures/profile`),
+/// used as a fallback to ensure existing user avatars are seamlessly preserved.
+fn legacy_profile_pictures_dir() -> Option<PathBuf> {
+    crate::system::config::mint_config_dir().map(|dir| dir.join("Pictures").join("profile"))
+}
+
+/// Resolves an avatar file path against explicit modern and legacy directories.
+/// When found in legacy storage, automatically copies the file to the modern directory
+/// to achieve self-healing zero-loss migration.
+pub(crate) fn resolve_avatar_file_path_in(
+    modern_dir: &std::path::Path,
+    legacy_dir: Option<&std::path::Path>,
+    filename: &str,
+) -> Option<PathBuf> {
+    let trimmed = filename.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    let path = std::path::Path::new(trimmed);
+    let mut components = path.components();
+    match (components.next(), components.next()) {
+        (Some(std::path::Component::Normal(comp)), None) => {
+            if trimmed.contains('/') || trimmed.contains('\\') {
+                return None;
+            }
+            let clean_name = comp.to_str()?;
+            let modern_path = modern_dir.join(clean_name);
+            if modern_path.is_file() {
+                return Some(modern_path);
+            }
+            if let Some(legacy_dir) = legacy_dir {
+                let legacy_path = legacy_dir.join(clean_name);
+                if legacy_path.is_file() {
+                    // Auto-migrate: copy to modern directory for self-healing persistence
+                    if std::fs::create_dir_all(modern_dir).is_ok()
+                        && std::fs::copy(&legacy_path, &modern_path).is_ok()
+                    {
+                        return Some(modern_path);
+                    }
+                    return Some(legacy_path);
+                }
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+/// Resolves an avatar file path, checking the modern `~/.config/mint/profile` directory first,
+/// and falling back to the legacy `~/.config/mint/Pictures/profile` directory if it exists there.
+pub fn resolve_avatar_file_path(filename: &str) -> Option<PathBuf> {
+    let modern = profile_pictures_dir_path().ok()?;
+    let legacy = legacy_profile_pictures_dir();
+    resolve_avatar_file_path_in(&modern, legacy.as_deref(), filename)
+}
+
 /// Saves an avatar image into the shared profile pictures directory and
 /// returns the `/api/avatar?key=...` URL to store on the user record.
 /// `extension` should be a bare extension like "jpg" or "png" (no dot).
@@ -542,4 +604,91 @@ mod tests {
         .unwrap();
         assert_eq!(session_user_id_with_conn(&conn, &expired_token), None);
     }
+
+    #[test]
+    fn resolve_avatar_file_path_handles_empty() {
+        assert_eq!(resolve_avatar_file_path(""), None);
+        assert_eq!(resolve_avatar_file_path("   "), None);
+    }
+
+    #[test]
+    fn resolve_avatar_file_path_in_finds_legacy_file_if_not_in_modern() {
+        let root = std::env::temp_dir().join(format!("mint-avatar-test-{}", uuid::Uuid::new_v4()));
+        let modern_dir = root.join("profile");
+        let legacy_dir = root.join("Pictures").join("profile");
+        std::fs::create_dir_all(&modern_dir).unwrap();
+        std::fs::create_dir_all(&legacy_dir).unwrap();
+
+        let filename = "sample-avatar.png";
+        let legacy_file = legacy_dir.join(filename);
+        std::fs::write(&legacy_file, b"legacy-avatar-bytes").unwrap();
+
+        // 1. When modern doesn't have it, auto-migrates to modern file
+        let resolved = resolve_avatar_file_path_in(&modern_dir, Some(&legacy_dir), filename);
+        let modern_file = modern_dir.join(filename);
+        assert_eq!(resolved, Some(modern_file.clone()));
+        assert_eq!(std::fs::read(&modern_file).unwrap(), b"legacy-avatar-bytes");
+
+        // 2. When modern also has it, modern takes priority
+        std::fs::write(&modern_file, b"modern-avatar-bytes").unwrap();
+        let resolved_modern = resolve_avatar_file_path_in(&modern_dir, Some(&legacy_dir), filename);
+        assert_eq!(resolved_modern, Some(modern_file));
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_avatar_file_path_in_returns_none_if_file_not_found() {
+        let root =
+            std::env::temp_dir().join(format!("mint-avatar-missing-{}", uuid::Uuid::new_v4()));
+        let modern_dir = root.join("profile");
+        let legacy_dir = root.join("Pictures").join("profile");
+        std::fs::create_dir_all(&modern_dir).unwrap();
+        std::fs::create_dir_all(&legacy_dir).unwrap();
+
+        let resolved =
+            resolve_avatar_file_path_in(&modern_dir, Some(&legacy_dir), "nonexistent.png");
+        assert_eq!(resolved, None);
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_avatar_file_path_in_rejects_path_traversal() {
+        let root =
+            std::env::temp_dir().join(format!("mint-avatar-traversal-{}", uuid::Uuid::new_v4()));
+        let modern_dir = root.join("profile");
+        std::fs::create_dir_all(&modern_dir).unwrap();
+
+        assert_eq!(
+            resolve_avatar_file_path_in(&modern_dir, None, "../foo.png"),
+            None
+        );
+        assert_eq!(
+            resolve_avatar_file_path_in(&modern_dir, None, "sub/dir.png"),
+            None
+        );
+        assert_eq!(
+            resolve_avatar_file_path_in(&modern_dir, None, "..\\win.png"),
+            None
+        );
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn resolve_avatar_file_path_does_not_create_directory_on_read() {
+        let root =
+            std::env::temp_dir().join(format!("mint-avatar-nonexist-{}", uuid::Uuid::new_v4()));
+        let non_existent_modern = root.join("profile");
+        // Ensure directory does not exist prior to read query
+        assert!(!non_existent_modern.exists());
+
+        let resolved = resolve_avatar_file_path_in(&non_existent_modern, None, "test.png");
+        assert_eq!(resolved, None);
+        // Ensure read query did NOT create directory on disk
+        assert!(!non_existent_modern.exists());
+
+        let _ = std::fs::remove_dir_all(root);
+    }
 }

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

@@ -994,14 +994,17 @@ fn owns_port(_pid: u32, _port: u16) -> bool {
     false
 }
 
+static HTTP_URL_PATTERN: LazyLock<regex::Regex> = LazyLock::new(|| {
+    regex::Regex::new(r"http://(?:localhost|127\.0\.0\.1|0\.0\.0\.0):([0-9]{1,5})").unwrap()
+});
+static PYTHON_SERVER_PATTERN: LazyLock<regex::Regex> =
+    LazyLock::new(|| regex::Regex::new(r"-m\s+http\.server(?:\s+(\d+))?").unwrap());
+static SERVING_PATTERN: LazyLock<regex::Regex> =
+    LazyLock::new(|| regex::Regex::new(r"Serving HTTP on .* port (\d+)").unwrap());
+
 fn spawn_readiness(job: Arc<JobRecord>) {
     std::thread::spawn(move || {
-        let pattern =
-            regex::Regex::new(r"http://(?:localhost|127\.0\.0\.1|0\.0\.0\.0):([0-9]{1,5})")
-                .unwrap();
-        let python = regex::Regex::new(r"-m\s+http\.server(?:\s+(\d+))?").unwrap();
-        let serving = regex::Regex::new(r"Serving HTTP on .* port (\d+)").unwrap();
-        let command_port = python.captures(&job.command).and_then(|c| {
+        let command_port = PYTHON_SERVER_PATTERN.captures(&job.command).and_then(|c| {
             c.get(1)
                 .map_or(Some(8000), |p| p.as_str().parse::<u16>().ok())
         });
@@ -1015,11 +1018,11 @@ fn spawn_readiness(job: Arc<JobRecord>) {
                 job.stdout.lock().unwrap().data,
                 job.stderr.lock().unwrap().data
             );
-            let port = pattern
+            let port = HTTP_URL_PATTERN
                 .captures(&text)
                 .and_then(|c| c[1].parse::<u16>().ok())
                 .or_else(|| {
-                    serving
+                    SERVING_PATTERN
                         .captures(&text)
                         .and_then(|c| c[1].parse::<u16>().ok())
                 })
@@ -1532,6 +1535,51 @@ mod tests {
         assert!(stopped["serverUrl"].is_null());
     }
 
+    #[test]
+    fn shells_stop_without_id_stops_all_owned_running_jobs() {
+        let dir = TestDir::new();
+        let other_dir = TestDir::new();
+        let config = local_config();
+        let owner = Some(uuid::Uuid::new_v4().to_string());
+        let start = |workspace: &Path, job_owner: Option<String>| {
+            with_context(
+                JobContext {
+                    workspace: workspace.to_path_buf(),
+                    owner: job_owner,
+                    ..JobContext::default()
+                },
+                || start_background(workspace, &config, "sleep 30").unwrap(),
+            )
+        };
+        let empty = shells_command("stop", dir.path(), &owner, &config).unwrap();
+        assert!(empty.contains("No running"), "{empty}");
+        let first = start(dir.path(), owner.clone());
+        let _first_cleanup = StopOnDrop(first.id.clone());
+        let second = start(other_dir.path(), owner.clone());
+        let _second_cleanup = StopOnDrop(second.id.clone());
+        let third = start(dir.path(), owner.clone());
+        let _third_cleanup = StopOnDrop(third.id.clone());
+        let foreign = start(dir.path(), Some(uuid::Uuid::new_v4().to_string()));
+        let _foreign_cleanup = StopOnDrop(foreign.id.clone());
+        shells_command(&format!("stop {}", third.id), dir.path(), &owner, &config).unwrap();
+        wait_json(&third.id, |v| v["status"] == "stopped");
+        assert_eq!(job_json(&first.id, false).unwrap()["status"], "running");
+        assert_eq!(job_json(&second.id, false).unwrap()["status"], "running");
+        let stopped = shells_command("stop", dir.path(), &owner, &config).unwrap();
+        assert!(
+            stopped.contains(&first.id) && stopped.contains(&second.id),
+            "{stopped}"
+        );
+        wait_json(&first.id, |v| v["status"] == "stopped");
+        wait_json(&second.id, |v| v["status"] == "stopped");
+        assert_eq!(job_json(&foreign.id, false).unwrap()["status"], "running");
+        assert!(
+            shells_command("stop", dir.path(), &owner, &config)
+                .unwrap()
+                .contains("No running")
+        );
+    }
+
     #[test]
     fn poll_unknown_job_errors() {
         assert!(matches!(
@@ -1574,12 +1622,32 @@ pub fn shells_command(
         }
         return Ok(lines.join("\n\n"));
     }
+    if rest == "stop" {
+        let jobs: Vec<_> = list_json(owner, None)
+            .into_iter()
+            .filter(|job| job["status"] == "running")
+            .collect();
+        if jobs.is_empty() {
+            return Ok("No running background terminals.".into());
+        }
+        let mut results = Vec::new();
+        for job in jobs {
+            let id = job["id"].as_str().unwrap_or("");
+            // Reuse the explicit-ID path so ownership and capability checks
+            // also apply to each job in the batch. Keep going on failures.
+            results.push(
+                shells_command(&format!("stop {id}"), workspace, owner, config)
+                    .unwrap_or_else(|error| format!("{id}: {error}")),
+            );
+        }
+        return Ok(results.join("\n"));
+    }
     let (action, id) = rest
         .split_once(char::is_whitespace)
         .map(|(a, i)| (a, i.trim()))
         .unwrap_or((rest, ""));
     if !matches!(action, "show" | "stop" | "kill") || id.is_empty() {
-        return Ok("Usage: /shells [all|show <id>|stop <id>|kill <id>]".into());
+        return Ok("Usage: /shells [all|show <id>|stop [<id>]|kill <id>]".into());
     }
     if !accessible(id, owner) {
         return Err(ShellError::JobNotFound(id.into()));

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

@@ -137,6 +137,13 @@ pub struct MintConfig {
     pub disabled_tools: Vec<String>,
     pub agents: Vec<AgentConfig>,
     pub enable_agent_collaboration: bool,
+    /// 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.
@@ -191,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")]
@@ -285,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
@@ -364,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"),
@@ -374,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(),
@@ -434,6 +482,8 @@ impl Default for MintConfig {
             disabled_tools: Vec::new(),
             agents: default_agents(),
             enable_agent_collaboration: false,
+            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,
@@ -1012,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));
@@ -1022,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)
 }
 
@@ -1172,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,
@@ -1808,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/mint_web.rs

@@ -11,13 +11,19 @@ use std::{
 static SERVERS: LazyLock<Mutex<HashMap<Option<String>, String>>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 
+#[derive(Debug)]
+struct WebLaunch {
+    job_id: String,
+    reused: bool,
+}
+
 fn launch(
     cwd: &Path,
     owner: Option<String>,
     config: &MintConfig,
     program: Command,
     ports: &[u16],
-) -> Result<String, String> {
+) -> Result<WebLaunch, String> {
     crate::assert_path_capability(cwd, crate::Capability::Write, config)
         .map_err(|e| e.to_string())?;
     let mut servers = SERVERS.lock().map_err(|e| e.to_string())?;
@@ -25,7 +31,10 @@ fn launch(
         && let Ok(job) = crate::bg_shell::job_json(id, false)
     {
         if job["status"] == "running" {
-            return Ok(id.clone());
+            return Ok(WebLaunch {
+                job_id: id.clone(),
+                reused: true,
+            });
         }
         if job["status"] == "stopping" {
             return Err("Mint Web is stopping; try again after it stops.".into());
@@ -46,7 +55,10 @@ fn launch(
     })
     .map_err(|e| e.to_string())?;
     servers.insert(owner, job.id.clone());
-    Ok(job.id)
+    Ok(WebLaunch {
+        job_id: job.id,
+        reused: false,
+    })
 }
 
 fn executable() -> Result<PathBuf, String> {
@@ -83,10 +95,16 @@ pub fn command(
         return Err("Usage: /mint-web".into());
     }
     let mut program = Command::new(executable()?);
-    program.arg("web");
-    let id = launch(cwd, owner, config, program, &[9000, 3000])?;
+    program.args(["web", "--open"]);
+    let launch = launch(cwd, owner, config, program, &[9000, 3000])?;
+    let id = launch.job_id;
+    let browser_notice = if launch.reused {
+        "Mint Web is already running. Open the URL above to return to it."
+    } else {
+        "Your browser will open automatically when ready."
+    };
     Ok(format!(
-        "Mint Web background terminal: `{id}`\n\nOpen http://localhost:9000 once startup completes. It stops when this Mint backend closes.\n\nUse `/shells show {id}` for startup logs or `/shells stop {id}` to stop it."
+        "Mint Web background terminal: `{id}`\n\nMint Web: **http://localhost:9000**\n{browser_notice}\n\nIt stops when this Mint backend closes. Use `/shells show {id}` for startup logs or `/shells stop {id}` to stop it."
     ))
 }
 
@@ -139,14 +157,16 @@ mod tests {
             &[],
         )
         .unwrap();
-        assert_eq!(first, second);
+        assert!(!first.reused);
+        assert!(second.reused);
+        assert_eq!(first.job_id, second.job_id);
         assert!(crate::bg_shell::accessible(
-            &first,
+            &first.job_id,
             &Some("web-launch-test".into())
         ));
-        crate::bg_shell::kill_job(&first).unwrap();
+        crate::bg_shell::kill_job(&first.job_id).unwrap();
         let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
-        while crate::bg_shell::job_json(&first, false).unwrap()["status"] == "stopping" {
+        while crate::bg_shell::job_json(&first.job_id, false).unwrap()["status"] == "stopping" {
             assert!(std::time::Instant::now() < deadline);
             std::thread::sleep(std::time::Duration::from_millis(20));
         }
@@ -158,7 +178,8 @@ mod tests {
             &[],
         )
         .unwrap();
-        assert_ne!(first, next);
-        crate::bg_shell::kill_job(&next).unwrap();
+        assert!(!next.reused);
+        assert_ne!(first.job_id, next.job_id);
+        crate::bg_shell::kill_job(&next.job_id).unwrap();
     }
 }