feat(UI/Codebase): Made menu persistent. After starting the bot, the menu will remain on the screen and be interactable for the user while the bot is running

Added a Token Credential Manager - Closes #4
Added TUI Menu - Closes #2

.gitignore

@@ -1 +1,2 @@
 /target
+cliff.toml

Cargo.toml

@@ -1,14 +1,19 @@
 [package]
 name = "RhythmWorks"
-version = "0.4.0"
+version = "0.6.0"
 edition = "2024"
 
 [dependencies]
+color-eyre = "0.6.5"
+crossterm = "0.29.0"
+dialoguer = "0.12.0"
+keyring = { version = "3.6.3", features = ["linux-native", "windows-native"] }
 opentelemetry = { version = "0.27.0", features = ["logs", "metrics", "trace"] }
 opentelemetry-otlp = { version = "0.27.0", features = ["trace", "metrics", "grpc-tonic", "http-proto", "tls", "reqwest-client", "reqwest-rustls"] }
 opentelemetry-proto = "0.27.0"
 opentelemetry-semantic-conventions = "0.27.0"
 opentelemetry_sdk = { version = "0.27.0", features = ["rt-tokio", "trace"] }
+ratatui = { version = "0.30.0", features = ["all-widgets"] }
 reqwest = { version = "0.12.28", features = ["blocking", "json"] }
 semver = "1.0.27"
 serde = "1.0.228"
@@ -17,6 +22,7 @@ serenity = { version = "0.12.5", features = ["client", "gateway", "voice"] }
 songbird = { version = "0.5.0", features = ["builtin-queue", "driver", "serenity"] }
 symphonia = { version = "0.5.5", features = ["aac", "alac", "isomp4", "mp3"] }
 tokio = "1.48.0"
+tokio-util = "0.7.18"
 tonic = { version = "0.12.3", features = ["tls-roots"] }
 tracing = "0.1.41"
 tracing-opentelemetry = "0.32.0"

changelog.md

@@ -0,0 +1 @@
+## [0.5.2] - 2026-01-21

src/main.rs

@@ -1,26 +1,70 @@
+use dialoguer::Select;
+use dialoguer::theme::ColorfulTheme;
 use modules::*;
 use opentelemetry::KeyValue;
 use opentelemetry::global;
-use opentelemetry::global::ObjectSafeSpan;
-use opentelemetry::trace::SpanKind;
 use opentelemetry::trace::Status;
 use opentelemetry::trace::TraceContextExt;
 use opentelemetry::trace::Tracer;
 use serenity::all::ChannelId;
 use serenity::async_trait;
-use serenity::futures::channel::oneshot::channel;
 use serenity::model::channel::Message;
 use serenity::model::gateway::Ready;
 use serenity::prelude::*;
+use songbird::Event;
+use songbird::EventContext;
 use songbird::SerenityInit;
+use songbird::events::EventHandler as VoiceEventHandler;
 use songbird::get;
 use songbird::input::HlsRequest;
 use songbird::input::Input;
-use std::io;
+use std::env;
 use std::process::Command;
 use std::process::Stdio;
-pub mod modules;
+use tokio::task::JoinHandle;
+use tokio_util::sync::CancellationToken;
 
