@pheem49/mint 1.14.0 → 1.15.0

package/crates/mint-cli/src/commands/agent.rs

@@ -367,30 +367,21 @@ pub async fn handle_auto() -> Result<()> {
 
     // Enable the browser tools if they are disabled
     let mut config_mut = config.clone();
-    let mut changed = false;
-    for tool in &[
-        "browser_open",
-        "browser_click",
-        "browser_type",
-        "browser_read",
-        "browser_mouse_move",
-        "browser_mouse_click",
-        "browser_key_press",
-        "browser_screenshot",
-    ] {
-        if config_mut.disabled_tools.contains(&tool.to_string()) {
-            config_mut.disabled_tools.retain(|x| x != *tool);
-            changed = true;
-        }
-    }
-    if changed {
+    if mint_core::enable_browser_tools(&mut config_mut) {
         mint_core::save_config(&config_mut)?;
         println!(
-            "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read, browser_mouse_move, browser_mouse_click, browser_key_press, browser_screenshot"
+            "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read, browser_mouse_move, browser_mouse_click, browser_key_press, browser_screenshot, browser_tabs, browser_observe, browser_fill, browser_select, browser_scroll, browser_wait"
         );
     }
 
-    println!("🌐 Isolated browser running with remote debugging on http://127.0.0.1:9222");
+    println!(
+        "🌐 Isolated browser running with remote debugging on {}",
+        config
+            .extra
+            .get("browserDebugUrl")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or("http://127.0.0.1:9222/json/list")
+    );
     println!("💬 Keep this terminal open while you want Mint to automate browser tasks.");
     println!("Press Ctrl+C to terminate the automation browser session.");
     println!("----------------------------------------------------------------------");
@@ -458,7 +449,10 @@ pub async fn handle_auto() -> Result<()> {
     Ok(())
 }
 
-pub async fn handle_web(dev: bool) -> Result<()> {
+pub async fn handle_web(dev: bool, tailscale: bool) -> Result<()> {
+    if tailscale {
+        return super::tailnet_web::run().await;
+    }
     launch_mint_target("web".into(), dev).await
 }
 
@@ -607,10 +601,11 @@ pub async fn handle_chat(
                 messages: None,
                 tools: None,
                 temperature: config.temperature,
+                ..Default::default()
             },
         )
         .await?;
-        image::save_sent_image_after_send(image_data_uri.as_deref(), &message);
+        image::save_sent_image_after_send(image_data_uri.as_deref(), &message, None);
         println!("{}", response.text);
     }
     Ok(())

package/crates/mint-cli/src/commands/eval.rs

@@ -1,3 +1,5 @@
+const ANSI_BLUE_BOLD: &str = crate::terminal_theme::ANSI_BLUE_BOLD;
+
 use anyhow::{Context, Result};
 use mint_core::MintConfig;
 use mint_core::eval::{aggregate_benchmark_report, evaluate_task_result, load_suite_from_file};
@@ -5,13 +7,15 @@ use std::path::PathBuf;
 use std::time::Instant;
 
 pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig) -> Result<()> {
-    println!("\x1b[1;36m┌─ Mint Benchmark Evaluation Harness ──────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}┌─ Mint Benchmark Evaluation Harness ──────────────────────\x1b[0m");
     if !suite_path.exists() {
         println!(
             "│ \x1b[31mBenchmark suite file not found: {}\x1b[0m",
             suite_path.display()
         );
-        println!("\x1b[1;36m└─────────────────────────────────────────────────────────\x1b[0m");
+        println!(
+            "{ANSI_BLUE_BOLD}└─────────────────────────────────────────────────────────\x1b[0m"
+        );
         anyhow::bail!("Suite file not found: {}", suite_path.display());
     }
 
@@ -22,7 +26,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
         suite.name, suite.version
     );
     println!("│ Total Tasks: {}", suite.tasks.len());
-    println!("\x1b[1;36m├─────────────────────────────────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}├─────────────────────────────────────────────────────────\x1b[0m");
 
     let cwd = std::env::current_dir().context("failed to get current dir")?;
     let mut results = Vec::new();
@@ -131,7 +135,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
     }
 
     let report = aggregate_benchmark_report(&suite.name, results);
