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

tests/engine_io_tests.rs

@@ -0,0 +1,158 @@
+use imks::engine::codec;
+use imks::engine::packet::{HandshakeData, Packet, PacketData, PacketType};
+
+#[test]
+fn test_engine_io_handshake_encoding() {
+    let handshake = HandshakeData {
+        sid: "lv_VI97HAXpY6yYWAAAC".to_string(),
+        upgrades: vec!["websocket".to_string()],
+        ping_interval: 25000,
+        ping_timeout: 20000,
+        max_payload: 1000000,
+    };
+
+    let packet = Packet::open(&handshake);
+    let encoded = codec::encode_packet(&packet);
+
+    assert!(encoded.starts_with('0'));
+    assert!(encoded.contains("\"sid\":\"lv_VI97HAXpY6yYWAAAC\""));
+    assert!(encoded.contains("\"upgrades\":[\"websocket\"]"));
+    assert!(encoded.contains("\"pingInterval\":25000"));
+    assert!(encoded.contains("\"pingTimeout\":20000"));
+    assert!(encoded.contains("\"maxPayload\":1000000"));
+}
+
+#[test]
+fn test_engine_io_packet_types() {
+    let open = Packet::open(&HandshakeData {
+        sid: "test".to_string(),
+        upgrades: vec![],
+        ping_interval: 25000,
+        ping_timeout: 20000,
+        max_payload: 1000000,
+    });
+    assert_eq!(open.packet_type, PacketType::Open);
+
+    let close = Packet::close();
+    assert_eq!(close.packet_type, PacketType::Close);
+
+    let ping = Packet::ping("test");
+    assert_eq!(ping.packet_type, PacketType::Ping);
+
+    let pong = Packet::pong("test");
+    assert_eq!(pong.packet_type, PacketType::Pong);
+
+    let msg = Packet::message_text("hello");
+    assert_eq!(msg.packet_type, PacketType::Message);
+
+    let upgrade = Packet::upgrade();
+    assert_eq!(upgrade.packet_type, PacketType::Upgrade);
+
+    let noop = Packet::noop();
+    assert_eq!(noop.packet_type, PacketType::Noop);
+}
+
+#[test]
+fn test_engine_io_polling_payload() {
+    let packets = vec![
+        Packet::message_text("hello"),
+        Packet::ping(""),
+        Packet::message_text("world"),
+    ];
+
+    let encoded = codec::encode_payload(&packets);
+    assert_eq!(encoded, "4hello\x1e2\x1e4world");
+
+    let decoded = codec::decode_payload(&encoded).unwrap();
+    assert_eq!(decoded.len(), 3);
+    assert_eq!(decoded[0].packet_type, PacketType::Message);
+    assert_eq!(decoded[1].packet_type, PacketType::Ping);
+    assert_eq!(decoded[2].packet_type, PacketType::Message);
+}
+
+#[test]
+fn test_engine_io_binary_encoding() {
+    let packet = Packet::message_binary(vec![0x01, 0x02, 0x03, 0x04]);
+    let encoded = codec::encode_packet(&packet);
+    assert_eq!(encoded, "4bAQIDBA==");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Message);
+    assert_eq!(decoded.data, PacketData::Binary(vec![0x01, 0x02, 0x03, 0x04]));
+}
+
+#[test]
+fn test_engine_io_webtransport_header_encoding() {
+    let header = codec::encode_webtransport_header(6, false);
+    assert_eq!(header, vec![0x06]);
+
+    let header = codec::encode_webtransport_header(200, true);
+    assert_eq!(header.len(), 3);
+    assert_eq!(header[0], 0x80 | 126);
+
+    let header = codec::encode_webtransport_header(70000, false);
+    assert_eq!(header.len(), 9);
+    assert_eq!(header[0], 127);
+}
+
+#[test]
+fn test_engine_io_webtransport_header_decoding() {
+    let header = vec![0x06];
+    let (len, is_binary) = codec::decode_webtransport_header(&header).unwrap();
+    assert_eq!(len, 6);
+    assert!(!is_binary);
+
+    let header = vec![0x80 | 126, 0x00, 0xC8];
+    let (len, is_binary) = codec::decode_webtransport_header(&header).unwrap();
+    assert_eq!(len, 200);
+    assert!(is_binary);
+}
+
+#[test]
+fn test_engine_io_probe_ping_pong() {
+    let ping = Packet::ping("probe");
+    let encoded = codec::encode_packet(&ping);
+    assert_eq!(encoded, "2probe");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Ping);
+    assert_eq!(decoded.data, PacketData::Text("probe".to_string()));
+
+    let pong = Packet::pong("probe");
+    let encoded = codec::encode_packet(&pong);
+    assert_eq!(encoded, "3probe");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Pong);
+    assert_eq!(decoded.data, PacketData::Text("probe".to_string()));
+}
+
+#[test]
+fn test_engine_io_upgrade_packet() {
+    let upgrade = Packet::upgrade();
+    let encoded = codec::encode_packet(&upgrade);
+    assert_eq!(encoded, "5");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Upgrade);
+}
+
+#[test]
+fn test_engine_io_noop_packet() {
+    let noop = Packet::noop();
+    let encoded = codec::encode_packet(&noop);
+    assert_eq!(encoded, "6");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Noop);
+}
+
+#[test]
+fn test_engine_io_close_packet() {
+    let close = Packet::close();
+    let encoded = codec::encode_packet(&close);
+    assert_eq!(encoded, "1");
+
+    let decoded = codec::decode_packet(&encoded).unwrap();
+    assert_eq!(decoded.packet_type, PacketType::Close);
+}