@pheem49/mint 1.6.1 → 1.6.3

package/src-tauri/src/browser.rs

@@ -0,0 +1,141 @@
+use futures_util::{SinkExt, StreamExt};
+use mint_core::MintConfig;
+use serde::Serialize;
+use serde_json::{Value, json};
+use tokio_tungstenite::{connect_async, tungstenite::Message};
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BrowserTab {
+    pub id: String,
+    pub title: String,
+    pub url: String,
+}
+
+pub async fn list_tabs(config: &MintConfig) -> Result<Vec<BrowserTab>, String> {
+    Ok(fetch_pages(config)
+        .await?
+        .into_iter()
+        .filter_map(|page| {
+            Some(BrowserTab {
+                id: page["id"].as_str()?.to_owned(),
+                title: page["title"].as_str().unwrap_or_default().to_owned(),
+                url: page["url"].as_str().unwrap_or_default().to_owned(),
+            })
+        })
+        .collect())
+}
+
+pub async fn navigate(config: &MintConfig, url: &str) -> Result<String, String> {
+    if !(url.starts_with("https://") || url.starts_with("http://")) {
+        return Err("browser navigation only supports http and https URLs".into());
+    }
+    let response = cdp_call(config, "Page.navigate", json!({ "url": url })).await?;
+    response["result"]["frameId"]
+        .as_str()
+        .map(|_| format!("navigating to {url}"))
+        .ok_or_else(|| response_error(&response))
+}
+
+pub async fn read_page_text(config: &MintConfig) -> Result<String, String> {
+    let response = cdp_call(
+        config,
+        "Runtime.evaluate",
+        json!({
+            "expression": "document.body ? document.body.innerText.substring(0, 12000) : ''",
+            "returnByValue": true
+        }),
+    )
+    .await?;
+    response["result"]["result"]["value"]
+        .as_str()
+        .map(str::to_owned)
+        .ok_or_else(|| response_error(&response))
+}
+
+pub async fn click(config: &MintConfig, selector: &str) -> Result<String, String> {
+    let selector = selector.trim();
+    if selector.is_empty() || selector.len() > 500 {
+        return Err("browser selector must contain between 1 and 500 characters".into());
+    }
+    let selector = serde_json::to_string(selector).map_err(|error| error.to_string())?;
+    let response = cdp_call(
+        config,
+        "Runtime.evaluate",
+        json!({
+            "expression": format!(
+                "(() => {{ const element = document.querySelector({selector}); if (!element) return 'not-found'; element.click(); return 'clicked'; }})()"
+            ),
+            "returnByValue": true
+        }),
+    )
+    .await?;
+    match response["result"]["result"]["value"].as_str() {
+        Some("clicked") => Ok("clicked".into()),
+        Some("not-found") => Err(format!("browser selector not found: {selector}")),
+        _ => Err(response_error(&response)),
+    }
+}
+
+async fn cdp_call(config: &MintConfig, method: &str, params: Value) -> Result<Value, String> {
+    let page = fetch_pages(config)
+        .await?
+        .into_iter()
+        .find(|page| page["type"] == "page")
+        .ok_or("Chrome DevTools did not report an open browser page")?;
+    let socket_url = page["webSocketDebuggerUrl"]
+        .as_str()
+        .ok_or("Chrome DevTools page does not expose a websocket URL")?;
+    let (mut socket, _) = connect_async(socket_url)
+        .await
+        .map_err(|error| format!("unable to connect to Chrome DevTools websocket: {error}"))?;
+    socket
+        .send(Message::Text(
+            json!({ "id": 1, "method": method, "params": params })
+                .to_string()
+                .into(),
+        ))
+        .await
+        .map_err(|error| error.to_string())?;
+    while let Some(message) = socket.next().await {
+        let message = message.map_err(|error| error.to_string())?;
+        let Message::Text(raw) = message else {
+            continue;
+        };
+        let value: Value = serde_json::from_str(&raw).map_err(|error| error.to_string())?;
+        if value["id"] == 1 {
+            return Ok(value);
+        }
+    }
+    Err("Chrome DevTools websocket closed before returning a response".into())
+}
+
+async fn fetch_pages(config: &MintConfig) -> Result<Vec<Value>, String> {
+    let endpoint = config
+        .extra
+        .get("browserDebugUrl")
+        .and_then(Value::as_str)
+        .unwrap_or("http://127.0.0.1:9222/json/list");
+    let value: Value = mint_core::HTTP_CLIENT
+        .clone()
+        .get(endpoint)
+        .send()
+        .await
+        .map_err(|error| format!("unable to reach Chrome DevTools at {endpoint}: {error}"))?
+        .error_for_status()
+        .map_err(|error| error.to_string())?
+        .json()
+        .await
+        .map_err(|error| error.to_string())?;
+    value
+        .as_array()
+        .cloned()
+        .ok_or_else(|| "Chrome DevTools response was not a page list".into())
+}
+
+fn response_error(response: &Value) -> String {
+    response["error"]["message"]
+        .as_str()
+        .unwrap_or("Chrome DevTools returned an unexpected response")
+        .to_owned()
+}