-    println!("\x1b[1;36m├─ Final Evaluation Report ───────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}├─ Final Evaluation Report ───────────────────────────────\x1b[0m");
     println!("│ Suite:            {}", report.suite_name);
     println!(
         "│ Tasks Completed:  {}/{}",
@@ -146,7 +150,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
     println!("│ Avg Tokens:       {}", report.avg_tokens);
     println!("│ Avg Tool Calls:   {:.1}", report.avg_tool_calls);
     println!("│ Avg Retries:      {:.1}", report.avg_retries);
-    println!("\x1b[1;36m└─────────────────────────────────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}└─────────────────────────────────────────────────────────\x1b[0m");
 
     let report_path = cwd.join("mint_eval_report.json");
     if let Ok(json) = serde_json::to_string_pretty(&report) {

package/crates/mint-cli/src/commands/git.rs

@@ -0,0 +1,204 @@
+use std::path::Path;
+
+use anyhow::{Result, bail};
+use clap::Subcommand;
+use crossterm::tty::IsTty;
+use mint_core::{
+    BranchChange, BranchChangeOutcome, BranchInfo, change_branch, read_branch_info, read_graph,
+};
+
+use crate::{DIM, MINT, RESET, confirm};
+
+#[derive(Debug, Subcommand)]
+pub enum GitCommand {
+    /// Show the active branch, working tree state, and known refs.
+    Status {
+        /// Print the branch state as JSON.
+        #[arg(long)]
+        json: bool,
+    },
+    /// Print local and locally known remote branches.
+    List,
+    /// Switch to an existing local branch.
+    Switch {
+        branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Create a branch from the current HEAD and switch to it.
+    Create {
+        branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Create and switch to a local tracking branch from a known remote ref.
+    Track {
+        remote_branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Print decorated repository history as a graph.
+    Graph {
+        /// Number of commits to show, from 1 to 500.
+        #[arg(long, default_value_t = 120)]
+        limit: usize,
+    },
+}
+
+pub fn handle_git(command: GitCommand) -> Result<()> {
+    let root = std::env::current_dir()?;
+    match command {
+        GitCommand::Status { json } => print_status(&root, json),
+        GitCommand::List => print_list(&root),
+        GitCommand::Switch {
+            branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Switch {
+                    branch: branch.clone(),
+                },
+                allow_dirty,
+                &format!("Switch to {branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Create {
+            branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Create {
+                    branch: branch.clone(),
+                },
+                allow_dirty,
+                &format!("Create and switch to {branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Track {
+            remote_branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Track {
+                    remote_branch: remote_branch.clone(),
+                },
+                allow_dirty,
+                &format!("Create a local tracking branch from {remote_branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Graph { limit } => {
+            let graph = read_graph(&root, limit).map_err(anyhow::Error::msg)?;
+            if graph.is_empty() {
+                println!("{DIM}No commits yet.{RESET}");
+            } else {
+                println!("{}", graph.join("\n"));
+            }
+            Ok(())
+        }
+    }
+}
+
+fn print_status(root: &Path, json: bool) -> Result<()> {
+    let info = read_branch_info(root).map_err(anyhow::Error::msg)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&info)?);
+        return Ok(());
+    }
+    print_info(&info);
+    Ok(())
+}
+
+fn print_list(root: &Path) -> Result<()> {
+    let info = read_branch_info(root).map_err(anyhow::Error::msg)?;
+    ensure_repository(&info)?;
+    println!("Local branches");
+    for branch in &info.branches {
+        let marker = if info.current_branch.as_deref() == Some(branch) {
+            format!("{MINT}*{RESET}")
+        } else {
+            " ".to_string()
+        };
+        println!("  {marker} {branch}");
+    }
+    if !info.remote_branches.is_empty() {
+        println!("\nRemote branches {DIM}(locally known){RESET}");
+        for branch in &info.remote_branches {
+            println!("    {branch}");
+        }
+    }
+    Ok(())
+}
+
+fn print_changed(info: &BranchInfo) -> Result<()> {
+    ensure_repository(info)?;
+    let branch = info.current_branch.as_deref().unwrap_or("detached HEAD");
+    println!("{MINT}Switched to {branch}{RESET}");
+    Ok(())
+}
+
+fn print_info(info: &BranchInfo) {
+    if !info.is_repository {
+        println!("Not a Git repository.");
+        return;
+    }
+    let branch = info
+        .current_branch
+        .as_deref()
+        .or(info.detached_head.as_deref())
+        .unwrap_or("No branch");
+    let state = if info.is_dirty { "dirty" } else { "clean" };
+    println!("Branch: {branch}");
+    println!("Working tree: {state}");
+    println!("Local branches: {}", info.branches.len());
+    println!(
+        "Remote branches: {} {DIM}(locally known){RESET}",
+        info.remote_branches.len()
+    );
+}
+
+fn apply_branch_change(
+    root: &Path,
+    change: BranchChange,
+    confirmed_dirty_workspace: bool,
+    action: &str,
+) -> Result<BranchInfo> {
+    match change_branch(root, &change, confirmed_dirty_workspace).map_err(anyhow::Error::msg)? {
+        BranchChangeOutcome::Changed { info } => Ok(info),
+        BranchChangeOutcome::ConfirmationRequired { .. } => {
+            confirm_and_change(root, change, action)
+        }
+    }
+}
+
+fn confirm_and_change(root: &Path, change: BranchChange, action: &str) -> Result<BranchInfo> {
+    if !std::io::stdin().is_tty() || !std::io::stdout().is_tty() {
+        bail!("Workspace has uncommitted changes. Re-run with --allow-dirty to confirm.");
+    }
+    if confirm(&format!("Workspace has uncommitted changes. {action}"))? {
+        match change_branch(root, &change, true).map_err(anyhow::Error::msg)? {
+            BranchChangeOutcome::Changed { info } => Ok(info),
+            BranchChangeOutcome::ConfirmationRequired { .. } => {
+                bail!("Workspace still requires confirmation.")
+            }
+        }
+    } else {
+        bail!("Branch change cancelled.")
+    }
+}
+
+fn ensure_repository(info: &BranchInfo) -> Result<()> {
+    if info.is_repository {
+        Ok(())
+    } else {
+        bail!("The selected workspace is not a Git repository.")
+    }
+}

package/crates/mint-cli/src/commands/integrations.rs

@@ -114,6 +114,16 @@ pub enum LinkCommand {
     Remove {
         name: String,
     },
+    Refresh {
+        name: String,
+    },
+    Notes {
+        name: String,
+    },
+    Save {
+        name: String,
+        text: String,
+    },
 }
 
 #[derive(Debug, Subcommand)]
@@ -338,6 +348,24 @@ pub fn handle_link(command: LinkCommand) -> Result<()> {
                 }
             )
         }
+        LinkCommand::Refresh { name } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::refresh_linked_folder(&name)?)?
+            );
+        }
+        LinkCommand::Notes { name } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::list_linked_folder_notes(&name)?)?
+            );
+        }
+        LinkCommand::Save { name, text } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::save_linked_folder_note(&name, &text)?)?
+            );
+        }
     }
     Ok(())
 }

