Implement chat bridge

Author: Earthcomputer

src/discord_bot/mod.rs

@@ -15,8 +15,10 @@ mod update_copy;
 
 use crate::config;
 use crate::discord_bot::guild_storage::GuildStorage;
+use crate::pterodactyl::{send_command_safe, PterodactylServer};
 use async_trait::async_trait;
 use log::{error, info, warn};
+use serde::Serialize;
 use serenity::builder::{
     CreateCommand, CreateInteractionResponse, CreateInteractionResponseMessage, CreateMessage,
     EditInteractionResponse,
@@ -115,6 +117,47 @@ async fn process_command(
     Ok(())
 }
 
+async fn process_chatbridge(
+    ctx: Context,
+    pterodactyl: &pterodactyl_api::client::Client,
+    chatbridge_server: &PterodactylServer,
+    new_message: &Message,
+) -> Result<(), crate::Error> {
+    let ptero_server = pterodactyl.get_server(&chatbridge_server.id);
+
+    #[derive(Serialize)]
+    struct TextComponent {
+        text: String,
+    }
+
+    let sanitized_message = new_message.content_safe(&ctx);
+    if !sanitized_message.is_empty() {
+        let text_component = TextComponent {
+            text: format!("[{}] {}", new_message.author.name, sanitized_message),
+        };
+        let text_component = serde_json::to_string(&text_component)?;
+        send_command_safe(&ptero_server, format!("tellraw @a {}", text_component)).await?;
+    }
+
+    if !new_message.attachments.is_empty() {
+        let attachment_message = if new_message.attachments.len() == 1 {
+            "an attachment"
+        } else {
+            "multiple attachments"
+        };
+        let text_component = TextComponent {
+            text: format!(
+                "{} posted {} in Discord.",
+                new_message.author.name, attachment_message
+            ),
+        };
+        let text_component = serde_json::to_string(&text_component)?;
+        send_command_safe(&ptero_server, format!("tellraw @a {}", text_component)).await?;
+    }
+
+    Ok(())
+}
+
 #[async_trait]
 impl EventHandler for Handler {
     async fn guild_member_addition(&self, ctx: Context, new_member: Member) {
@@ -167,20 +210,33 @@ impl EventHandler for Handler {
             Some(guild_id) => guild_id,
             None => return,
         };
+        let pterodactyl = self.pterodactyl.clone();
 
         tokio::runtime::Handle::current().spawn(async move {
             enum MessageHandling<'a> {
+                ChatBridge(&'a PterodactylServer),
                 Command(&'a str),
                 IncCounter(&'a str),
                 PermanentLatest,
                 SimpleWords,
             }
 
+            let config = config::get();
+
             let message_handling = {
-                if config::get().simple_words_channel == Some(new_message.channel_id) {
+                if config.simple_words_channel == Some(new_message.channel_id) {
                     MessageHandling::SimpleWords
                 } else if new_message.author.bot {
                     return;
+                } else if let Some(chatbridge_server) =
+                    config.pterodactyl_servers.iter().find(|server| {
+                        server
+                            .bridge
+                            .as_ref()
+                            .is_some_and(|bridge| bridge.discord_channel == new_message.channel_id)
+                    })
+                {
+                    MessageHandling::ChatBridge(chatbridge_server)
                 } else {
                     let storage = GuildStorage::get(guild_id).await;
                     if storage
@@ -207,6 +263,9 @@ impl EventHandler for Handler {
             };
 
             if let Err(err) = match message_handling {
+                MessageHandling::ChatBridge(chatbridge_server) => {
+                    process_chatbridge(ctx, &pterodactyl, chatbridge_server, &new_message).await
+                }
                 MessageHandling::Command(command) => {
                     commands::run(command, guild_id, ctx, &new_message).await
                 }

src/pterodactyl/mod.rs

@@ -1,4 +1,6 @@
+use pterodactyl_api::client::ServerState;
 use serde::Deserialize;
+use serenity::model::id::ChannelId;
 use std::collections::BTreeMap;
 
 pub mod perms_sync;
@@ -10,6 +12,8 @@ pub struct PterodactylServer {
     pub id: String,
     pub name: String,
     pub category: PterodactylServerCategory,
+    #[serde(default)]
+    pub bridge: Option<PterodactylChatBridge>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize)]
@@ -90,3 +94,21 @@ impl PterodactylPerms {
         }
     }
 }
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct PterodactylChatBridge {
+    pub discord_channel: ChannelId,
+    pub webhook: String,
+}
+
+pub async fn send_command_safe(
+    server: &pterodactyl_api::client::Server<'_>,
+    command: impl Into<String>,
+) -> Result<(), crate::Error> {
+    if let Err(err) = server.send_command(command).await {
+        if server.get_resources().await?.current_state == ServerState::Running {
+            return Err(err.into());
+        }
+    }
+    Ok(())
+}

src/pterodactyl/smp_commands.rs

@@ -9,6 +9,8 @@ use nom::sequence::tuple;
 use nom::Finish;
 use pterodactyl_api::client::backups::{Backup, BackupParams};
 use pterodactyl_api::client::websocket::{PteroWebSocketHandle, PteroWebSocketListener};
+use serenity::builder::ExecuteWebhook;
+use serenity::model::webhook::Webhook;
 
 pub(crate) async fn create_backup(
     server: &pterodactyl_api::client::Server<'_>,
@@ -50,7 +52,9 @@ pub(crate) async fn create_backup(
 
 async fn handle_chat_message<H: PteroWebSocketHandle>(
     handle: &mut H,
-    server: &pterodactyl_api::client::Server<'_>,
+    data: &ProtobotData,
+    chat_bridge_webhook: Option<&Webhook>,
+    ptero_server: &pterodactyl_api::client::Server<'_>,
     sender: &str,
     message: &str,
 ) -> Result<(), crate::Error> {
@@ -88,7 +92,7 @@ async fn handle_chat_message<H: PteroWebSocketHandle>(
             }
             "backup" => {
                 create_backup(
-                    server,
+                    ptero_server,
                     if args.len() > 1 {
                         Some(args[1..].join(" "))
                     } else {
@@ -104,14 +108,27 @@ async fn handle_chat_message<H: PteroWebSocketHandle>(
             }
             _ => {}
         }
+    } else if let Some(chat_bridge_webhook) = chat_bridge_webhook {
+        chat_bridge_webhook
+            .execute(
+                &data.discord_handle,
+                false,
+                ExecuteWebhook::new()
+                    .content(message)
+                    .username(sender)
+                    .avatar_url(format!("https://visage.surgeplay.com/face/256/{sender}")),
+            )
+            .await?;
     }
 
     Ok(())
 }
 
 async fn handle_server_log<H: PteroWebSocketHandle>(
     handle: &mut H,
-    server: &pterodactyl_api::client::Server<'_>,
+    data: &ProtobotData,
+    chat_bridge_webhook: Option<&Webhook>,
+    ptero_server: &pterodactyl_api::client::Server<'_>,
     message: &str,
 ) -> Result<(), crate::Error> {
     let parse_result: Result<(&str, (&str, &str)), nom::error::Error<&str>> = map(
@@ -133,15 +150,24 @@ async fn handle_server_log<H: PteroWebSocketHandle>(
     )(message)
     .finish();
     if let Ok((_, (sender, message))) = parse_result {
-        handle_chat_message(handle, server, sender, message).await?;
+        handle_chat_message(
+            handle,
+            data,
+            chat_bridge_webhook,
+            ptero_server,
+            sender,
+            message,
+        )
+        .await?;
     }
 
     Ok(())
 }
 
 struct WebsocketListener<'a> {
+    data: ProtobotData,
     ptero_server: pterodactyl_api::client::Server<'a>,
-    server: PterodactylServer,
+    chat_bridge_webhook: Option<Webhook>,
 }
 
 impl<H: PteroWebSocketHandle> PteroWebSocketListener<H> for WebsocketListener<'_> {
@@ -150,7 +176,15 @@ impl<H: PteroWebSocketHandle> PteroWebSocketListener<H> for WebsocketListener<'_
         handle: &mut H,
         output: &str,
     ) -> pterodactyl_api::Result<()> {
-        if let Err(err) = handle_server_log(handle, &self.ptero_server, output).await {
+        if let Err(err) = handle_server_log(
+            handle,
+            &self.data,
+            self.chat_bridge_webhook.as_ref(),
+            &self.ptero_server,
+            output,
+        )
+        .await
+        {
             error!("Error handling console output: {}", err);
         }
         Ok(())
@@ -159,12 +193,21 @@ impl<H: PteroWebSocketHandle> PteroWebSocketListener<H> for WebsocketListener<'_
 
 pub(crate) async fn run(server: PterodactylServer, data: ProtobotData) -> Result<(), crate::Error> {
     info!("Starting websocket for server {}", server.name);
+    let chat_bridge_webhook = match &server.bridge {
+        Some(bridge) => Some(Webhook::from_url(&data.discord_handle, &bridge.webhook).await?),
+        None => None,
+    };
+    let listener = WebsocketListener {
+        data: data.clone(),
+        ptero_server: data.pterodactyl.get_server(&server.id),
+        chat_bridge_webhook,
+    };
     let ptero_server = data.pterodactyl.get_server(&server.id);
     tokio::select! {
         _ = crate::wait_shutdown() => {}
         result = ptero_server.run_websocket_loop(|url| async {
             Ok(async_tungstenite::tokio::connect_async(url).await?.0)
-        }, WebsocketListener { ptero_server: data.pterodactyl.get_server(&server.id), server }) => {
+        }, listener) => {
             result?;
         }
     }

src/pterodactyl/whitelist.rs

@@ -1,9 +1,8 @@
-use crate::pterodactyl::PterodactylServerCategory;
+use crate::pterodactyl::{send_command_safe, PterodactylServerCategory};
 use crate::{config, ProtobotData};
 use futures::future::try_join_all;
 use git_version::git_version;
 use log::{error, info};
-use pterodactyl_api::client::ServerState;
 use serde::de::value::StrDeserializer;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeSet;
@@ -257,11 +256,7 @@ async fn set_whitelist(
             ptero_server
                 .write_file("whitelist.json", whitelist_json)
                 .await?;
-            if let Err(err) = ptero_server.send_command("whitelist reload").await {
-                if ptero_server.get_resources().await?.current_state == ServerState::Running {
-                    return Err(err.into());
-                }
-            }
+            send_command_safe(&ptero_server, "whitelist reload").await?;
             info!("{}", message);
             Ok::<(), crate::Error>(())
         }
@@ -282,11 +277,7 @@ async fn run_command(
         let message = message(&server.name);
         async move {
             let ptero_server = data.pterodactyl.get_server(&server.id);
-            if let Err(err) = ptero_server.send_command(command).await {
-                if ptero_server.get_resources().await?.current_state == ServerState::Running {
-                    return Err(err.into());
-                }
-            }
+            send_command_safe(&ptero_server, command).await?;
             info!("{}", message);
             Ok::<(), crate::Error>(())
         }