fix: wip awful voice chat please god someone save me I feel my bones they're melting oh gOD HELP ME

Author: ChecksumDev

Cargo.lock

@@ -23,3 +23,9 @@ reqwest = { version = "0.12.9", features = ["json"] }
 fastrand = "2.3.0"
 lru = "0.12.5"
 serde_json = "1.0"
+songbird = { version = "0.4", features = ["receive", "gateway"] }
+dashmap = "6.1.0"
+
+[dependencies.symphonia]
+version = "0.5.2"
+features = ["wav", "mp3"]

Cargo.toml

@@ -2,14 +2,17 @@ use crate::database::Database;
 use crate::modules::{
     lorax::database::LoraxDatabase, modrinth::database::ModrinthDatabase,
     stats::database::StatsDatabase, testing::database::TestingDatabase,
+    recording::database::RecordingDatabase,
 };
+use std::fs;
 
 #[derive(Debug)]
 pub struct Databases {
     pub lorax: Database<LoraxDatabase>,
     pub stats: Database<StatsDatabase>,
     pub testing: Database<TestingDatabase>,
     pub modrinth: Database<ModrinthDatabase>,
+    pub recording: Database<RecordingDatabase>,
 }
 
 impl Default for Databases {
@@ -20,11 +23,15 @@ impl Default for Databases {
 
 impl Databases {
     pub async fn default() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
+        // Create data directory if it doesn't exist
+        fs::create_dir_all("data")?;
+        
         Ok(Self {
             lorax: Database::new("data/lorax.db").await?,
             stats: Database::new("data/stats.db").await?,
             testing: Database::new("data/testing.db").await?,
-            modrinth: Database::new("modrinth.json").await?,
+            modrinth: Database::new("data/modrinth.json").await?,
+            recording: Database::new("data/recording.json").await?,
         })
     }
 }

extra/recording-start.mp3

@@ -2,7 +2,9 @@ use async_trait::async_trait;
 use futures::stream::{FuturesUnordered, StreamExt};
 use poise::serenity_prelude::{Context, FullEvent};
 use std::fmt::Debug;
+use std::sync::Arc;
 use tokio::sync::Mutex;
+use crate::{Data, modules::recording::handler::RecordingHandler};
 
 #[async_trait]
 pub trait EventHandler: Send + Sync + Debug {
@@ -33,6 +35,11 @@ impl EventManager {
         }
     }
 
+    pub async fn init(&self, data: &Arc<Data>) {
+        let mut handlers = self.handlers.lock().await;
+        handlers.push(Box::new(RecordingHandler::new(data.dbs.recording.clone())));
+    }
+
     pub async fn add_handler(&self, handler: impl EventHandler + 'static) {
         self.handlers.lock().await.push(Box::new(handler));
     }

extra/recording-voice.wav

@@ -3,12 +3,13 @@ use databases::Databases;
 use modules::{
     lorax::{commands::lorax, task::LoraxEventTask},
     modrinth::modrinth,
+    recording::recording,
     stats::{stats, task::StatsTask},
-    system::events::ReadyHandler,
     testing::{task::TestingTask, testing},
     utils::server_costs,
 };
 use poise::serenity_prelude::{self as serenity, CreateAllowedMentions};
+use songbird::SerenityInit;
 use std::sync::Arc;
 use tasks::TaskManager;
 use tracing::{error, info, trace};
@@ -80,12 +81,20 @@ async fn main() {
     info!("starting prometheus");
 
     let token = std::env::var("DISCORD_TOKEN").expect("missing DISCORD_TOKEN");
-    let intents = serenity::GatewayIntents::non_privileged();
+    let intents = serenity::GatewayIntents::all();
 
     let framework = poise::Framework::builder()
         .options(poise::FrameworkOptions::<Data, Error> {
             allowed_mentions: Some(CreateAllowedMentions::new().empty_roles().empty_users()),
-            commands: vec![register(), lorax(), stats(), testing(), modrinth(), server_costs()],
+            commands: vec![
+                register(),
+                lorax(),
+                stats(),
+                testing(),
+                modrinth(),
+                server_costs(),
+                recording(),
+            ],
             pre_command: |ctx| {
                 Box::pin(async move {
                     trace!(
@@ -143,23 +152,27 @@ async fn main() {
                 let event_manager = Arc::new(events::EventManager::new());
                 let master_key = std::env::var("MASTER_KEY").expect("missing MASTER_KEY");
 
-                event_manager.add_handler(ReadyHandler).await;
-
-                let data = Data {
-                    dbs,
-                    task_manager,
-                    event_manager,
+                let data = Arc::new(Data {
+                    dbs: dbs.clone(),
+                    task_manager: task_manager.clone(),
+                    event_manager: event_manager.clone(),
                     config: Config { master_key },
-                };
+                });
+
+                event_manager.init(&data).await;
                 data.init_tasks(ctx).await;
 
-                Ok(data)
+                Ok((*data).clone())
             })
         })
         .build();
 
+    let songbird = songbird::Songbird::serenity();
+    songbird.set_config(songbird::Config::default().decode_mode(songbird::driver::DecodeMode::Decode));
+
     let client = serenity::ClientBuilder::new(token, intents)
         .framework(framework)
+        .register_songbird_with(songbird)
         .await;
 
     client.unwrap().start().await.unwrap();

src/databases.rs

@@ -17,7 +17,7 @@ pub async fn config(_ctx: Context<'_>) -> Result<(), Error> {
 }
 
 /// Set the announcement channel
-#[command(slash_command, guild_only)]
+#[command(slash_command, guild_only, required_permissions = "MANAGE_GUILD")]
 pub async fn channel(
     ctx: Context<'_>,
     #[description = "Channel for Lorax announcements"] channel: serenity::Channel,
@@ -85,7 +85,7 @@ pub async fn channel(
 }
 
 /// Configure role settings
-#[command(slash_command, guild_only)]
+#[command(slash_command, guild_only, required_permissions = "MANAGE_GUILD")]
 pub async fn roles(
     ctx: Context<'_>,
     #[description = "Role to mention for events"] event_role: Option<serenity::Role>,
@@ -157,7 +157,7 @@ pub async fn roles(
 }
 
 /// Set event phase durations
-#[command(slash_command, guild_only)]
+#[command(slash_command, guild_only, required_permissions = "MANAGE_GUILD")]
 pub async fn durations(
     ctx: Context<'_>,
     #[description = "Minutes for submissions"] submission: Option<u64>,
@@ -205,7 +205,7 @@ pub async fn durations(
 }
 
 /// View current Lorax settings
-#[command(slash_command, guild_only)]
+#[command(slash_command, guild_only, required_permissions = "MANAGE_GUILD")]
 pub async fn view(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap().get();
 

src/events.rs

@@ -1,5 +1,6 @@
 pub mod lorax;
 pub mod modrinth;
+pub mod recording;  // Add this
 pub mod stats;
 pub mod system;
 pub mod testing;

src/main.rs

@@ -0,0 +1,162 @@
+use crate::Context;
+use poise::command;
+use poise::serenity_prelude::{ChannelId, ChannelType};
+use super::database::RecordingChannel;
+
+/// Enable voice channel recording
+#[command(slash_command, guild_only)]
+pub async fn enable(
+    ctx: Context<'_>,
+    #[description = "Voice channel to record"] voice_channel: ChannelId,
+) -> Result<(), crate::Error> {
+    let guild_id = ctx.guild_id().unwrap();
+    
+    // Verify channel is voice channel
+    let voice_channel_info = voice_channel.to_channel(&ctx).await?;
+    
+    if voice_channel_info.guild().map(|c| c.kind) != Some(ChannelType::Voice) {
+        ctx.say("The specified channel must be a voice channel!").await?;
+        return Ok(());
+    }
+    
+    // Get database
+    let db = &ctx.data().dbs.recording;
+    
+    // Check if guild already has a recording channel
+    if db.read(|data| {
+        data.channels.contains_key(&guild_id.get())
+    }).await {
+        ctx.say("This guild already has a recording channel set up! Use `/recording disable` first.").await?;
+        return Ok(());
+    }
+    
+    // Add recording channel 
+    db.transaction(|data| {
+        data.channels.insert(
+            guild_id.get(),
+            RecordingChannel {
+                guild_id: guild_id.get(),
+                voice_channel_id: voice_channel.get(),
+                is_recording: false,
+                last_activity: None,
+            },
+        );
+        Ok(())
+    })
+    .await?;
+    
+    ctx.say("Voice channel recording enabled!").await?;
+    Ok(())
+}
+
+/// Disable voice channel recording
+#[command(slash_command, guild_only)]
+pub async fn disable(
+    ctx: Context<'_>,
+) -> Result<(), crate::Error> {
+    let guild_id = ctx.guild_id().unwrap();
+    let db = &ctx.data().dbs.recording;
+    
+    db.transaction(|data| {
+        if data.channels.remove(&guild_id.get()).is_some() {
+            Ok(())
+        } else {
+            Err("No recording channel configured for this guild.".into())
+        }
+    })
+    .await?;
+    
+    ctx.say("Voice channel recording disabled!").await?;
+    Ok(())
+}
+
+/// List recording channels
+#[command(slash_command, guild_only)]
+pub async fn list(ctx: Context<'_>) -> Result<(), crate::Error> {
+    let guild_id = ctx.guild_id().unwrap();
+    let db = &ctx.data().dbs.recording;
+    
+    let channel = db.read(|data| {
+        data.channels.get(&guild_id.get()).cloned()
+    }).await;
+    
+    match channel {
+        Some(channel) => {
+            let voice_name = ChannelId::new(channel.voice_channel_id)
+                .to_channel(&ctx)
+                .await?
+                .guild()
+                .map(|c| c.name().to_string())
+                .unwrap_or_else(|| "Unknown".to_string());
+                
+            ctx.say(format!(
+                "Recording configuration:\nVoice Channel: {}\nCurrently Recording: {}\nLast Activity: {}",
+                voice_name,
+                if channel.is_recording { "Yes" } else { "No" },
+                channel.last_activity.map(|t| t.to_rfc3339()).unwrap_or_else(|| "Never".to_string())
+            )).await?;
+        }
+        None => {
+            ctx.say("No recording channel configured for this guild.").await?;
+        }
+    }
+    
+    Ok(())
+}
+
+/// Toggle voice recording for a channel
+#[command(slash_command, guild_only)]
+pub async fn toggle(
+    ctx: Context<'_>,
+    #[description = "Voice channel to record (leave empty to disable)"] voice_channel: Option<ChannelId>,
+) -> Result<(), crate::Error> {
+    let guild_id = ctx.guild_id().unwrap();
+    let db = &ctx.data().dbs.recording;
+
+    match voice_channel {
+        Some(channel) => {
+            // Verify channel is voice channel
+            let channel_info = channel.to_channel(&ctx).await?;
+            
+            // Check channel type first
+            if channel_info.clone().guild().map(|c| c.kind) != Some(ChannelType::Voice) {
+                ctx.say("The specified channel must be a voice channel!").await?;
+                return Ok(());
+            }
+
+            // Update or create recording configuration
+            db.transaction(|data| {
+                data.channels.insert(
+                    guild_id.get(),
+                    RecordingChannel {
+                        guild_id: guild_id.get(),
+                        voice_channel_id: channel.get(),
+                        is_recording: false,
+                        last_activity: None,
+                    },
+                );
+                Ok(())
+            })
+            .await?;
+
+            let channel_name = channel_info.guild().map(|c| c.name().to_string())
+                .unwrap_or_else(|| "Unknown".to_string());
+            ctx.say(format!("Voice recording configured for channel: {}", channel_name)).await?;
+        }
+        None => {
+            // Disable recording if it exists
+            db.transaction(|data| {
+                if data.channels.remove(&guild_id.get()).is_some() {
+                    Ok(())
+                } else {
+                    Err("No recording channel was configured for this guild.".into())
+                }
+            })
+            .await?;
+            
+            ctx.say("Voice recording disabled!").await?;
+        }
+    }
+    
+    Ok(())
+}