@pheem49/mint 1.15.0 → 1.17.0

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

@@ -0,0 +1,185 @@
+//! Session-owned Mint Web background terminal.
+use crate::MintConfig;
+use std::{
+    collections::HashMap,
+    net::TcpListener,
+    path::{Path, PathBuf},
+    process::Command,
+    sync::{LazyLock, Mutex},
+};
+
+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<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())?;
+    if let Some(id) = servers.get(&owner)
+        && let Ok(job) = crate::bg_shell::job_json(id, false)
+    {
+        if job["status"] == "running" {
+            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());
+        }
+    }
+    for port in ports {
+        TcpListener::bind(("0.0.0.0", *port)).map_err(|_| {
+            format!("Port {port} is already in use. Stop that server before starting /mint-web.")
+        })?;
+    }
+    let context = crate::bg_shell::JobContext {
+        workspace: cwd.to_path_buf(),
+        owner: owner.clone(),
+        ..Default::default()
+    };
+    let job = crate::bg_shell::with_context(context, || {
+        crate::bg_shell::start_owned_background(cwd, config, "mint web", program)
+    })
+    .map_err(|e| e.to_string())?;
+    servers.insert(owner, job.id.clone());
+    Ok(WebLaunch {
+        job_id: job.id,
+        reused: false,
+    })
+}
+
+fn executable() -> Result<PathBuf, String> {
+    let name = if cfg!(windows) { "mint.exe" } else { "mint" };
+    if let Ok(current) = std::env::current_exe() {
+        if current.file_name().is_some_and(|n| n == name) {
+            return Ok(current);
+        }
+        if let Some(parent) = current.parent() {
+            let sibling = parent.join(name);
+            if sibling.is_file() {
+                return Ok(sibling);
+            }
+        }
+    }
+    if let Some(path) = std::env::var_os("PATH") {
+        for dir in std::env::split_paths(&path) {
+            let candidate = dir.join(name);
+            if candidate.is_file() {
+                return Ok(candidate);
+            }
+        }
+    }
+    Err("Mint CLI executable was not found. Install mint or place it beside the Desktop executable.".into())
+}
+
+pub fn command(
+    cwd: &Path,
+    rest: &str,
+    owner: Option<String>,
+    config: &MintConfig,
+) -> Result<String, String> {
+    if !rest.trim().is_empty() {
+        return Err("Usage: /mint-web".into());
+    }
+    let mut program = Command::new(executable()?);
+    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\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."
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[cfg(unix)]
+    #[test]
+    fn occupied_port_does_not_start_a_background_terminal() {
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let config = MintConfig {
+            safety_enabled: false,
+            ..Default::default()
+        };
+        let owner = Some(format!("occupied-port-{}", uuid::Uuid::new_v4()));
+        let mut program = Command::new("bash");
+        program.args(["-c", "sleep 30"]);
+        let error = launch(Path::new("."), owner.clone(), &config, program, &[port]).unwrap_err();
+        assert!(error.contains(&format!("Port {port} is already in use")));
+        assert!(crate::bg_shell::list_json(&owner, None).is_empty());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn launch_reuses_live_job_and_can_restart_after_stop() {
+        let root = Path::new(".");
+        let config = MintConfig {
+            safety_enabled: false,
+            ..Default::default()
+        };
+        let program = || {
+            let mut p = Command::new("bash");
+            p.args(["-c", "echo ready; cat"]);
+            p
+        };
+        let first = launch(
+            root,
+            Some("web-launch-test".into()),
+            &config,
+            program(),
+            &[],
+        )
+        .unwrap();
+        let second = launch(
+            root,
+            Some("web-launch-test".into()),
+            &config,
+            program(),
+            &[],
+        )
+        .unwrap();
+        assert!(!first.reused);
+        assert!(second.reused);
+        assert_eq!(first.job_id, second.job_id);
+        assert!(crate::bg_shell::accessible(
+            &first.job_id,
+            &Some("web-launch-test".into())
+        ));
+        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.job_id, false).unwrap()["status"] == "stopping" {
+            assert!(std::time::Instant::now() < deadline);
+            std::thread::sleep(std::time::Duration::from_millis(20));
+        }
+        let next = launch(
+            root,
+            Some("web-launch-test".into()),
+            &config,
+            program(),
+            &[],
+        )
+        .unwrap();
+        assert!(!next.reused);
+        assert_ne!(first.job_id, next.job_id);
+        crate::bg_shell::kill_job(&next.job_id).unwrap();
+    }
+}

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