package/src-tauri/src/desktop.rs

@@ -0,0 +1,392 @@
+use std::{
+    fs,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
+
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use image::ImageFormat;
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use tauri::{
+    AppHandle, Emitter, Manager, PhysicalPosition, PhysicalSize, WebviewUrl, WebviewWindowBuilder,
+};
+
+use crate::system::run_system_automation;
+use mint_core::{KnowledgeStore, create_folder, find_paths};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DesktopAction {
+    #[serde(rename = "type")]
+    pub kind: String,
+    #[serde(default)]
+    pub target: String,
+    #[serde(default)]
+    pub server: String,
+    #[serde(default)]
+    pub args: Value,
+    #[serde(default)]
+    pub approved: bool,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActionResult {
+    pub success: bool,
+    pub message: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CaptureRect {
+    pub x: u32,
+    pub y: u32,
+    pub width: u32,
+    pub height: u32,
+}
+
+pub fn open_desktop_window(app: &AppHandle, kind: &str) -> Result<(), String> {
+    let (label, route, width, height, always_on_top, skip_taskbar) = match kind {
+        "settings" => ("settings", "settings", 1020.0, 720.0, false, false),
+        "spotlight" => ("spotlight", "spotlight", 600.0, 80.0, true, true),
+        "widget" => ("widget", "widget", 150.0, 150.0, true, true),
+        "screen-picker" => ("screen-picker", "screen-picker", 1280.0, 800.0, true, true),
+        other => return Err(format!("unsupported desktop window '{other}'")),
+    };
+
+    if let Some(window) = app.get_webview_window(label) {
+        window.show().map_err(|error| error.to_string())?;
+        window.set_focus().map_err(|error| error.to_string())?;
+        return Ok(());
+    }
+
+    let url = WebviewUrl::App(format!("index.html#/{route}").into());
+    let mut builder = WebviewWindowBuilder::new(app, label, url)
+        .title(format!("Mint {kind}"))
+        .inner_size(width, height)
+        .decorations(kind == "settings")
+        .transparent(true)
+        .always_on_top(always_on_top)
+        .skip_taskbar(skip_taskbar);
+    if kind == "screen-picker" {
+        builder = builder.fullscreen(true);
+    }
+    builder.build().map_err(|error| error.to_string())?;
+    Ok(())
+}
+
+pub fn hide_window(app: &AppHandle, label: &str) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .hide()
+        .map_err(|error| error.to_string())
+}
+
+pub fn close_window(app: &AppHandle, label: &str) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .close()
+        .map_err(|error| error.to_string())
+}
+
+pub fn resize_window(app: &AppHandle, label: &str, width: u32, height: u32) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .set_size(PhysicalSize::new(width, height))
+        .map_err(|error| error.to_string())
+}
+
+pub fn position_widget(app: &AppHandle) {
+    let Some(widget) = app.get_webview_window("widget") else {
+        return;
+    };
+    let Ok(Some(monitor)) = widget.primary_monitor() else {
+        return;
+    };
+    let size = monitor.size();
+    let x = size.width.saturating_sub(190) as i32;
+    let _ = widget.set_position(PhysicalPosition::new(x, 40));
+}
+
+pub fn execute_action(
+    config: &mint_core::MintConfig,
+    action: DesktopAction,
+) -> Result<ActionResult, String> {
+    match action.kind.as_str() {
+        "none" => Ok(success("no action requested")),
+        "system_info" => Ok(success(&format!(
+            "os={} arch={} family={}",
+            std::env::consts::OS,
+            std::env::consts::ARCH,
+            std::env::consts::FAMILY
+        ))),
+        "open_url" => {
+            if !(action.target.starts_with("https://")
+                || action.target.starts_with("http://")
+                || action.target.starts_with("file://"))
+            {
+                return Err("only http, https, and file URLs may be opened".into());
+            }
+            spawn_detached("xdg-open", &[&action.target])?;
+            Ok(success("opened URL"))
+        }
+        "search" => {
+            let query = action.target.trim();
+            if query.is_empty() {
+                return Err("search query is required".into());
+            }
+            let url = format!("https://www.google.com/search?q={}", encode_query(query));
+            spawn_detached("xdg-open", &[&url])?;
+            Ok(success("opened web search"))
+        }
+        "open_app" => {
+            let app = action.target.trim();
+            if app.is_empty()
+                || !app
+                    .chars()
+                    .all(|char| char.is_ascii_alphanumeric() || matches!(char, '-' | '_' | '.'))
+            {
+                return Err("application name contains unsupported characters".into());
+            }
+            spawn_detached(app, &[])?;
+            Ok(success("opened application"))
+        }
+        "clipboard_write" => Err("clipboard actions are handled by the renderer".into()),
+        "mcp_tool" => mint_core::call_mcp_tool(config, &action.server, &action.target, action.args)
+            .map(|result| success(&result.to_string()))
+            .map_err(|error| error.to_string()),
+        "system_automation" => {
+            run_system_automation(&action.target, action.approved).map(|message| success(&message))
+        }
+        "create_folder" => create_folder(std::path::Path::new(&action.target), config)
+            .map(|path| success(&format!("created {}", path.display())))
+            .map_err(|error| error.to_string()),
+        "find_path" => {
+            let roots = action.args["roots"]
+                .as_array()
+                .map(|roots| {
+                    roots
+                        .iter()
+                        .filter_map(Value::as_str)
+                        .map(PathBuf::from)
+                        .collect::<Vec<_>>()
+                })
+                .filter(|roots| !roots.is_empty())
+                .unwrap_or_else(|| {
+                    let mut roots =
+                        vec![std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))];
+                    if let Some(home) = dirs::home_dir() {
+                        roots.push(home);
+                    }
+                    roots
+                });
+            let limit = action.args["limit"].as_u64().unwrap_or(20).min(100) as usize;
+            serde_json::to_string(&find_paths(&action.target, &roots, limit, config))
+                .map(|message| success(&message))
+                .map_err(|error| error.to_string())
+        }
+        "learn_file" => KnowledgeStore::open_default()
+            .map_err(|error| error.to_string())?
+            .index_file(std::path::Path::new(&action.target), config)
+            .map(|chunks| success(&format!("indexed {chunks} knowledge chunks")))
+            .map_err(|error| error.to_string()),
+        other => Err(format!(
+            "desktop action '{other}' has not migrated to the allowlisted Rust executor"
+        )),
+    }
+}
+
+pub fn capture_screen() -> Result<String, String> {
+    capture_screen_bytes().map(|bytes| format!("data:image/png;base64,{}", STANDARD.encode(bytes)))
+}
+
+pub fn read_clipboard_image() -> Result<String, String> {
+    let output = Command::new("wl-paste").args(&["-t", "image/png"]).output();
+
+    if let Ok(out) = output {
+        if out.status.success() && !out.stdout.is_empty() {
+            return Ok(format!(
+                "data:image/png;base64,{}",
+                STANDARD.encode(&out.stdout)
+            ));
+        }
+    }
+
+    let output = Command::new("xclip")
+        .args(&["-selection", "clipboard", "-t", "image/png", "-o"])
+        .output();
+
+    if let Ok(out) = output {
+        if out.status.success() && !out.stdout.is_empty() {
+            return Ok(format!(
+                "data:image/png;base64,{}",
+                STANDARD.encode(&out.stdout)
+            ));
+        }
+    }
+
+    Err("No image found in clipboard".into())
+}
+
+pub async fn translate_screen_region(
+    config: &mint_core::MintConfig,
+    rect: CaptureRect,
+) -> Result<String, String> {
+    let bytes = capture_screen_bytes()?;
+    let image = image::load_from_memory(&bytes).map_err(|error| error.to_string())?;
+    if rect.width == 0 || rect.height == 0 || rect.x >= image.width() || rect.y >= image.height() {
+        return Err("screen capture rectangle is invalid".into());
+    }
+    let width = rect.width.min(image.width() - rect.x);
+    let height = rect.height.min(image.height() - rect.y);
+    let cropped = image.crop_imm(rect.x, rect.y, width, height);
+    let mut jpeg = std::io::Cursor::new(Vec::new());
+    cropped
+        .write_to(&mut jpeg, ImageFormat::Jpeg)
+        .map_err(|error| error.to_string())?;
+    let api_key = if config.api_key.trim().is_empty() {
+        std::env::var("GEMINI_API_KEY").unwrap_or_default()
+    } else {
+        config.api_key.clone()
+    };
+    if api_key.trim().is_empty() {
+        return Err("Gemini API key is required for live translation".into());
+    }
+    let value: Value = mint_core::HTTP_CLIENT.clone()
+        .post(format!(
+            "https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent?key={api_key}",
+            config.gemini_model
+        ))
+        .json(&json!({
+            "contents": [{
+                "role": "user",
+                "parts": [
+                    { "text": "Translate visible text in this image into Thai. Return only the translated text. If there is no readable text, return an empty string." },
+                    { "inlineData": { "mimeType": "image/jpeg", "data": STANDARD.encode(jpeg.into_inner()) } }
+                ]
+            }]
+        }))
+        .send()
+        .await
+        .map_err(|error| error.to_string())?
+        .error_for_status()
+        .map_err(|error| error.to_string())?
+        .json()
+        .await
+        .map_err(|error| error.to_string())?;
+    value["candidates"][0]["content"]["parts"][0]["text"]
+        .as_str()
+        .map(str::to_owned)
+        .ok_or_else(|| "Gemini translation response did not include text".into())
+}
+
+pub(crate) fn capture_screen_bytes() -> Result<Vec<u8>, String> {
+    let path = std::env::temp_dir().join(format!("mint-screen-{}.png", std::process::id()));
+    let commands = [
+        ("grim", vec![path_string(&path)]),
+        ("gnome-screenshot", vec!["-f".into(), path_string(&path)]),
+        (
+            "spectacle",
+            vec!["-b".into(), "-n".into(), "-o".into(), path_string(&path)],
+        ),
+        ("scrot", vec![path_string(&path)]),
+        (
+            "import",
+            vec!["-window".into(), "root".into(), path_string(&path)],
+        ),
+    ];
+    let mut attempted = Vec::new();
+    for (program, args) in commands {
+        attempted.push(program);
+        let result = Command::new(program)
+            .args(&args)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+        if result.is_ok_and(|status| status.success()) && path.exists() {
+            let bytes = fs::read(&path).map_err(|error| error.to_string())?;
+            let _ = fs::remove_file(&path);
+            return Ok(bytes);
+        }
+    }
+    Err(format!(
+        "screen capture requires one of these commands: {}",
+        attempted.join(", ")
+    ))
+}
+
+pub fn integration_status(config: &mint_core::MintConfig) -> Value {
+    let mcp_servers = config
+        .extra
+        .get("mcpServers")
+        .and_then(Value::as_object)
+        .map(|servers| servers.keys().cloned().collect::<Vec<_>>())
+        .unwrap_or_default();
+    json!({
+        "automation": {
+            "supportedActions": ["open_url", "open_app", "search", "system_info", "system_automation", "find_path", "create_folder", "learn_file"],
+            "approvalRequired": true
+        },
+        "mcp": {
+            "configuredServers": mcp_servers,
+            "execution": "native-stdio"
+        },
+        "plugins": {
+            "migrated": ["desktop-actions", "dev_tools", "docker", "obsidian", "spotify", "system_metrics"]
+        }
+    })
+}
+
+pub fn emit_to_main(app: &AppHandle, event: &str, payload: impl Serialize + Clone) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit(event, payload);
+        let _ = main.show();
+        let _ = main.set_focus();
+    }
+}
+
+fn success(message: &str) -> ActionResult {
+    ActionResult {
+        success: true,
+        message: message.into(),
+    }
+}
+
+fn spawn_detached(program: &str, args: &[&str]) -> Result<(), String> {
+    Command::new(program)
+        .args(args)
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .map(|_| ())
+        .map_err(|error| format!("unable to start '{program}': {error}"))
+}
+
+fn path_string(path: &PathBuf) -> String {
+    path.to_string_lossy().into_owned()
+}
+
+fn encode_query(query: &str) -> String {
+    query
+        .bytes()
+        .map(|byte| match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                (byte as char).to_string()
+            }
+            b' ' => "+".into(),
+            _ => format!("%{byte:02X}"),
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn encodes_search_queries_for_urls() {
+        assert_eq!(encode_query("mint cli"), "mint+cli");
+        assert_eq!(encode_query("a/b"), "a%2Fb");
+    }
+}

