@pheem49/mint 1.5.5 → 1.6.1

package/crates/mint-cli/src/gmail.rs

@@ -0,0 +1,216 @@
+use std::{
+    collections::BTreeMap,
+    io::{Read, Write},
+    net::TcpListener,
+    process::{Command, Stdio},
+    thread,
+    time::Duration,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::{Context, Result, anyhow, bail};
+use mint_core::{MintConfig, load_config, save_config};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+
+const AUTH_URL: &str = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL: &str = "https://oauth2.googleapis.com/token";
+const SCOPES: &str =
+    "https://www.googleapis.com/auth/gmail.readonly https://www.googleapis.com/auth/gmail.compose";
+
+pub async fn auth(no_open: bool, port: u16) -> Result<()> {
+    let mut config = load_config()?;
+    let client_id = config_string(&config, "gmailClientId")?;
+    let client_secret = config_string(&config, "gmailClientSecret")?;
+    let listener = TcpListener::bind(("127.0.0.1", port))?;
+    let actual_port = listener.local_addr()?.port();
+    let redirect = format!("http://127.0.0.1:{actual_port}/oauth2callback");
+    let state = state_token();
+    let url = format!(
+        "{AUTH_URL}?client_id={}&redirect_uri={}&response_type=code&scope={}&access_type=offline&prompt=consent&state={}",
+        encode(&client_id),
+        encode(&redirect),
+        encode(SCOPES),
+        encode(&state)
+    );
+    println!("Open this Google OAuth consent link for Gmail:\n{url}\n");
+    if !no_open {
+        open_browser(&url)?;
+    }
+    println!("Waiting for Gmail OAuth callback on {redirect} ...");
+    let code = wait_for_code(listener, &state)?;
+    let token: Value = mint_core::HTTP_CLIENT
+        .clone()
+        .post(TOKEN_URL)
+        .form(&[
+            ("client_id", client_id.as_str()),
+            ("client_secret", client_secret.as_str()),
+            ("code", code.as_str()),
+            ("redirect_uri", redirect.as_str()),
+            ("grant_type", "authorization_code"),
+        ])
+        .send()
+        .await?
+        .error_for_status()?
+        .json()
+        .await?;
+    let refresh = token["refresh_token"]
+        .as_str()
+        .ok_or_else(|| anyhow!("Google did not return a refresh token; run Gmail auth again"))?;
+    config
+        .extra
+        .insert("gmailRefreshToken".into(), Value::String(refresh.into()));
+    config
+        .extra
+        .insert("pluginGmailEnabled".into(), Value::Bool(true));
+    save_config(&config)?;
+    println!("Gmail OAuth refresh token saved.");
+    Ok(())
+}
+
+fn wait_for_code(listener: TcpListener, expected_state: &str) -> Result<String> {
+    listener.set_nonblocking(true)?;
+    let deadline = std::time::Instant::now() + Duration::from_secs(180);
+    let mut stream = loop {
+        match listener.accept() {
+            Ok((stream, _)) => break stream,
+            Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+                if std::time::Instant::now() >= deadline {
+                    bail!("timed out waiting for Gmail authorization callback");
+                }
+                thread::sleep(Duration::from_millis(100));
+            }
+            Err(error) => return Err(error.into()),
+        }
+    };
+    let mut bytes = [0_u8; 8192];
+    let read = stream.read(&mut bytes)?;
+    let request = String::from_utf8_lossy(&bytes[..read]);
+    let target = request
+        .lines()
+        .next()
+        .and_then(|line| line.split_whitespace().nth(1))
+        .ok_or_else(|| anyhow!("invalid OAuth callback request"))?;
+    let (_, query) = target
+        .split_once('?')
+        .ok_or_else(|| anyhow!("OAuth callback did not contain query parameters"))?;
+    let values = query
+        .split('&')
+        .filter_map(|part| part.split_once('='))
+        .map(|(key, value)| (key.to_owned(), decode(value)))
+        .collect::<BTreeMap<_, _>>();
+    let response = if values
+        .get("state")
+        .is_some_and(|state| state == expected_state)
+        && values.contains_key("code")
+    {
+        "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<h1>Gmail connected</h1><p>You can close this window and return to Mint.</p>"
+    } else {
+        "HTTP/1.1 400 Bad Request\r\nContent-Type: text/plain\r\n\r\nInvalid Gmail authorization response."
+    };
+    stream.write_all(response.as_bytes())?;
+    if let Some(error) = values.get("error") {
+        bail!("Gmail authorization failed: {error}");
+    }
+    if values
+        .get("state")
+        .is_none_or(|state| state != expected_state)
+    {
+        bail!("invalid Gmail OAuth state");
+    }
+    values
+        .get("code")
+        .cloned()
+        .ok_or_else(|| anyhow!("Gmail OAuth callback did not include a code"))
+}
+
+fn config_string(config: &MintConfig, key: &str) -> Result<String> {
+    config
+        .extra
+        .get(key)
+        .and_then(Value::as_str)
+        .map(str::to_owned)
+        .filter(|value| !value.trim().is_empty())
+        .ok_or_else(|| anyhow!("missing config value '{key}'"))
+}
+
+fn state_token() -> String {
+    let seed = format!(
+        "{}:{}",
+        std::process::id(),
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos()
+    );
+    format!("{:x}", Sha256::digest(seed.as_bytes()))
+}
+
+fn open_browser(url: &str) -> Result<()> {
+    let mut command = if cfg!(target_os = "windows") {
+        let mut command = Command::new("cmd");
+        command.args(["/c", "start", "", url]);
+        command
+    } else if cfg!(target_os = "macos") {
+        let mut command = Command::new("open");
+        command.arg(url);
+        command
+    } else {
+        let mut command = Command::new("xdg-open");
+        command.arg(url);
+        command
+    };
+    command
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .context("unable to open browser")?;
+    Ok(())
+}
+
+fn encode(value: &str) -> String {
+    value
+        .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()
+            }
+            _ => format!("%{byte:02X}"),
+        })
+        .collect()
+}
+
+fn decode(value: &str) -> String {
+    let bytes = value.as_bytes();
+    let mut output = Vec::new();
+    let mut index = 0;
+    while index < bytes.len() {
+        if bytes[index] == b'%'
+            && index + 2 < bytes.len()
+            && let Ok(byte) = u8::from_str_radix(&value[index + 1..index + 3], 16)
+        {
+            output.push(byte);
+            index += 3;
+            continue;
+        }
+        output.push(if bytes[index] == b'+' {
+            b' '
+        } else {
+            bytes[index]
+        });
+        index += 1;
+    }
+    String::from_utf8_lossy(&output).into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn encodes_and_decodes_oauth_values() {
+        let value = "http://127.0.0.1/callback?a=b c";
+        assert_eq!(decode(&encode(value)), value);
+    }
+}

