Rework chat link to use webhook

This allows the fctrl discord bot to "impersonate" in-game usernames as their nicknames, instead of simply prefixing it to the message.
Update Cargo dependencies

Author: circlesabound

Cargo.lock

@@ -12,46 +12,46 @@ async_zip = { version = "0.0.17", features = [ "full" ] }
 base64 = "0.22.1"
 bincode = "1.3"
 bytes = "1.8.0"
-chrono = { version = "0.4.38", features = [ "serde" ] }
+chrono = { version = "0.4.39", features = [ "serde" ] }
 derive_more = { version = "1.0", features = [ "full" ] }
-env_logger = "0.11.5"
+env_logger = "0.11.6"
 factorio-file-parser = { git = "https://github.com/circlesabound/factorio-file-parser", rev = "6a4c062" }
 futures = "0.3.31"
 futures-util = "0.3.31"
-http = "1.1.0"
+http = "1.2.0"
 lazy_static = "1.5.0"
 log = "0.4.22"
 nix = { version = "0.29", features = [ "process", "signal" ] }
 rand = "0.8.5"
 rcon = { version = "0.6", features = [ "rt-tokio" ] }
-regex = "1.11.0"
-reqwest = { version = "0.12.8", features = [ "json" ] }
-rocksdb = "0.22"
+regex = "1.11.1"
+reqwest = { version = "0.12.12", features = [ "json" ] }
+rocksdb = "0.23"
 rocket = { version = "0.5.1", features = [ "json" ] }
-serde = { version = "1.0.210", features = [ "derive" ] }
-serde_json = "1.0.132"
-serenity = { version = "0.12.2", default-features = false, features = [ "client", "gateway", "rustls_backend", "model", "cache" ] }
+serde = { version = "1.0.217", features = [ "derive" ] }
+serde_json = "1.0.134"
+serenity = { version = "0.12.4", default-features = false, features = [ "client", "gateway", "rustls_backend", "model", "cache" ] }
 stream-cancel = "0.8.2"
 strum = "0.26.3"
 strum_macros = "0.26.4"
-sysinfo = "0.32.0"
-tar = "0.4.42"
-tokio = { version = "1.40.0", features = [ "full" ] }
-tokio-stream = { version = "0.1.16", features = [ "sync" ] }
-tokio-tungstenite = { version = "0.24", features = [ "native-tls", "url" ] }
-tokio-util = "0.7.12"
+sysinfo = "0.33.1"
+tar = "0.4.43"
+tokio = { version = "1.42.0", features = [ "full" ] }
+tokio-stream = { version = "0.1.17", features = [ "sync" ] }
+tokio-tungstenite = { version = "0.26.1", features = [ "native-tls", "url" ] }
+tokio-util = "0.7.13"
 toml = "0.8.19"
 unicode-xid = "0.2.6"
-url = "2.5.2"
+url = "2.5.4"
 urlencoding = "2.1.3"
 uuid = { version = "1.11.0", features = [ "serde", "v4" ] }
 xz2 = "0.1.7"
 
 [build-dependencies]
-vergen-gitcl = { version = "1.0", features = [ "build" ] }
+vergen-gitcl = { version = "1.0.2", features = [ "build" ] }
 
 [dev-dependencies]
-serial_test = "3.1.1"
+serial_test = "3.2.0"
 
 [target.'cfg(not(windows))'.dependencies]
 openssl-sys = { version = "0.9.104", features = [ "vendored" ] }

Cargo.toml

@@ -196,7 +196,7 @@ impl AgentController {
                                 debug!("Sending streaming message: {}", json);
                                 AgentController::_send_message(
                                     Arc::clone(&ws_tx_clone),
-                                    Message::Text(json),
+                                    Message::Text(json.into()),
                                 )
                                 .await;
                             }
@@ -477,7 +477,7 @@ impl AgentController {
             }
             Ok(json) => {
                 debug!("Sending ack: {}", json);
-                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json)).await;
+                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json.into())).await;
             }
         }
     }
@@ -496,7 +496,7 @@ impl AgentController {
             }
             Ok(json) => {
                 debug!("Sending reply: {}", json);
-                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json)).await;
+                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json.into())).await;
             }
         }
     }