+pub mod modules;
+enum BotState {
+    Stopped,
+    Running,
+}
+struct TrackTraceHandler {
+    otel_ctx: opentelemetry::Context,
+    guild_id: String,
+    track_url: String,
+    hls_url: String,
+    event_name: &'static str,
+}
+
+#[async_trait]
+impl VoiceEventHandler for TrackTraceHandler {
+    async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
+        let tracer = global::tracer("RhythmWorks");
+        let track_status = if let EventContext::Track(track_list) = ctx {
+            track_list.first().map(|state| format!("{:?}", state.0))
+        } else {
+            None
+        };
+        tracer.in_span(self.event_name, |cx| {
+            cx.span()
+                .set_attribute(KeyValue::new("Guild_ID", self.guild_id.clone()));
+            cx.span()
+                .set_attribute(KeyValue::new("Youtube_URL", self.track_url.clone()));
+            cx.span()
+                .set_attribute(KeyValue::new("Stream_URL", self.hls_url.clone()));
+            cx.span().add_event(
+                self.event_name,
+                vec![KeyValue::new(
+                    "track_status",
+                    track_status.unwrap().to_string(),
+                )],
+            );
+        });
+
+        None
+    }
+}
 struct Handler;
 fn get_user_voice_channel(ctx: &Context, msg: &Message) -> Option<ChannelId> {
     let guild_id = msg.guild_id?;
@@ -82,7 +126,7 @@ impl EventHandler for Handler {
                     cx.span()
                         .set_status(opentelemetry::trace::Status::error(format!(
                             "{} not in Voice Channel",
-                            msg.author.to_string()
+                            msg.author
                         )));
                     let _ = msg
                         .channel_id
@@ -173,7 +217,7 @@ impl EventHandler for Handler {
                         cx.span()
                             .set_status(opentelemetry::trace::Status::error(format!(
                                 "{} not in Voice Channel",
-                                msg.author.to_string()
+                                msg.author
                             )));
                         let _ = msg
                             .channel_id
@@ -185,7 +229,7 @@ impl EventHandler for Handler {
                 manager.join(guild_id, channel_id).await.unwrap()
             };
             let output = match Command::new("./yt-dlp")
-                .args(["-f", "bestaudio", "-g", &yt_url])
+                .args(["-f", "bestaudio", "-g", "--no-playlist", &yt_url])
                 .stdout(Stdio::piped())
                 .output()
             {
@@ -210,18 +254,56 @@ impl EventHandler for Handler {
                 .expect("Invalid UTF-8")
                 .trim()
                 .to_string();
+            let telemetry_stream_url = stream_url.clone();
             let mut call = handler_lock.lock().await;
             let input = Input::from(HlsRequest::new(reqwest::Client::new(), stream_url));
-            let _ = call.enqueue_input(input).await;
+            let track_handle = call.enqueue_input(input).await;
+            let otel_ctx = opentelemetry::Context::current();
             let position = call.queue().len();
             let response = if position == 1 {
-                cx.span().add_event("Starting Playback", vec![KeyValue::new("Status", "Playing".to_string())]);
+                cx.span().add_event(
+                    "Starting Playback",
+                    vec![KeyValue::new("Status", "Playing".to_string())],
+                );
                 "🎶 Now playing!".to_string()
             } else {
-                cx.span().add_event("Starting Playback", vec![KeyValue::new("Status", "Added to Queue".to_string())]);
+                cx.span().add_event(
+                    "Starting Playback",
+                    vec![KeyValue::new("Status", "Added to Queue".to_string())],
+                );
                 format!("🎶 Added Song to Queue: #{}", position)
             };
             let _ = msg.channel_id.say(&ctx.http, response).await;
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::Play),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Track Started Playing",
+                },
+            );
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::End),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Track Finished",
+                },
+            );
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::Error),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Playback had an error",
+                },
+            );
         }
         if msg.content == "!skip" {
             let guild_id = match msg.guild_id {
@@ -273,6 +355,30 @@ impl EventHandler for Handler {
         println!("{} is connected!", ready.user.name);
     }
 }
+async fn run_bot(token: String, shutdown: CancellationToken) {
+    let intents = GatewayIntents::GUILD_MESSAGES
+        | GatewayIntents::GUILDS
+        | GatewayIntents::DIRECT_MESSAGES
+        | GatewayIntents::MESSAGE_CONTENT
+        | GatewayIntents::GUILD_VOICE_STATES;
+
+    let mut client = Client::builder(&token, intents)
+        .event_handler(Handler)
+        .register_songbird()
+        .await
+        .expect("Err creating client");
+
+    tokio::select! {
+        result = client.start() => {
+            if let Err(why) = result {
+                println!("Client error: {why:?}");
+            }
+        }
+        _ = shutdown.cancelled() => {
+            println!("Shutting down bot...");
+        }
+    }
+}
 
 #[tokio::main]
 async fn main() {
@@ -285,25 +391,69 @@ This is free software, and you are welcome to redistribute it under certain cond
     global::set_tracer_provider(tracer_provider.clone());
     let tracer: global::BoxedTracer = global::tracer("tracer");
     tracer
-        .in_span("Checking for Updates", |cx| updator::update())
+        .in_span("Checking for Updates", |_cx| updator::update())
         .await;
-    println!("Please paste in your bot token");
-    let mut input = String::new();
-    io::stdin()
-        .read_line(&mut input)
-        .expect("Failed to read line");
-    let token = input.trim();
-    let intents = GatewayIntents::GUILD_MESSAGES
-        | GatewayIntents::GUILDS
-        | GatewayIntents::DIRECT_MESSAGES
-        | GatewayIntents::MESSAGE_CONTENT
-        | GatewayIntents::GUILD_VOICE_STATES;
-    let mut client = Client::builder(&token, intents)
-        .event_handler(Handler)
-        .register_songbird()
-        .await
-        .expect("Err creating client");
-    if let Err(why) = client.start().await {
-        println!("Client error: {why:?}");
+    let service_name = "RhythmWorks";
+    let username = env::var("USER").or_else(|_| env::var("USERNAME")).unwrap();
+    let mut bot_task: Option<JoinHandle<()>> = None;
+    let mut shutdown_token: Option<CancellationToken> = None;
+    let mut bot_state = BotState::Stopped;
+    loop {
+        let token = credentialmanager::get_token(service_name, &username);
+        let options: Vec<&'static str> = vec![
+            "- Start Bot",
+            "- Stop Bot",
+            "- Change Token",
+            "- Delete Token",
+            "- Exit",
+        ];
+        let selection = Select::with_theme(&ColorfulTheme::default())
+            .with_prompt("Choose an Option")
+            .default(0)
+            .items(&options)
+            .interact()
+            .unwrap();
+        match selection {
+            0 => {
+                if matches!(bot_state, BotState::Running) {
+                    println!("[x] Bot is already running.");
+                    continue;
+                }
+
+                let token = credentialmanager::get_token(service_name, &username);
+                let shutdown = CancellationToken::new();
+                let shutdown_clone = shutdown.clone();
+
+                let task = tokio::spawn(run_bot(token, shutdown_clone));
+
+                bot_task = Some(task);
+                shutdown_token = Some(shutdown);
+                bot_state = BotState::Running;
+
+                println!("✅ Bot started.");
+            }
+            1 => {
+                if let Some(token) = shutdown_token.take() {
+                    token.cancel();
+                }
+                if let Some(task) = bot_task.take() {
+                    let _ = task.await;
+                }
+                println!("Bot stopped.");
+            }
+            2 => {
+                credentialmanager::change_token(service_name, &username);
+            }
+            3 => {
+                credentialmanager::remove_token(service_name, &username);
+            }
+            4 => {
+                if let Some(token) = shutdown_token {
+                    token.cancel();
+                }
+                break;
+            }
+            _ => println!("Invalid Option"),
+        }
     }
 }

src/modules/credentialmanager.rs

@@ -0,0 +1,37 @@
+use dialoguer::{Input, theme::ColorfulTheme};
+use keyring::Entry;
+
+pub fn get_token<'a>(service: &str, username: &str) -> String {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    match entry.get_password() {
+        Ok(token) => token,
+        Err(_) => {
+            let token: String = Input::with_theme(&ColorfulTheme::default())
+                .with_prompt("Enter your bot token")
+                .interact_text()
+                .unwrap();
+            match entry.set_password(&token) {
+                Ok(_) => {}
+                Err(e) => {
+                    println!("Failed to set token: {}", e);
+                    std::process::abort()
+                }
+            };
+            token
+        }
+    }
+}
+
+pub fn change_token(service: &str, username: &str) {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    let new_token: String = Input::with_theme(&ColorfulTheme::default())
+        .with_prompt("New Token")
+        .interact_text()
+        .unwrap();
+    let _ = entry.set_password(&new_token);
+}
+
+pub fn remove_token(service: &str, username: &str) {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    let _ = entry.delete_credential();
+}

src/modules/mod.rs

@@ -1,2 +1,3 @@
+pub mod credentialmanager;
+pub mod telemetry;
 pub mod updator;
-pub mod telemetry;

src/modules/updator.rs

@@ -25,6 +25,5 @@ pub async fn update() {
         println!("URL: https://git.racooncity.org/brotoskyj/RhythmWorks/releases");
         thread::sleep(std::time::Duration::from_secs(10));
         std::process::exit(1);
-    } else {
     }
 }