package/src-tauri/src/discord_rpc.rs

@@ -0,0 +1,99 @@
+use std::io::{Read, Write};
+
+use mint_core::MintConfig;
+use serde_json::{Value, json};
+
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+pub fn set_activity(config: &MintConfig, instruction: &str) -> Result<String, String> {
+    let application_id = config
+        .extra
+        .get("discordApplicationId")
+        .and_then(Value::as_str)
+        .filter(|value| !value.trim().is_empty())
+        .ok_or("missing config value 'discordApplicationId'")?;
+    let input: Value = serde_json::from_str(instruction).unwrap_or_else(|_| {
+        json!({ "details": instruction.trim().is_empty().then_some("Using Mint Assistant").unwrap_or(instruction) })
+    });
+    let activity = json!({
+        "details": input["details"].as_str().unwrap_or("Using Mint Assistant"),
+        "state": input["state"].as_str().unwrap_or("Native Tauri desktop"),
+        "instance": false
+    });
+    send(application_id, activity)?;
+    Ok("Discord Rich Presence activity updated.".into())
+}
+
+#[cfg(unix)]
+fn send(application_id: &str, activity: Value) -> Result<(), String> {
+    let mut socket = connect()?;
+    write_frame(
+        &mut socket,
+        0,
+        &json!({ "v": 1, "client_id": application_id }),
+    )?;
+    let _ = read_frame(&mut socket)?;
+    write_frame(
+        &mut socket,
+        1,
+        &json!({
+            "cmd": "SET_ACTIVITY",
+            "args": { "pid": std::process::id(), "activity": activity },
+            "nonce": format!("mint-{}", std::process::id())
+        }),
+    )?;
+    let _ = read_frame(&mut socket)?;
+    Ok(())
+}
+
+#[cfg(not(unix))]
+fn send(_application_id: &str, _activity: Value) -> Result<(), String> {
+    Err("Discord Rich Presence is currently implemented for Unix desktop IPC only".into())
+}
+
+#[cfg(unix)]
+fn connect() -> Result<UnixStream, String> {
+    let runtime = std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".into());
+    (0..10)
+        .find_map(|index| UnixStream::connect(format!("{runtime}/discord-ipc-{index}")).ok())
+        .ok_or_else(|| "Discord IPC socket was not found; start Discord desktop first".into())
+}
+
+fn write_frame(stream: &mut impl Write, opcode: u32, payload: &Value) -> Result<(), String> {
+    let payload = serde_json::to_vec(payload).map_err(|error| error.to_string())?;
+    stream
+        .write_all(&opcode.to_le_bytes())
+        .and_then(|_| stream.write_all(&(payload.len() as u32).to_le_bytes()))
+        .and_then(|_| stream.write_all(&payload))
+        .map_err(|error| format!("unable to write Discord IPC frame: {error}"))
+}
+
+fn read_frame(stream: &mut impl Read) -> Result<Value, String> {
+    let mut header = [0_u8; 8];
+    stream
+        .read_exact(&mut header)
+        .map_err(|error| format!("unable to read Discord IPC header: {error}"))?;
+    let length = u32::from_le_bytes(header[4..8].try_into().unwrap()) as usize;
+    let mut payload = vec![0; length];
+    stream
+        .read_exact(&mut payload)
+        .map_err(|error| format!("unable to read Discord IPC payload: {error}"))?;
+    serde_json::from_slice(&payload).map_err(|error| error.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn writes_discord_rpc_frame() {
+        let mut bytes = Vec::new();
+        write_frame(&mut bytes, 1, &json!({ "ok": true })).unwrap();
+        assert_eq!(u32::from_le_bytes(bytes[0..4].try_into().unwrap()), 1);
+        assert_eq!(
+            u32::from_le_bytes(bytes[4..8].try_into().unwrap()) as usize,
+            bytes.len() - 8
+        );
+    }
+}

package/src-tauri/src/events.rs

@@ -0,0 +1,70 @@
+use std::{
+    fs,
+    net::{SocketAddr, TcpStream},
+    path::Path,
+    thread,
+    time::Duration,
+};
+
+use serde_json::json;
+use tauri::{AppHandle, Emitter, Manager};
+
+pub fn start_system_events(app: AppHandle) {
+    thread::spawn(move || {
+        let mut last_battery = None;
+        let mut last_online = None;
+        loop {
+            let battery = battery_level(Path::new("/sys/class/power_supply"));
+            if let Some(level) = battery
+                .filter(|level| *level <= 20 && last_battery.is_none_or(|previous| previous > 20))
+            {
+                emit_notification(
+                    &app,
+                    json!({ "message": format!("Battery is low ({level}%). Please plug in your charger."), "type": "warning" }),
+                );
+            }
+            last_battery = battery;
+
+            let online = network_online();
+            if last_online.is_some_and(|previous| previous != online) {
+                emit_notification(
+                    &app,
+                    json!({
+                        "message": if online { "Internet connection restored." } else { "Internet connection lost." },
+                        "type": "info"
+                    }),
+                );
+            }
+            last_online = Some(online);
+            thread::sleep(Duration::from_secs(60));
+        }
+    });
+}
+
+fn emit_notification(app: &AppHandle, payload: serde_json::Value) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit("proactive-notification", payload);
+    }
+}
+
+fn battery_level(root: &Path) -> Option<u8> {
+    fs::read_dir(root).ok()?.flatten().find_map(|entry| {
+        let name = entry.file_name().to_string_lossy().to_ascii_uppercase();
+        if !name.starts_with("BAT") {
+            return None;
+        }
+        fs::read_to_string(entry.path().join("capacity"))
+            .ok()?
+            .trim()
+            .parse()
+            .ok()
+    })
+}
+
+fn network_online() -> bool {
+    "1.1.1.1:53"
+        .parse::<SocketAddr>()
+        .ok()
+        .and_then(|address| TcpStream::connect_timeout(&address, Duration::from_secs(2)).ok())
+        .is_some()
+}