@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-core/src/integrations/channels.rs

@@ -1,38 +1,36 @@
+use super::webhooks::{line_webhook_loop, whatsapp_webhook_loop};
 use std::time::Duration;
+use std::{
+    collections::HashSet,
+    sync::{Mutex, OnceLock},
+};
 
 use crate::{ChatRequest, MintConfig, load_config, orchestrate_chat, set_config_value};
-use base64::{
-    Engine as _,
-    engine::general_purpose::{STANDARD as BASE64, URL_SAFE_NO_PAD},
-};
+use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use futures_util::{FutureExt, SinkExt, StreamExt};
-use hmac::{Hmac, Mac};
 use serde_json::{Value, json};
-use sha2::Sha256;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
 use tokio_tungstenite::{connect_async, tungstenite::Message};
 
 pub fn start_channels() {
     if tokio::runtime::Handle::try_current().is_ok() {
-        tokio::spawn(restarting_loop("telegram", telegram_loop));
-        tokio::spawn(restarting_loop("discord", discord_loop));
-        tokio::spawn(restarting_loop("slack", slack_loop));
-        tokio::spawn(restarting_loop("line", line_webhook_loop));
-        tokio::spawn(restarting_loop("whatsapp", whatsapp_webhook_loop));
-        tokio::spawn(restarting_loop("signal", signal_loop));
-        tokio::spawn(restarting_loop("email", email_loop));
+        tokio::spawn(owned_restarting_loop("telegram", telegram_loop));
+        tokio::spawn(owned_restarting_loop("discord", discord_loop));
+        tokio::spawn(owned_restarting_loop("slack", slack_loop));
+        tokio::spawn(owned_restarting_loop("line", line_webhook_loop));
+        tokio::spawn(owned_restarting_loop("whatsapp", whatsapp_webhook_loop));
+        tokio::spawn(owned_restarting_loop("signal", signal_loop));
+        tokio::spawn(owned_restarting_loop("email", email_loop));
     } else {
         std::thread::spawn(|| {
             if let Ok(rt) = tokio::runtime::Runtime::new() {
                 rt.block_on(async {
-                    let h1 = tokio::spawn(restarting_loop("telegram", telegram_loop));
-                    let h2 = tokio::spawn(restarting_loop("discord", discord_loop));
-                    let h3 = tokio::spawn(restarting_loop("slack", slack_loop));
-                    let h4 = tokio::spawn(restarting_loop("line", line_webhook_loop));
-                    let h5 = tokio::spawn(restarting_loop("whatsapp", whatsapp_webhook_loop));
-                    let h6 = tokio::spawn(restarting_loop("signal", signal_loop));
-                    let h7 = tokio::spawn(restarting_loop("email", email_loop));
+                    let h1 = tokio::spawn(owned_restarting_loop("telegram", telegram_loop));
+                    let h2 = tokio::spawn(owned_restarting_loop("discord", discord_loop));
+                    let h3 = tokio::spawn(owned_restarting_loop("slack", slack_loop));
+                    let h4 = tokio::spawn(owned_restarting_loop("line", line_webhook_loop));
+                    let h5 = tokio::spawn(owned_restarting_loop("whatsapp", whatsapp_webhook_loop));
+                    let h6 = tokio::spawn(owned_restarting_loop("signal", signal_loop));
+                    let h7 = tokio::spawn(owned_restarting_loop("email", email_loop));
                     let _ = tokio::join!(h1, h2, h3, h4, h5, h6, h7);
                 });
             }
@@ -78,6 +76,35 @@ where
     }
 }
 
+async fn owned_restarting_loop<F, Fut>(name: &'static str, run: F)
+where
+    F: FnMut() -> Fut,
+    Fut: std::future::Future<Output = Result<(), String>>,
+{
+    static OWNERS: OnceLock<Mutex<HashSet<&'static str>>> = OnceLock::new();
+    struct Lease(&'static str);
+    impl Drop for Lease {
+        fn drop(&mut self) {
+            OWNERS
+                .get()
+                .unwrap()
+                .lock()
+                .unwrap_or_else(|e| e.into_inner())
+                .remove(self.0);
+        }
+    }
+    let owners = OWNERS.get_or_init(Mutex::default);
+    if !owners
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .insert(name)
+    {
+        return;
+    }
+    let _lease = Lease(name);
+    restarting_loop(name, run).await;
+}
+
 pub(crate) fn panic_payload_message(payload: &(dyn std::any::Any + Send)) -> String {
     if let Some(message) = payload.downcast_ref::<&str>() {
         (*message).to_string()
@@ -284,200 +311,6 @@ async fn slack_loop() -> Result<(), String> {
     Ok(())
 }
 
-/// LINE's webhook events (delivered by POST) rather than a socket/poll model, so this binds
-/// a small local HTTP listener instead — same shape as `start_api_server`'s hand-rolled
-/// parsing, just enough of it for a single-request-per-connection webhook. Whatever sits in
-/// front of `lineWebhookHost:lineWebhookPort` (reverse proxy, tunnel, etc.) is the user's
-/// responsibility — LINE requires a public HTTPS callback URL, which this alone can't be.
-async fn line_webhook_loop() -> Result<(), String> {
-    let Some(access_token) = enabled_value("enableLineBridge", "lineChannelAccessToken") else {
-        tokio::time::sleep(Duration::from_secs(30)).await;
-        return Ok(());
-    };
-    let channel_secret = config_value("lineChannelSecret").unwrap_or_default();
-    let host = config_value("lineWebhookHost").unwrap_or_else(|| "127.0.0.1".to_string());
-    let port = config_port("lineWebhookPort", 3000);
-
-    let listener = TcpListener::bind((host.as_str(), port))
-        .await
-        .map_err(|error| error.to_string())?;
-    loop {
-        let Ok((mut socket, _)) = listener.accept().await else {
-            continue;
-        };
-        let access_token = access_token.clone();
-        let channel_secret = channel_secret.clone();
-        tokio::spawn(async move {
-            let Some(request) = read_http_request(&mut socket).await else {
-                return;
-            };
-            if request.method != "POST" {
-                let _ = respond_plain(&mut socket, "404 Not Found").await;
-                return;
-            }
-            if !channel_secret.is_empty() {
-                let signature =
-                    header_value(&request.headers, "X-Line-Signature").unwrap_or_default();
-                if !verify_hmac_sha256_base64(&channel_secret, &request.body, signature) {
-                    let _ = respond_plain(&mut socket, "401 Unauthorized").await;
-                    return;
-                }
-            }
-            let Ok(payload) = serde_json::from_str::<Value>(&request.body) else {
-                let _ = respond_plain(&mut socket, "400 Bad Request").await;
-                return;
-            };
-            crate::bridge_health::record_success("line");
-            // Ack the webhook right away — LINE expects a fast response, and the reply
-            // token below is short-lived regardless, so nothing is gained by waiting.
-            let _ = respond_plain(&mut socket, "200 OK").await;
-
-            let client = crate::HTTP_CLIENT.clone();
-            for event in payload["events"].as_array().cloned().unwrap_or_default() {
-                if event["type"] != "message" || event["message"]["type"] != "text" {
-                    continue;
-                }
-                let (Some(reply_token), Some(text)) = (
-                    event["replyToken"].as_str(),
-                    event["message"]["text"].as_str(),
-                ) else {
-                    continue;
-                };
-                let user_id = event["source"]["userId"].as_str().unwrap_or_default();
-                if !authorize_sender("lineOwnerUserId", user_id) {
-                    continue;
-                }
-                let shared_chat_id = crate::CHAT_CLI_ID.to_string();
-                let reply = answer_channel(
-                    text,
-                    "Reply concisely for a LINE chat.",
-                    Some(shared_chat_id),
-                )
-                .await;
-                let _ = client
-                    .post("https://api.line.me/v2/bot/message/reply")
-                    .bearer_auth(&access_token)
-                    .json(&json!({
-                        "replyToken": reply_token,
-                        "messages": [{ "type": "text", "text": reply }]
-                    }))
-                    .send()
-                    .await;
-            }
-        });
-    }
-}
-
-/// WhatsApp Cloud API's webhook: a GET verification handshake (echoes `hub.challenge` once)
-/// plus POST deliveries for incoming messages. Same "small local listener" shape as
-/// `line_webhook_loop` — see its doc comment for the public-URL caveat.
-async fn whatsapp_webhook_loop() -> Result<(), String> {
-    let Some(access_token) = enabled_value("enableWhatsappBridge", "whatsappCloudAccessToken")
-    else {
-        tokio::time::sleep(Duration::from_secs(30)).await;
-        return Ok(());
-    };
-    let phone_number_id = config_value("whatsappPhoneNumberId").unwrap_or_default();
-    let verify_token = config_value("whatsappVerifyToken").unwrap_or_default();
-    let app_secret = config_value("whatsappAppSecret");
-    let host = config_value("whatsappWebhookHost").unwrap_or_else(|| "127.0.0.1".to_string());
-    let port = config_port("whatsappWebhookPort", 3001);
-
-    let listener = TcpListener::bind((host.as_str(), port))
-        .await
-        .map_err(|error| error.to_string())?;
-    loop {
-        let Ok((mut socket, _)) = listener.accept().await else {
-            continue;
-        };
-        let access_token = access_token.clone();
-        let phone_number_id = phone_number_id.clone();
-        let verify_token = verify_token.clone();
-        let app_secret = app_secret.clone();
-        tokio::spawn(async move {
-            let Some(request) = read_http_request(&mut socket).await else {
-                return;
-            };
-
-            if request.method == "GET" {
-                let mode = query_param(&request.path, "hub.mode").unwrap_or_default();
-                let token = query_param(&request.path, "hub.verify_token").unwrap_or_default();
-                let challenge = query_param(&request.path, "hub.challenge").unwrap_or_default();
-                if mode == "subscribe" && !verify_token.is_empty() && token == verify_token {
-                    crate::bridge_health::record_success("whatsapp");
-                    let _ = respond_text(&mut socket, "200 OK", &challenge).await;
-                } else {
-                    let _ = respond_plain(&mut socket, "403 Forbidden").await;
-                }
-                return;
-            }
-            if request.method != "POST" {
-                let _ = respond_plain(&mut socket, "404 Not Found").await;
-                return;
-            }
-            if let Some(secret) = app_secret.filter(|value| !value.is_empty()) {
-                let signature =
-                    header_value(&request.headers, "X-Hub-Signature-256").unwrap_or_default();
-                let hex_signature = signature.strip_prefix("sha256=").unwrap_or(signature);
-                if !verify_hmac_sha256_hex(&secret, &request.body, hex_signature) {
-                    let _ = respond_plain(&mut socket, "401 Unauthorized").await;
-                    return;
-                }
-            }
-            let Ok(payload) = serde_json::from_str::<Value>(&request.body) else {
-                let _ = respond_plain(&mut socket, "400 Bad Request").await;
-                return;
-            };
-            crate::bridge_health::record_success("whatsapp");
-            let _ = respond_plain(&mut socket, "200 OK").await;
-
-            let client = crate::HTTP_CLIENT.clone();
-            let entries = payload["entry"].as_array().cloned().unwrap_or_default();
-            for change in entries
-                .iter()
-                .flat_map(|entry| entry["changes"].as_array().cloned().unwrap_or_default())
-            {
-                let messages = change["value"]["messages"]
-                    .as_array()
-                    .cloned()
-                    .unwrap_or_default();
-                for message in messages {
-                    if message["type"] != "text" {
-                        continue;
-                    }
-                    let (Some(from), Some(text)) =
-                        (message["from"].as_str(), message["text"]["body"].as_str())
-                    else {
-                        continue;
-                    };
-                    if !authorize_sender("whatsappOwnerPhone", from) {
-                        continue;
-                    }
-                    let shared_chat_id = crate::CHAT_CLI_ID.to_string();
-                    let reply = answer_channel(
-                        text,
-                        "Reply concisely for a WhatsApp chat.",
-                        Some(shared_chat_id),
-                    )
-                    .await;
-                    let _ = client
-                        .post(format!(
-                            "https://graph.facebook.com/v21.0/{phone_number_id}/messages"
-                        ))
-                        .bearer_auth(&access_token)
-                        .json(&json!({
-                            "messaging_product": "whatsapp",
-                            "to": from,
-                            "text": { "body": reply }
-                        }))
-                        .send()
-                        .await;
-                }
-            }
-        });
-    }
-}
-
 /// Signal has no official bot API, so this talks to a self-hosted
 /// `signal-cli-rest-api` (https://github.com/bbernhard/signal-cli-rest-api)
 /// instance instead — same "bring your own infra" shape as the LINE/WhatsApp
@@ -770,6 +603,7 @@ pub async fn answer_channel(
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         },
     )
     .await
@@ -834,7 +668,7 @@ fn extra_string(config: &MintConfig, key: &str) -> Option<String> {
 /// e.g. `"telegramOwnerChatId"`) and everyone else is rejected from then on.
 /// To let a different sender claim it later, clear the stored id — e.g.
 /// `mint config set telegramOwnerChatId ""`.
-fn authorize_sender(owner_key: &str, sender_id: &str) -> bool {
+pub(super) fn authorize_sender(owner_key: &str, sender_id: &str) -> bool {
     if sender_id.is_empty() {
         return false;
     }
@@ -880,138 +714,47 @@ fn request_error(error: reqwest::Error) -> String {
     error.to_string()
 }
 
-fn config_port(key: &str, default: u16) -> u16 {
-    load_config()
-        .ok()
-        .and_then(|config| config.extra.get(key).and_then(Value::as_u64))
-        .and_then(|value| u16::try_from(value).ok())
-        .unwrap_or(default)
-}
-
-struct RawHttpRequest {
-    method: String,
-    path: String,
-    /// Raw header block (request line through the last header, no trailing blank line).
-    headers: String,
-    body: String,
-}
-
-/// Reads one HTTP/1.1 request off a freshly-accepted socket — same hand-rolled approach
-/// `start_api_server` uses (read until the header terminator, then read `Content-Length`
-/// more bytes), just trimmed down for a single-shot webhook delivery.
-async fn read_http_request(socket: &mut tokio::net::TcpStream) -> Option<RawHttpRequest> {
-    const MAX_WEBHOOK_REQUEST_BYTES: usize = 2 * 1024 * 1024;
-    let mut buf = Vec::with_capacity(4096);
-    let mut chunk = [0_u8; 4096];
-    let mut expected_len: Option<usize> = None;
-
-    loop {
-        let n = match socket.read(&mut chunk).await {
-            Ok(n) if n > 0 => n,
-            _ => break,
-        };
-        buf.extend_from_slice(&chunk[..n]);
-        if buf.len() > MAX_WEBHOOK_REQUEST_BYTES {
-            return None;
-        }
-
-        let text = String::from_utf8_lossy(&buf);
-        if expected_len.is_none() && text.contains("\r\n\r\n") {
-            expected_len = text
-                .to_lowercase()
-                .find("content-length:")
-                .and_then(|pos| {
-                    let sub = &text[pos..];
-                    let line_end = sub.find("\r\n")?;
-                    sub["content-length:".len()..line_end]
-                        .trim()
-                        .parse::<usize>()
-                        .ok()
-                })
-                .map(|content_len| text.find("\r\n\r\n").unwrap() + 4 + content_len);
-        }
-
-        match expected_len {
-            Some(total) if buf.len() >= total => break,
-            None if text.contains("\r\n\r\n") => break,
-            _ => {}
-        }
-    }
-
-    if buf.is_empty() {
-        return None;
-    }
-    let text = String::from_utf8_lossy(&buf).to_string();
-    let header_end = text.find("\r\n\r\n")?;
-    let request_line_end = text.find("\r\n").unwrap_or(header_end);
-    let mut parts = text[..request_line_end].split_whitespace();
-    let method = parts.next()?.to_string();
-    let path = parts.next()?.to_string();
-
-    Some(RawHttpRequest {
-        method,
-        path,
-        headers: text[..header_end].to_string(),
-        body: text[header_end + 4..].to_string(),
-    })
-}
-
-fn header_value<'a>(headers: &'a str, name: &str) -> Option<&'a str> {
-    headers.lines().find_map(|line| {
-        let (key, value) = line.split_once(':')?;
-        key.trim().eq_ignore_ascii_case(name).then(|| value.trim())
-    })
-}
-
-fn query_param(path: &str, key: &str) -> Option<String> {
-    let (_, query) = path.split_once('?')?;
-    query.split('&').find_map(|pair| {
-        let (k, v) = pair.split_once('=')?;
-        (k == key).then(|| v.to_string())
-    })
-}
-
-async fn respond_plain(socket: &mut tokio::net::TcpStream, status: &str) -> std::io::Result<()> {
-    let response = format!("HTTP/1.1 {status}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
-    socket.write_all(response.as_bytes()).await?;
-    socket.flush().await
-}
-
-async fn respond_text(
-    socket: &mut tokio::net::TcpStream,
-    status: &str,
-    body: &str,
-) -> std::io::Result<()> {
-    let response = format!(
-        "HTTP/1.1 {status}\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
-        body.len(),
-        body
-    );
-    socket.write_all(response.as_bytes()).await?;
-    socket.flush().await
-}
-
-fn hmac_sha256(secret: &str, body: &str) -> Option<Vec<u8>> {
-    let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).ok()?;
-    mac.update(body.as_bytes());
-    Some(mac.finalize().into_bytes().to_vec())
-}
-
-fn verify_hmac_sha256_base64(secret: &str, body: &str, signature: &str) -> bool {
-    hmac_sha256(secret, body).is_some_and(|digest| BASE64.encode(digest) == signature)
-}
-
-fn verify_hmac_sha256_hex(secret: &str, body: &str, signature_hex: &str) -> bool {
-    hmac_sha256(secret, body).is_some_and(|digest| {
-        let expected: String = digest.iter().map(|byte| format!("{byte:02x}")).collect();
-        expected.eq_ignore_ascii_case(signature_hex)
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[tokio::test]
+    async fn core_migration_duplicate_bridge_start_has_one_owner_and_abort_releases_it() {
+        use std::sync::{
+            Arc,
+            atomic::{AtomicUsize, Ordering},
+        };
+        let calls = Arc::new(AtomicUsize::new(0));
+        let start = || {
+            let calls = Arc::clone(&calls);
+            tokio::spawn(owned_restarting_loop("ownership-regression", move || {
+                calls.fetch_add(1, Ordering::SeqCst);
+                std::future::pending::<Result<(), String>>()
+            }))
+        };
+        let first = start();
+        let second = start();
+        tokio::time::sleep(Duration::from_millis(20)).await;
+        assert_eq!(
+            calls.load(Ordering::SeqCst),
+            1,
+            "duplicate startup ran the bridge twice"
+        );
+        first.abort();
+        second.abort();
+        let _ = first.await;
+        let _ = second.await;
+        let next = start();
+        tokio::time::sleep(Duration::from_millis(20)).await;
+        assert_eq!(
+            calls.load(Ordering::SeqCst),
+            2,
+            "aborted runtime retained bridge ownership"
+        );
+        next.abort();
+        let _ = next.await;
+    }
+
     #[test]
     fn no_stored_owner_claims_the_sender() {
         assert_eq!(