package/crates/mint-cli/src/commands/knowledge.rs

@@ -258,6 +258,7 @@ async fn run_github_overview(repo: &str, config: &MintConfig) -> Result<()> {
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         },
     )
     .await {

package/crates/mint-cli/src/commands/mod.rs

@@ -7,14 +7,17 @@ use mint_core::MintConfig;
 pub mod agent;
 pub mod config;
 pub mod eval;
+pub mod git;
 pub mod integrations;
 pub mod knowledge;
 pub mod system;
+pub mod tailnet_web;
 pub mod tasks;
 
 pub use agent::*;
 pub use config::*;
 pub use eval::*;
+pub use git::*;
 pub use integrations::*;
 pub use knowledge::*;
 pub use system::*;
@@ -99,13 +102,26 @@ pub enum Command {
         #[arg(long, default_value = "cli")]
         chat_id: String,
     },
+    /// Inspect and manage Git branches in the current workspace.
+    Git {
+        #[command(subcommand)]
+        command: GitCommand,
+    },
+    /// Resume a previous conversation session, or open the interactive session picker.
+    Resume {
+        /// Optional session ID to resume directly (omitting opens the interactive picker).
+        id: Option<String>,
+    },
     /// Start the browser automation environment and enable browser actions.
     Auto,
     /// Launch the web UI and local API server.
     Web {
         /// Force development mode with Hot Module Replacement (HMR)
-        #[arg(long, default_value_t = false)]
+        #[arg(long, default_value_t = false, conflicts_with = "tailscale")]
         dev: bool,
+        /// Share the production web UI privately over Tailscale HTTPS.
+        #[arg(long, default_value_t = false)]
+        tailscale: bool,
     },
     /// Start only the local API server.
     Api {
@@ -273,8 +289,27 @@ pub async fn dispatch(cmd: Command, config: &mut MintConfig, cli: &crate::Cli) -
         Command::Agent { task } => agent::handle_agent(task).await,
         Command::Eval { suite, limit } => eval::handle_eval(suite, limit, config).await,
         Command::Rewind { step, chat_id } => agent::handle_rewind(step, chat_id),
+        Command::Git { command } => git::handle_git(command),
+        Command::Resume { id } => {
+            mint_core::channels::start_channels();
+            mint_core::start_cron_scheduler();
+            let current_dir = std::env::current_dir()?;
+            let resume_id = match id {
+                Some(sid) => Some(sid),
+                None => crate::interactive::prompt_resume_session_picker(&current_dir, "")?,
+            };
+            crate::interactive::run_interactive_chat_with_session(
+                cli.model.clone(),
+                cli.fast,
+                cli.plan,
+                resume_id,
+                !cli.classic,
+            )
+            .await?;
+            Ok(())
+        }
         Command::Auto => agent::handle_auto().await,
-        Command::Web { dev } => agent::handle_web(dev).await,
+        Command::Web { dev, tailscale } => agent::handle_web(dev, tailscale).await,
         Command::Api { port } => agent::handle_api(port).await,
         Command::Gateway { command } => agent::handle_gateway(command).await,
         Command::Chat {

package/crates/mint-cli/src/commands/tailnet_web.rs

@@ -0,0 +1,235 @@
+//! Opt-in private HTTPS entry point for the existing Mint web UI.
+
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::PathBuf,
+    process::{Child, Command, Stdio},
+    time::Duration,
+};
+
+use anyhow::{Context, Result, bail};
+use serde_json::Value;
+
+use crate::{BLUE, DIM, MINT, RESET, print_welcome_banner};
+
+struct ChildGuard(Child);
+
+impl Drop for ChildGuard {
+    fn drop(&mut self) {
+        let _ = self.0.kill();
+        let _ = self.0.wait();
+    }
+}
+
+fn project_root() -> Result<PathBuf> {
+    let cwd = std::env::current_dir()?;
+    let exe = std::env::current_exe()?;
+    exe.ancestors()
+        .chain(cwd.ancestors())
+        .find(|path| path.join("package.json").exists())
+        .map(PathBuf::from)
+        .context("Could not find the Mint project root (package.json)")
+}
+
+fn tailscale(args: &[&str]) -> Result<String> {
+    let output = Command::new("tailscale").args(args).output().context(
+        "Tailscale is not installed. Install it and sign in on this computer and your phone first",
+    )?;
+    if !output.status.success() {
+        bail!(
+            "tailscale {} failed: {}",
+            args.join(" "),
+            String::from_utf8_lossy(&output.stderr).trim()
+        );
+    }
+    Ok(String::from_utf8(output.stdout).context("Tailscale returned invalid UTF-8")?)
+}
+
+fn tailnet_url(status: &Value) -> Result<String> {
+    if status["BackendState"] != "Running" {
+        bail!("Tailscale is not connected. Sign in and connect this computer first");
+    }
+    let name = status["Self"]["DNSName"]
+        .as_str()
+        .map(|name| name.trim_end_matches('.'))
+        .filter(|name| !name.is_empty())
+        .context("Tailscale did not report a MagicDNS name; enable MagicDNS for this tailnet")?;
+    Ok(format!("https://{name}"))
+}
+
+fn https_443_in_use(status: &Value) -> bool {
+    let Some(config) = status.as_object() else {
+        return true; // unknown status format: never risk replacing a route
+    };
+    if config
+        .get("TCP")
+        .unwrap_or(&Value::Null)
+        .as_object()
+        .is_some_and(|ports| ports.contains_key("443"))
+        || config
+            .get("Web")
+            .unwrap_or(&Value::Null)
+            .as_object()
+            .is_some_and(|hosts| hosts.keys().any(|host| host.ends_with(":443")))
+    {
+        return true;
+    }
+    config
+        .get("Foreground")
+        .unwrap_or(&Value::Null)
+        .as_object()
+        .is_some_and(|sessions| sessions.values().any(https_443_in_use))
+}
+
+async fn wait_for_port(port: u16) -> Result<()> {
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);
+    for _ in 0..50 {
+        if tokio::net::TcpStream::connect(addr).await.is_ok() {
+            return Ok(());
+        }
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+    bail!("Local port {port} did not become ready; check whether it is already in use")
+}
+
+async fn shutdown_signal() {
+    #[cfg(unix)]
+    {
+        use tokio::signal::unix::{SignalKind, signal};
+        if let Ok(mut terminate) = signal(SignalKind::terminate()) {
+            tokio::select! {
+                _ = tokio::signal::ctrl_c() => {},
+                _ = terminate.recv() => {},
+            }
+            return;
+        }
+    }
+    let _ = tokio::signal::ctrl_c().await;
+}
+
+pub async fn run() -> Result<()> {
+    let root = project_root()?;
+    if !root.join("out/web/index-web.html").exists() {
+        bail!("Build the production Web UI first: npm run build:web");
+    }
+    let status: Value = serde_json::from_str(&tailscale(&["status", "--json"])?)
+        .context("Could not read Tailscale status")?;
+    let url = tailnet_url(&status)?;
+    let serve_status: Value = serde_json::from_str(&tailscale(&["serve", "status", "--json"])?)
+        .context("Could not read Tailscale Serve status")?;
+    if https_443_in_use(&serve_status) {
+        bail!("Tailscale Serve already uses HTTPS port 443; Mint will not replace it");
+    }
+    for port in [9000, 3000] {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);
+        if tokio::net::TcpStream::connect(addr).await.is_ok() {
+            bail!("Local port {port} is already in use; stop the existing service first");
+        }
+    }
+
+    let config = mint_core::load_config()?;
+    print_welcome_banner(&config);
+
+    let vite = root.join("node_modules/vite/bin/vite.js");
+    if !vite.exists() {
+        bail!("Vite is missing. Run npm install in the Mint project first");
+    }
+    let web = ChildGuard(
+        Command::new("node")
+            .current_dir(&root)
+            .env("MINT_TAILSCALE_HOST", url.trim_start_matches("https://"))
+            .arg(vite)
+            .args([
+                "preview",
+                "--config",
+                "vite.config.web.ts",
+                "--host",
+                "127.0.0.1",
+            ])
+            .stdout(Stdio::null())
+            .stderr(Stdio::inherit())
+            .spawn()
+            .context("Could not start the production Web UI")?,
+    );
+    wait_for_port(9000).await?;
+
+    let api_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 3000);
+    let mut api = tokio::spawn(mint_core::api_server::start_api_server_on(api_addr));
+    if let Err(error) = wait_for_port(3000).await {
+        api.abort();
+        return Err(error);
+    }
+
+    let mut serve = match Command::new("tailscale")
+        .args(["serve", "--https=443", "http://127.0.0.1:9000"])
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()
+    {
+        Ok(child) => ChildGuard(child),
+        Err(error) => {
+            api.abort();
+            return Err(error).context("Could not start Tailscale Serve");
+        }
+    };
+
+    println!("\n{MINT}Mint Web is starting in your tailnet{RESET}\n");
+    println!("    {BLUE}Mobile HTTPS:{RESET} {MINT}{url}{RESET}");
+    println!("    {BLUE}Local Web UI:{RESET}  {MINT}http://127.0.0.1:9000{RESET}");
+    println!("    {DIM}Open the HTTPS URL after Tailscale Serve reports it is available.{RESET}");
+    println!("    {DIM}Press Ctrl+C to stop Mint Web and Tailscale Serve.{RESET}\n");
+
+    let result = loop {
+        tokio::select! {
+            _ = shutdown_signal() => break Ok(()),
+            outcome = &mut api => {
+                break match outcome {
+                    Ok(Ok(())) => Ok(()),
+                    Ok(Err(error)) => Err(error.into()),
+                    Err(error) => Err(error.into()),
+                };
+            }
+            _ = tokio::time::sleep(Duration::from_secs(1)) => {
+                if let Some(status) = serve.0.try_wait()? {
+                    break Err(anyhow::anyhow!("Tailscale Serve stopped ({status}). Check that HTTPS certificates and Serve are enabled for this tailnet"));
+                }
+            }
+        }
+    };
+    api.abort();
+    drop(serve);
+    drop(web);
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn requires_connected_tailnet_with_dns_name() {
+        assert_eq!(
+            tailnet_url(
+                &json!({"BackendState":"Running","Self":{"DNSName":"mint.example.ts.net."}})
+            )
+            .unwrap(),
+            "https://mint.example.ts.net"
+        );
+        assert!(tailnet_url(&json!({"BackendState":"Stopped"})).is_err());
+        assert!(tailnet_url(&json!({"BackendState":"Running"})).is_err());
+    }
+
+    #[test]
+    fn existing_serve_routes_are_never_overwritten() {
+        assert!(!https_443_in_use(&json!({})));
+        assert!(!https_443_in_use(&json!({"TCP":{"8443":{}}})));
+        assert!(https_443_in_use(
+            &json!({"Web":{"mint.example.ts.net:443":{}}})
+        ));
+        assert!(https_443_in_use(&json!({"TCP":{"443":{"HTTPS":true}}})));
+        assert!(https_443_in_use(
+            &json!({"Foreground":{"session":{"Web":{"mint.example.ts.net:443":{}}}}})
+        ));
+    }
+}