package/crates/mint-cli/src/image.rs

@@ -0,0 +1,142 @@
+use std::path::Path;
+
+use anyhow::{Context, Result, bail};
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
+
+/// Load an image file from disk and return a `data:<mime>;base64,<data>` URI.
+/// Supports PNG, JPEG, GIF, and WEBP by extension and magic bytes.
+pub fn load_image_as_data_uri(path: &Path) -> Result<String> {
+    let bytes = std::fs::read(path)
+        .with_context(|| format!("failed to read image file: {}", path.display()))?;
+
+    if bytes.is_empty() {
+        bail!("image file is empty: {}", path.display());
+    }
+
+    let mime = detect_mime(&bytes, path);
+    let encoded = BASE64.encode(&bytes);
+    Ok(format!("data:{mime};base64,{encoded}"))
+}
+
+/// Try to read an image from the system clipboard.
+/// Returns `None` if the clipboard contains no image or the required tool is unavailable.
+/// On Linux uses `xclip` or `wl-paste`. On macOS uses `osascript`.
+pub fn read_clipboard_image() -> Result<Option<String>> {
+    #[cfg(target_os = "linux")]
+    {
+        if let Ok(output) = std::process::Command::new("xclip")
+            .args(["-selection", "clipboard", "-t", "image/png", "-o"])
+            .output()
+        {
+            if output.status.success() && !output.stdout.is_empty() {
+                let encoded = BASE64.encode(&output.stdout);
+                return Ok(Some(format!("data:image/png;base64,{encoded}")));
+            }
+        }
+
+        if let Ok(output) = std::process::Command::new("wl-paste")
+            .args(["--type", "image/png"])
+            .output()
+        {
+            if output.status.success() && !output.stdout.is_empty() {
+                let encoded = BASE64.encode(&output.stdout);
+                return Ok(Some(format!("data:image/png;base64,{encoded}")));
+            }
+        }
+
+        Ok(None)
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let script = r#"
+            set png_data to (the clipboard as «class PNGf»)
+            return png_data
+        "#;
+        let output = std::process::Command::new("osascript")
+            .args(["-e", script])
+            .output();
+        if let Ok(out) = output {
+            if out.status.success() && !out.stdout.is_empty() {
+                let encoded = BASE64.encode(&out.stdout);
+                return Ok(Some(format!("data:image/png;base64,{encoded}")));
+            }
+        }
+        Ok(None)
+    }
+
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    {
+        Ok(None)
+    }
+}
+
+pub fn save_sent_image_after_send(data_uri: Option<&str>, message: &str) {
+    if let Some(data_uri) = data_uri {
+        for img in data_uri.split_whitespace() {
+            match mint_core::save_sent_image(img, message) {
+                Ok(entry) => println!("\x1b[90mSaved image: {}\x1b[0m", entry.path.display()),
+                Err(error) => {
+                    eprintln!("\x1b[33mWarning: failed to save sent image: {error}\x1b[0m")
+                }
+            }
+        }
+    }
+}
+
+fn detect_mime(bytes: &[u8], path: &Path) -> &'static str {
+    if bytes.starts_with(&[0x89, 0x50, 0x4E, 0x47]) {
+        return "image/png";
+    }
+    if bytes.starts_with(&[0xFF, 0xD8, 0xFF]) {
+        return "image/jpeg";
+    }
+    if bytes.starts_with(b"GIF8") {
+        return "image/gif";
+    }
+    if bytes.starts_with(b"RIFF") && bytes.len() > 12 && &bytes[8..12] == b"WEBP" {
+        return "image/webp";
+    }
+
+    match path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.to_ascii_lowercase())
+        .as_deref()
+    {
+        Some("jpg") | Some("jpeg") => "image/jpeg",
+        Some("gif") => "image/gif",
+        Some("webp") => "image/webp",
+        Some("bmp") => "image/bmp",
+        _ => "image/png",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn detects_png_by_magic_bytes() {
+        let png_magic = [0x89u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
+        assert_eq!(
+            detect_mime(&png_magic, Path::new("test.unknown")),
+            "image/png"
+        );
+    }
+
+    #[test]
+    fn detects_jpeg_by_magic_bytes() {
+        let jpeg_magic = [0xFF, 0xD8, 0xFF, 0xE0];
+        assert_eq!(
+            detect_mime(&jpeg_magic, Path::new("photo.jpg")),
+            "image/jpeg"
+        );
+    }
+
+    #[test]
+    fn falls_back_to_extension() {
+        let no_magic = [0x00u8, 0x01, 0x02, 0x03];
+        assert_eq!(detect_mime(&no_magic, Path::new("anim.gif")), "image/gif");
+    }
+}