@@ -0,0 +1,18 @@
+//! Development checkouts read live notes; standalone builds retain a snapshot.
+
+const SNAPSHOT: &str = include_str!(concat!(env!("OUT_DIR"), "/release-notes.md"));
+
+pub fn text() -> String {
+    if env!("MINT_LIVE_RELEASE_NOTES") == "1" {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+        // Use the checkout this binary was built from, never the user's current
+        // workspace (which may have an unrelated Release_Note.md).
+        if root.join(".git").exists()
+            && let Ok(notes) = std::fs::read_to_string(root.join("Release_Note.md"))
+            && !notes.trim().is_empty()
+        {
+            return notes.trim().to_owned();
+        }
+    }
+    SNAPSHOT.trim().to_owned()
+}

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

@@ -36,15 +36,19 @@ pub(crate) const SHELL_COMMAND_TIMEOUT: Duration = Duration::from_secs(180);
 pub(crate) struct CommandResult {
     pub(crate) status_code: Option<i32>,
     pub(crate) success: bool,
+    pub(crate) job_id: Option<String>,
+    pub(crate) cancelled: bool,
     pub(crate) stdout: Vec<u8>,
     pub(crate) stderr: Vec<u8>,
 }
 
-fn spawn_reader(mut pipe: impl Read + Send + 'static) -> std::thread::JoinHandle<Vec<u8>> {
+fn spawn_reader(
+    mut pipe: impl Read + Send + 'static,
+    buffer: std::sync::Arc<std::sync::Mutex<crate::bg_shell::CappedBuf>>,
+) -> std::thread::JoinHandle<Vec<u8>> {
     std::thread::spawn(move || {
-        let mut buf = Vec::new();
-        let _ = pipe.read_to_end(&mut buf);
-        buf
+        crate::bg_shell::read_stream(&mut pipe, &buffer);
+        buffer.lock().unwrap().data.as_bytes().to_vec()
     })
 }
 
@@ -60,10 +64,20 @@ fn spawn_reader(mut pipe: impl Read + Send + 'static) -> std::thread::JoinHandle
 /// the same timeout/output-buffering behavior for `docker exec` instead of
 /// duplicating it.
 pub(crate) fn run_with_timeout(
+    cmd: Command,
+    timeout: Duration,
+    command: &str,
+    cwd: &Path,
+) -> std::io::Result<CommandResult> {
+    run_with_timeout_cancellable(cmd, timeout, command, cwd, None)
+}
+
+fn run_with_timeout_cancellable(
     mut cmd: Command,
     timeout: Duration,
     command: &str,
     cwd: &Path,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
 ) -> std::io::Result<CommandResult> {
     cmd.stdin(Stdio::null())
         .stdout(Stdio::piped())
@@ -71,17 +85,59 @@ pub(crate) fn run_with_timeout(
     let mut child = cmd.spawn()?;
     let stdout_pipe = child.stdout.take().expect("stdout was piped");
     let stderr_pipe = child.stderr.take().expect("stderr was piped");
-    let stdout_handle = spawn_reader(stdout_pipe);
-    let stderr_handle = spawn_reader(stderr_pipe);
+    let stdout_buffer =
+        std::sync::Arc::new(std::sync::Mutex::new(crate::bg_shell::CappedBuf::new()));
+    let stderr_buffer =
+        std::sync::Arc::new(std::sync::Mutex::new(crate::bg_shell::CappedBuf::new()));
+    let stdout_handle = spawn_reader(stdout_pipe, stdout_buffer.clone());
+    let stderr_handle = spawn_reader(stderr_pipe, stderr_buffer.clone());
 
     let deadline = Instant::now() + timeout;
     loop {
+        if cancellation.is_some_and(|token| token.is_cancelled()) {
+            #[cfg(unix)]
+            unsafe {
+                libc::kill(-(child.id() as i32), libc::SIGTERM);
+            }
+            // Allow the browser helper to drop its separate Chrome runtime.
+            let grace = Instant::now() + Duration::from_millis(500);
+            while Instant::now() < grace {
+                if child.try_wait()?.is_some() {
+                    break;
+                }
+                std::thread::sleep(Duration::from_millis(10));
+            }
+            #[cfg(unix)]
+            unsafe {
+                libc::kill(-(child.id() as i32), libc::SIGKILL);
+            }
+            #[cfg(windows)]
+            {
+                let _ = Command::new("taskkill")
+                    .args(["/PID", &child.id().to_string(), "/T", "/F"])
+                    .output();
+            }
+            let _ = child.kill();
+            let _ = child.wait();
+            let stdout = stdout_handle.join().unwrap_or_default();
+            let stderr = stderr_handle.join().unwrap_or_default();
+            return Ok(CommandResult {
+                status_code: None,
+                success: false,
+                job_id: None,
+                cancelled: true,
+                stdout,
+                stderr,
+            });
+        }
         if let Some(status) = child.try_wait()? {
             let stdout = stdout_handle.join().unwrap_or_default();
             let stderr = stderr_handle.join().unwrap_or_default();
             return Ok(CommandResult {
                 status_code: status.code(),
                 success: status.success(),
+                job_id: None,
+                cancelled: false,
                 stdout,
                 stderr,
             });
@@ -93,6 +149,8 @@ pub(crate) fn run_with_timeout(
                 child,
                 stdout_handle,
                 stderr_handle,
+                stdout_buffer,
+                stderr_buffer,
             );
             let stderr = format!(
                 "[mint] Command exceeded {}s, so it was moved to run in the background instead \
@@ -109,6 +167,8 @@ pub(crate) fn run_with_timeout(
             return Ok(CommandResult {
                 status_code: None,
                 success: false,
+                job_id: Some(started.id),
+                cancelled: false,
                 stdout: Vec::new(),
                 stderr,
             });
@@ -125,6 +185,8 @@ pub struct ShellOutput {
     pub mode: String,
     pub status: Option<i32>,
     pub success: bool,
+    pub job_id: Option<String>,
+    pub cancelled: bool,
     pub sandboxed: bool,
     /// Set when a mutating/network command ran unconfined because sandboxing was
     /// unavailable (rather than intentionally disabled via `sandboxMode: "off"`),
@@ -174,6 +236,8 @@ pub enum ShellError {
     Execute(#[from] std::io::Error),
     #[error("no background job with id '{0}'")]
     JobNotFound(String),
+    #[error("background job '{0}' is still running")]
+    JobStillRunning(String),
 }
 
 pub fn run_shell_command(
@@ -183,6 +247,28 @@ pub fn run_shell_command(
     config: &MintConfig,
     chat_id: Option<&str>,
 ) -> Result<ShellOutput, ShellError> {
+    run_shell_command_cancellable(command, cwd, approved, config, chat_id, None)
+}
+
+pub fn run_shell_command_cancellable(
+    command: &str,
+    cwd: &Path,
+    approved: bool,
+    config: &MintConfig,
+    chat_id: Option<&str>,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
+) -> Result<ShellOutput, ShellError> {
+    if cancellation.is_some_and(|token| token.is_cancelled()) {
+        return Err(ShellError::Execute(std::io::Error::new(
+            std::io::ErrorKind::Interrupted,
+            "Command cancelled before dispatch",
+        )));
+    }
+    if crate::bg_shell::is_shutting_down() {
+        return Err(ShellError::Execute(std::io::Error::other(
+            "Mint backend is shutting down",
+        )));
+    }
     let classification = classify_shell_command(command);
     if classification.tier == SafetyTier::Blocked {
         return Err(ShellError::Blocked {
@@ -230,7 +316,7 @@ pub fn run_shell_command(
     let sandbox_mode = config.sandbox_mode.trim().to_ascii_lowercase();
     let mut sandbox_warning = None;
     if config.safety_enabled && sandbox_mode != "off" {
-        if let Some(output) = run_in_sandbox(&prepared_cmd, &cwd, config)? {
+        if let Some(output) = run_in_sandbox(&prepared_cmd, &cwd, config, cancellation)? {
             return Ok(shell_output(
                 command,
                 cwd,
@@ -273,8 +359,10 @@ pub fn run_shell_command(
     }
 
     let mut cmd = shell_command(&prepared_cmd);
+    crate::browser::workflow::configure_shell(&mut cmd, config);
     cmd.current_dir(&cwd);
-    let output = run_with_timeout(cmd, SHELL_COMMAND_TIMEOUT, command, &cwd)?;
+    let output =
+        run_with_timeout_cancellable(cmd, SHELL_COMMAND_TIMEOUT, command, &cwd, cancellation)?;
     Ok(shell_output(
         command,
         cwd,
@@ -306,6 +394,7 @@ fn run_in_sandbox(
     command: &str,
     cwd: &Path,
     config: &MintConfig,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
 ) -> Result<Option<CommandResult>, ShellError> {
     #[cfg(target_os = "linux")]
     {
@@ -316,21 +405,42 @@ fn run_in_sandbox(
             return Ok(None);
         }
         let mut process = Command::new(sandbox);
+        crate::browser::workflow::configure_shell(&mut process, config);
         // Own process group, same reasoning as `shell_command`'s: lets a
         // timed-out or interrupted run be killed as a whole tree via
         // `terminate_process_group` instead of just the `bwrap` wrapper.
-        process
-            .process_group(0)
-            .args(["--die-with-parent", "--ro-bind", "/", "/", "--dev", "/dev"])
-            .args(["--proc", "/proc", "--tmpfs", "/tmp"]);
-        for root in writable_roots(config, cwd) {
+        let roots = writable_roots(config, cwd);
+        let has_tmp = roots
+            .iter()
+            .any(|r| r == Path::new("/tmp") || r == &std::env::temp_dir());
+
+        process.process_group(0).args([
+            "--die-with-parent",
+            "--ro-bind",
+            "/",
+            "/",
+            "--dev",
+            "/dev",
+            "--proc",
+            "/proc",
+        ]);
+        if !has_tmp {
+            process.args(["--tmpfs", "/tmp"]);
+        }
+        for root in roots {
             process.arg("--bind").arg(&root).arg(&root);
         }
         process
             .arg("--chdir")
             .arg(cwd)
             .args(["bash", "-lc", command]);
-        let output = run_with_timeout(process, SHELL_COMMAND_TIMEOUT, command, cwd)?;
+        let output = run_with_timeout_cancellable(
+            process,
+            SHELL_COMMAND_TIMEOUT,
+            command,
+            cwd,
+            cancellation,
+        )?;
         Ok(Some(output))
     }
 
@@ -343,19 +453,26 @@ fn run_in_sandbox(
             return Ok(None);
         }
         let mut process = Command::new(sandbox);
+        crate::browser::workflow::configure_shell(&mut process, config);
         process
             .process_group(0)
             .arg("-p")
             .arg(mac_sandbox_profile(config, cwd))
             .args(["bash", "-lc", command])
             .current_dir(cwd);
-        let output = run_with_timeout(process, SHELL_COMMAND_TIMEOUT, command, cwd)?;
+        let output = run_with_timeout_cancellable(
+            process,
+            SHELL_COMMAND_TIMEOUT,
+            command,
+            cwd,
+            cancellation,
+        )?;
         return Ok(Some(output));
     }
 
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
     {
-        let _ = (command, cwd, config);
+        let _ = (command, cwd, config, cancellation);
         Ok(None)
     }
 }
@@ -423,6 +540,27 @@ pub(crate) fn writable_roots(config: &MintConfig, cwd: &Path) -> Vec<PathBuf> {
         .filter(|root| root.exists())
         .cloned()
         .collect::<Vec<_>>();
+    let temp = std::env::temp_dir();
+    if temp.exists() && !roots.iter().any(|r| r == &temp) {
+        roots.push(temp.clone());
+    }
+    if let Ok(canonical_temp) = temp.canonicalize() {
+        if !roots.iter().any(|r| r == &canonical_temp) {
+            roots.push(canonical_temp);
+        }
+    }
+    #[cfg(unix)]
+    {
+        let slash_tmp = PathBuf::from("/tmp");
+        if slash_tmp.exists() && !roots.iter().any(|r| r == &slash_tmp) {
+            roots.push(slash_tmp.clone());
+        }
+        if let Ok(canonical_slash_tmp) = slash_tmp.canonicalize() {
+            if !roots.iter().any(|r| r == &canonical_slash_tmp) {
+                roots.push(canonical_slash_tmp);
+            }
+        }
+    }
     if !roots.iter().any(|root| cwd.starts_with(root)) {
         roots.push(cwd.to_path_buf());
     }
@@ -510,6 +648,8 @@ fn shell_output(
         mode: mode.into(),
         status: output.status_code,
         success: output.success,
+        job_id: output.job_id,
+        cancelled: output.cancelled,
         sandboxed,
         sandbox_warning,
         stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
@@ -519,6 +659,34 @@ fn shell_output(
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    #[cfg(unix)]
+    fn cancellation_stops_the_foreground_process_group_and_preserves_partial_output() {
+        let token = tokio_util::sync::CancellationToken::new();
+        let cancel = token.clone();
+        let thread = std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_millis(400));
+            cancel.cancel();
+        });
+        let mut config = local_config();
+        config.allowed_write_paths.push(std::env::temp_dir());
+        let started = std::time::Instant::now();
+        let result = super::run_shell_command_cancellable(
+            "printf started; sleep 5; printf should-not-run",
+            &std::env::temp_dir(),
+            true,
+            &config,
+            None,
+            Some(&token),
+        )
+        .unwrap();
+        thread.join().unwrap();
+        assert!(result.cancelled);
+        assert_eq!(result.status, None);
+        assert!(result.stdout.contains("started"));
+        assert!(!result.stdout.contains("should-not-run"));
+        assert!(started.elapsed() < std::time::Duration::from_secs(2));
+    }
     use super::*;
 
     fn local_config() -> MintConfig {
@@ -682,4 +850,20 @@ mod tests {
         assert!(matches!(job.status, crate::bg_shell::JobStatus::Running));
         let _ = crate::bg_shell::kill_job(&job.id);
     }
+
+    #[test]
+    fn writable_roots_always_includes_temp_directory() {
+        let config = MintConfig {
+            allowed_write_paths: vec![],
+            ..MintConfig::default()
+        };
+        let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        let roots = writable_roots(&config, &cwd);
+        let temp = std::env::temp_dir();
+        assert!(
+            roots
+                .iter()
+                .any(|r| r == &temp || (cfg!(unix) && r == Path::new("/tmp")))
+        );
+    }
 }