fix(codebase): Changed git URL in updator to reflect new git name

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

.gitignore

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

Cargo.toml

@@ -1,9 +1,21 @@
 [package]
 name = "RhythmWorks"
-version = "0.3.0"
+version = "0.7.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-appender-log = "0.27.0"
+opentelemetry-appender-tracing = "0.27.0"
+opentelemetry-otlp = { version = "0.27.0", features = ["trace", "metrics", "grpc-tonic", "http-proto", "tls", "reqwest-client", "reqwest-rustls", "logs"] }
+opentelemetry-proto = "0.27.0"
+opentelemetry-semantic-conventions = "0.27.0"
+opentelemetry_sdk = { version = "0.27.0", features = ["logs", "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"
@@ -12,6 +24,11 @@ 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"
+tracing-subscriber = "0.3.20"
 yt-dlp = "1.4.7"
 
 

build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+cargo clean
+cargo fmt
+cargo clippy --fix --all-targets --allow-dirty
+cargo build --release
+cargo build --release --target x86_64-pc-windows-gnu

changelog.md

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

src/main.rs

@@ -1,18 +1,76 @@
+use dialoguer::Select;
+use dialoguer::theme::ColorfulTheme;
 use modules::*;
+use opentelemetry::KeyValue;
+use opentelemetry::global;
+use opentelemetry::trace::Status;
+use opentelemetry::trace::TraceContextExt;
+use opentelemetry::trace::Tracer;
 use serenity::all::ChannelId;
 use serenity::async_trait;
 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 tracing::instrument;
+use std::env;
 use std::process::Command;
 use std::process::Stdio;
-pub mod modules;
+use tokio::task::JoinHandle;
+use tokio_util::sync::CancellationToken;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::Layer;
+use tracing_subscriber::filter::Targets;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
 
+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?;
@@ -32,13 +90,51 @@ impl EventHandler for Handler {
             println!("Error sending message: {why:?}");
         }
         if msg.content == "!join" {
+            let tracer = global::tracer("RhythmWorks");
+            let span = tracer.start("Join Message Received");
+            let cx = opentelemetry::Context::current_with_span(span);
             let guild_id = match msg.guild_id {
-                Some(g) => g,
-                None => return,
-            };
-            let channel_id = match get_user_voice_channel(&ctx, &msg) {
-                Some(c) => c,
+                Some(g) => {
+                    tracing::info!("Received Guild ID");
+                    cx.span().add_event(
+                        "Received Guild ID",
+                        vec![KeyValue::new("Server ID", g.to_string())],
+                    );
+                    cx.span().set_status(opentelemetry::trace::Status::Ok);
+                    cx.span()
+                        .set_attribute(KeyValue::new("Guild_ID", g.to_string()));
+                    g
+                }
                 None => {
+                    cx.span().add_event(
+                        "Failed to Retreive Guild ID",
+                        vec![KeyValue::new("Server ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error("Failed"));
+                    return;
+                }
+            };
+
+            let channel_id = match get_user_voice_channel(&ctx, &msg) {
+                Some(c) => {
+                    cx.span().add_event(
+                        "Received Channel ID",
+                        vec![KeyValue::new("Channel ID", c.to_string())],
+                    );
+                    cx.span().set_status(Status::Ok);
+                    c
+                }
+                None => {
+                    cx.span().add_event(
+                        "Failed to Retreive Channel ID",
+                        vec![KeyValue::new("Channel ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error(format!(
+                            "{} not in Voice Channel",
+                            msg.author
+                        )));
                     let _ = msg
                         .channel_id
                         .say(&ctx.http, "You must be in a voice channel")
@@ -46,7 +142,6 @@ impl EventHandler for Handler {
                     return;
                 }
             };
-
             let manager = get(&ctx).await.expect("Songbird not initialized").clone();
 
             let _ = manager.join(guild_id, channel_id).await;
@@ -55,6 +150,11 @@ impl EventHandler for Handler {
                 .channel_id
                 .say(&ctx.http, "Joined your voice channel!")
                 .await;
+            cx.span().add_event(
+                "Joined Voice Channel",
+                vec![KeyValue::new("Voice Channel", msg.channel_id.to_string())],
+            );
+            cx.span().set_status(Status::Ok);
         }
         if msg.content == "!leave" {
             let guild_id = match msg.guild_id {
@@ -71,6 +171,8 @@ impl EventHandler for Handler {
             }
         }
         if msg.content.starts_with("!play") {
+            let tracer = global::tracer("RhythmWorks");
+            let span = tracer.start("Play Message Received");
             let mut yt_url = msg
                 .content
                 .strip_prefix("!play ")
@@ -84,7 +186,30 @@ impl EventHandler for Handler {
                 let _ = msg.reply(&ctx, "Please provide a YouTube URL.").await;
                 return;
             }
-            let guild_id = msg.guild_id.unwrap();
+            let cx = opentelemetry::Context::current_with_span(span);
+            cx.span()
+                .set_attribute(KeyValue::new("Youtube_URL", yt_url.to_string()));
+            let guild_id = match msg.guild_id {
+                Some(g) => {
+                    cx.span().add_event(
+                        "Received Guild ID",
+                        vec![KeyValue::new("Server ID", g.to_string())],
+                    );
+                    cx.span().set_status(opentelemetry::trace::Status::Ok);
+                    cx.span()
+                        .set_attribute(KeyValue::new("Guild_ID", g.to_string()));
+                    g
+                }
+                None => {
+                    cx.span().add_event(
+                        "Failed to Retreive Guild ID",
+                        vec![KeyValue::new("Server ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error("Failed"));
+                    return;
+                }
+            };
             let manager = songbird::get(&ctx).await.unwrap().clone();
             let handler_lock = if let Some(call) = manager.get(guild_id) {
                 call
@@ -92,35 +217,100 @@ impl EventHandler for Handler {
                 let channel_id = match get_user_voice_channel(&ctx, &msg) {
                     Some(c) => c,
                     None => {
-                        let _ = msg.reply(&ctx, "Join a voice channel first!").await;
+                        cx.span().add_event(
+                            "Failed to Retreive Channel ID",
+                            vec![KeyValue::new("Channel ID", "None")],
+                        );
+                        cx.span()
+                            .set_status(opentelemetry::trace::Status::error(format!(
+                                "{} not in Voice Channel",
+                                msg.author
+                            )));
+                        let _ = msg
+                            .channel_id
+                            .say(&ctx.http, "You must be in a voice channel")
+                            .await;
                         return;
                     }
                 };
                 manager.join(guild_id, channel_id).await.unwrap()
             };
-            let output = Command::new("./yt-dlp")
-                .args(["-f", "bestaudio", "-g", &yt_url])
+            let output = match Command::new("./yt-dlp")
+                .args(["-f", "bestaudio", "-g", "--no-playlist", &yt_url])
                 .stdout(Stdio::piped())
                 .output()
-                .expect("yt-dlp failed");
-            if !output.status.success() {
-                let _ = msg.reply(&ctx, "Failed to fetch audio stream.").await;
+            {
+                Ok(output) => {
+                    cx.span().add_event(
+                        "Retreiving Youtube Information",
+                        vec![KeyValue::new("Success", yt_url.to_string())],
+                    );
+                    output
+                }
+                Err(e) => {
+                    cx.span().add_event(
+                        "Retreiving Youtube Information",
+                        vec![KeyValue::new("Failed", e.to_string())],
+                    );
+                    cx.span().set_status(Status::error("Failed"));
+                    eprintln!("{}", e);
                     return;
                 }
+            };
             let stream_url = String::from_utf8(output.stdout)
                 .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())],
+                );
                 "🎶 Now playing!".to_string()
             } else {
+                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 {
@@ -172,6 +362,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() {
@@ -180,24 +394,80 @@ async fn main() {
 This program comes with ABSOLUTELY NO WARRANTY\n
 This is free software, and you are welcome to redistribute it under certain conditions."
     );
-    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 (tracer_provider, logger_provider) = telemetry::init_telemetry();
+    global::set_tracer_provider(tracer_provider.clone());
+    let filter = Targets::new()
+        .with_target("RhythmWorks", LevelFilter::INFO)
+        .with_default(LevelFilter::OFF);
+    let otel_log_layer =
+        opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge::new(&logger_provider)
+            .with_filter(filter);
+    tracing_subscriber::registry().with(otel_log_layer).init();
+    let tracer: global::BoxedTracer = global::tracer("tracer");
+    tracer
+        .in_span("Checking for Updates", |_cx| updator::update())
+        .await;
+    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 +1,3 @@
+pub mod credentialmanager;
+pub mod telemetry;
 pub mod updator;

src/modules/telemetry.rs

@@ -0,0 +1,44 @@
+use opentelemetry::KeyValue;
+use opentelemetry::global;
+use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
+use opentelemetry_sdk::{Resource, logs, runtime};
+use tonic::transport::{Channel, ClientTlsConfig};
+
+pub fn init_telemetry() -> (
+    opentelemetry_sdk::trace::TracerProvider,
+    opentelemetry_sdk::logs::LoggerProvider,
+) {
+    let endpoint = "https://signoz.racooncity.org".to_string();
+    let channel = Channel::from_shared(endpoint.clone())
+        .unwrap()
+        .tls_config(ClientTlsConfig::new().with_native_roots())
+        .unwrap()
+        .connect_lazy();
+    let exporter = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .with_endpoint(endpoint.clone())
+        .with_channel(channel.clone())
+        .build()
+        .expect("Failed to Build Exporter");
+    let log_exporter = opentelemetry_otlp::LogExporter::builder()
+        .with_tonic()
+        .with_endpoint(endpoint.clone())
+        .with_channel(channel.clone())
+        .build()
+        .expect("Failed to build log exporter");
+    let logger_provider = logs::LoggerProvider::builder()
+        .with_resource(Resource::new(vec![KeyValue::new(
+            "service.name",
+            "RhythmWorks",
+        )]))
+        .with_batch_exporter(log_exporter, runtime::Tokio)
+        .build();
+    let tracer_provider = opentelemetry_sdk::trace::TracerProvider::builder()
+        .with_batch_exporter(exporter, runtime::Tokio)
+        .with_resource(Resource::new(vec![KeyValue::new(
+            "service.name",
+            "RhythmWorks",
+        )]))
+        .build();
+    (tracer_provider, logger_provider)
+}

src/modules/updator.rs

@@ -10,7 +10,7 @@ struct Release {
 
 pub async fn update() {
     let body = reqwest::get(
-        "https://git.racooncity.org/api/v1/repos/brotoskyj/RhythmWorks/releases/latest",
+        "https://git.racooncity.org/api/v1/repos/mysticmomba/RhythmWorks/releases/latest",
     )
     .await
     .unwrap()
@@ -22,9 +22,8 @@ pub async fn update() {
     let current_version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
     if latest_version > current_version {
         println!("Update Available! Please download the latest version");
-        println!("URL: https://git.racooncity.org/brotoskyj/RhythmWorks/releases");
+        println!("URL: https://git.racooncity.org/mysticmomba/RhythmWorks/releases");
         thread::sleep(std::time::Duration::from_secs(10));
         std::process::exit(1);
-    } else {
     }
 }