feat(auth): add authentication protocol definitions and build configuration

- Add TokenClaims message for JWT payload structure with user id, issuer, timestamps, and scopes
- Implement IssueTokenRequest/Response for creating access and refresh tokens with TTL support
- Create RefreshTokenRequest/Response for token rotation functionality
- Define RevokeTokenRequest/Response with support for single token or user-wide revocation
- Add VerifyTokenRequest/Response for validating JWT tokens with detailed claims information
- Implement signing key distribution system with GetSigningKeysRequest/Response
- Create TokenService gRPC service with IssueToken, RefreshToken, RevokeToken, VerifyToken, and GetSigningKeys methods
- Add build.rs configuration to compile proto files using tonic_prost_build
- Include channel, channel_settings, member, and permission protocol definitions for IM services
- Generate Rust code bindings through pb/core.rs and pb/im.rs modules

socket/message_bus/redis.rs

@@ -0,0 +1,99 @@
+use async_trait::async_trait;
+use fred::clients::{Client, SubscriberClient};
+use fred::interfaces::{ClientLike, EventInterface, PubsubInterface};
+use fred::prelude::*;
+use tokio::sync::mpsc;
+
+use crate::socket::message_bus::{MessageBus, MessageBusError};
+
+pub struct RedisMessageBus {
+    client: Client,
+    subscriber: SubscriberClient,
+}
+
+impl RedisMessageBus {
+    pub async fn new(redis_url: &str) -> Result<Self, MessageBusError> {
+        let config = Config::from_url(redis_url)
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+
+        let client = Client::new(config.clone(), None, None, None);
+        let subscriber = SubscriberClient::new(config, None, None, None);
+
+        // connect() starts the connection task; result is checked by wait_for_connect()
+        let _ = client.connect().await;
+        let _ = subscriber.connect().await;
+
+        client
+            .wait_for_connect()
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+        subscriber
+            .wait_for_connect()
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+
+        Ok(Self { client, subscriber })
+    }
+
+    pub fn client(&self) -> &Client {
+        &self.client
+    }
+}
+
+#[async_trait]
+impl MessageBus for RedisMessageBus {
+    async fn publish(&self, channel: &str, message: &[u8]) -> Result<(), MessageBusError> {
+        self.client
+            .publish::<(), _, Vec<u8>>(channel, message.to_vec())
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn subscribe(&self, channel: &str) -> Result<mpsc::Receiver<Vec<u8>>, MessageBusError> {
+        let (tx, rx) = mpsc::channel::<Vec<u8>>(256);
+
+        self.subscriber
+            .subscribe(channel.to_string())
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+
+        let subscriber = self.subscriber.clone();
+        let channel_owned = channel.to_string();
+        let mut message_rx = subscriber.message_rx();
+
+        tokio::spawn(async move {
+            while let Ok(message) = message_rx.recv().await {
+                if &message.channel == &channel_owned {
+                    let data: Vec<u8> = FromValue::from_value(message.value)
+                        .unwrap_or_default();
+                    if tx.send(data).await.is_err() {
+                        break;
+                    }
+                }
+            }
+        });
+
+        Ok(rx)
+    }
+
+    async fn unsubscribe(&self, channel: &str) -> Result<(), MessageBusError> {
+        self.subscriber
+            .unsubscribe(channel.to_string())
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn close(&self) -> Result<(), MessageBusError> {
+        self.client
+            .quit()
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+        self.subscriber
+            .quit()
+            .await
+            .map_err(|e| MessageBusError::Redis(e.to_string()))?;
+        Ok(())
+    }
+}