@@ -515,7 +515,7 @@ impl AgentController {
             }
             Ok(json) => {
                 debug!("Sending reply_success: {}", json);
-                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json)).await;
+                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json.into())).await;
             }
         }
     }
@@ -534,7 +534,7 @@ impl AgentController {
             }
             Ok(json) => {
                 debug!("Sending reply_failed: {}", json);
-                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json)).await;
+                AgentController::_send_message(Arc::clone(&self.ws_tx), Message::Text(json.into())).await;
             }
         }
     }

src/agent/main.rs

@@ -25,9 +25,9 @@ pub struct ProcessManager {
 
 impl ProcessManager {
     pub fn new() -> Self {
-        let sysinfo_refresh_specifics = RefreshKind::new()
-            .with_cpu(CpuRefreshKind::new().with_cpu_usage())
-            .with_memory(MemoryRefreshKind::new().with_ram());
+        let sysinfo_refresh_specifics = RefreshKind::nothing()
+            .with_cpu(CpuRefreshKind::nothing().with_cpu_usage())
+            .with_memory(MemoryRefreshKind::nothing().with_ram());
         let sysinfo = Arc::new(RwLock::new(System::new_with_specifics(sysinfo_refresh_specifics)));
         let sysinfo_arc = Arc::clone(&sysinfo);
         tokio::spawn(async move {

src/agent/server/proc.rs

@@ -542,7 +542,7 @@ pub async fn connect(ws_addr: url::Url, event_broker: Arc<EventBroker>) -> Resul
     let keep_alive_task = tokio::spawn(async move {
         while consecutive_missed_pings_1.load(Ordering::Acquire) < 3 {
             tokio::time::sleep(Duration::from_secs(15)).await;
-            let ping = Message::Ping(b"ping".to_vec());
+            let ping = Message::Ping(b"ping".to_vec().into());
             if let Err(e) = ws_write_1.lock().await.send(ping).await {
                 error!("Failed to send ping: {:?}", e);
             } else {
@@ -558,7 +558,7 @@ pub async fn connect(ws_addr: url::Url, event_broker: Arc<EventBroker>) -> Resul
     let forward_outgoing_task = tokio::spawn(async move {
         pin_mut!(outgoing_stream);
         while let Some(outgoing_event) = outgoing_stream.next().await {
-            let msg = Message::Text(outgoing_event.content);
+            let msg = Message::Text(outgoing_event.content.into());
             if let Err(e) = ws_write_2.lock().await.send(msg).await {
                 error!("Websocket error sending request to agent: {:?}", e);
                 break;
@@ -574,7 +574,7 @@ pub async fn connect(ws_addr: url::Url, event_broker: Arc<EventBroker>) -> Resul
                 Ok(msg) => {
                     match msg {
                         Message::Text(s) => {
-                            if let Some(event) = tag_incoming_message(s) {
+                            if let Some(event) = tag_incoming_message(s.to_string()) {
                                 event_broker.publish(event).await;
                             }
                         }

src/mgmt-server/clients.rs

@@ -5,7 +5,7 @@ use std::{collections::HashMap, time::Duration};
 use fctrl::schema::{InternalServerState, ServerStatus};
 use futures::{pin_mut, StreamExt};
 use log::{error, info, warn};
-use serenity::all::CreateCommand;
+use serenity::all::{Builder, CreateCommand, CreateWebhook, ExecuteWebhook};
 use serenity::gateway::ActivityData;
 use serenity::{
     client::{Cache, Context, EventHandler},
@@ -68,17 +68,48 @@ impl DiscordClient {
 
         if let Some(chat_link_channel_id) = chat_link_channel_id {
             let bot_token_clone = bot_token.clone();
+            // regular string type mpsc for non webhook messages
             let (chat_link_tx, mut rx) = mpsc::unbounded_channel();
+            // for webhook messages we need extra data for "nickname impersonation"
+            let (webhook_msg_tx, mut webhook_rx) = mpsc::unbounded_channel();
+
+            let http = Arc::new(Http::new(&bot_token_clone));
+            let channel = ChannelId::new(chat_link_channel_id);
+
+            // we use a webhook to allow custom display nickname of sent messages
+            // create if not exist
+            let existing_webhooks = channel.webhooks(&http).await?;
+            let webhook = if let Some(w) = existing_webhooks.into_iter().find(|w| w.name.as_ref().is_some_and(|n| n == "fctrl_chat_link_g2d")) {
+                w
+            } else {
+                let create_webhook = CreateWebhook::new("fctrl_chat_link_g2d");
+                create_webhook.execute(&http, channel).await?
+            };
+
+            // regular non webhook message handler
+            let http_clone = Arc::clone(&http);
             tokio::spawn(async move {
-                let http = Http::new(&bot_token_clone);
-                let channel = ChannelId::new(chat_link_channel_id);
                 while let Some(line) = rx.recv().await {
-                    if let Err(e) = channel.say(&http, line).await {
+                    if let Err(e) = channel.say(&http_clone, line).await {
                         error!("Couldn't send message to Discord: {:?}", e);
                     }
                 }
             });
-            DiscordClient::create_chat_link_g2d_subscriber(chat_link_tx.clone(), event_broker)
+
+            // webhook message handler
+            let http_clone = Arc::clone(&http);
+            tokio::spawn(async move {
+                while let Some((name, line)) = webhook_rx.recv().await {
+                    let content = ExecuteWebhook::new()
+                        .username(name)
+                        .content(line);
+                    if let Err(e) = webhook.execute(&http_clone, false, content).await {
+                        error!("Couldn't send message to Discord: {:?}", e);
+                    }
+                }
+            });
+
+            DiscordClient::create_chat_link_g2d_subscriber(chat_link_tx.clone(), webhook_msg_tx, event_broker)
                 .await;
         }
 
@@ -189,9 +220,10 @@ impl DiscordClient {
 
     async fn create_chat_link_g2d_subscriber(
         send_msg_tx: mpsc::UnboundedSender<String>,
+        webhook_msg_tx: mpsc::UnboundedSender<(String, String)>,
         event_broker: Arc<EventBroker>,
     ) {
-        let chat_tx = send_msg_tx.clone();
+        let chat_tx = webhook_msg_tx;
         let join_tx = send_msg_tx.clone();
         let leave_tx = send_msg_tx.clone();
         let statechange_tx = send_msg_tx;
@@ -202,10 +234,18 @@ impl DiscordClient {
         tokio::spawn(async move {
             pin_mut!(chat_sub);
             while let Some(event) = chat_sub.next().await {
-                let message = event.tags.get(&TopicName::new(CHAT_TOPIC_NAME)).unwrap();
-                if let Err(e) = chat_tx.send(message.clone()) {
-                    error!("Error sending line through mpsc channel: {:?}", e);
-                    break;
+                let line = event.tags.get(&TopicName::new(CHAT_TOPIC_NAME)).unwrap();
+                // assume names cannot have colon
+                match line.split_once(": ") {
+                    Some((nick, message)) => {
+                        if let Err(e) = chat_tx.send((nick.to_string(), message.to_string())) {
+                            error!("Error sending line through mpsc channel: {:?}", e);
+                            break;
+                        }
+                    },
+                    None => {
+                        warn!("Failed to parse nick and message out of incoming chat link g2d line: {}", line);
+                    }
                 }
             }
 
@@ -290,7 +330,6 @@ impl DiscordClient {
         });
     }
 
-
 }
 
 fn parse_serverstate_topic_value(states_str: impl AsRef<str>) -> Option<(InternalServerState, InternalServerState)> {

src/mgmt-server/discord.rs

@@ -125,7 +125,7 @@ impl WebSocketServer {
                     let outgoing_tx_clone = outgoing_tx.clone();
                     pin_mut!(stream);
                     let forward_fut = stream.for_each(|e| {
-                        let msg = Message::Text(e.content);
+                        let msg = Message::Text(e.content.into());
                         let _ = outgoing_tx_clone.send(msg);
                         future::ready(())
                     });

src/mgmt-server/ws.rs

@@ -71,7 +71,7 @@ where
             }
             Some(req) => {
                 if ws_write
-                    .send(Message::Text(serde_json::to_string(&req).unwrap()))
+                    .send(Message::Text(serde_json::to_string(&req).unwrap().into()))
                     .await
                     .is_err()
                 {