⭐ feat: Migrate from WebSocket to libp2p for peer-to-peer connectivity (#286)

## Description
Whew, some stuff is still not re-implemented, but it's working!

Rabbit's gonna explode with the amount of changes I reckon 😅



<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Introduced a peer-to-peer relay system using libp2p with enhanced
stream forwarding, room state synchronization, and mDNS peer discovery.
- Added decentralized room and participant management, metrics
publishing, and safe, size-limited, concurrent message streaming with
robust framing and callback dispatching.
- Implemented asynchronous, callback-driven message handling over custom
libp2p streams replacing WebSocket signaling.
- **Improvements**
- Migrated signaling and stream protocols from WebSocket to libp2p,
improving reliability and scalability.
- Simplified configuration and environment variables, removing
deprecated flags and adding persistent data support.
- Enhanced logging, error handling, and connection management for better
observability and robustness.
- Refined RTP header extension registration and NAT IP handling for
improved WebRTC performance.
- **Bug Fixes**
- Improved ICE candidate buffering and SDP negotiation in WebRTC
connections.
  - Fixed NAT IP and UDP port range configuration issues.
- **Refactor**
- Modularized codebase, reorganized relay and server logic, and removed
deprecated WebSocket-based components.
- Streamlined message structures, removed obsolete enums and message
types, and simplified SafeMap concurrency.
- Replaced WebSocket signaling with libp2p stream protocols in server
and relay components.
- **Chores**
- Updated and cleaned dependencies across Go, Rust, and JavaScript
packages.
  - Added `.gitignore` for persistent data directory in relay package.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: DatCaptainHorse <DatCaptainHorse@users.noreply.github.com>
Co-authored-by: Philipp Neumann <3daquawolf@gmail.com>

packages/relay/internal/connections/messages.go

@@ -1,18 +1,32 @@
 package connections
 
 import (
-	"github.com/pion/webrtc/v4"
+	"encoding/json"
 	"relay/internal/common"
-	"time"
+
+	"github.com/pion/webrtc/v4"
 )
 
-// MessageBase is the base type for WS/DC messages.
+// MessageBase is the base type for any JSON message
 type MessageBase struct {
-	PayloadType string                 `json:"payload_type"`
-	Latency     *common.LatencyTracker `json:"latency,omitempty"`
+	Type    string                 `json:"payload_type"`
+	Latency *common.LatencyTracker `json:"latency,omitempty"`
+}
+
+type MessageRaw struct {
+	MessageBase
+	Data json.RawMessage `json:"data"`
+}
+
+func NewMessageRaw(t string, data json.RawMessage) *MessageRaw {
+	return &MessageRaw{
+		MessageBase: MessageBase{
+			Type: t,
+		},
+		Data: data,
+	}
 }
 
-// MessageLog represents a log message.
 type MessageLog struct {
 	MessageBase
 	Level   string `json:"level"`
@@ -20,7 +34,17 @@ type MessageLog struct {
 	Time    string `json:"time"`
 }
 
-// MessageMetrics represents a metrics/heartbeat message.
+func NewMessageLog(t string, level, message, time string) *MessageLog {
+	return &MessageLog{
+		MessageBase: MessageBase{
+			Type: t,
+		},
+		Level:   level,
+		Message: message,
+		Time:    time,
+	}
+}
+
 type MessageMetrics struct {
 	MessageBase
 	UsageCPU        float64 `json:"usage_cpu"`
@@ -29,104 +53,42 @@ type MessageMetrics struct {
 	PipelineLatency float64 `json:"pipeline_latency"`
 }
 
-// MessageICECandidate represents an ICE candidate message.
-type MessageICECandidate struct {
-	MessageBase
-	Candidate webrtc.ICECandidateInit `json:"candidate"`
-}
-
-// MessageSDP represents an SDP message.
-type MessageSDP struct {
-	MessageBase
-	SDP webrtc.SessionDescription `json:"sdp"`
-}
-
-// JoinerType is an enum for the type of incoming room joiner
-type JoinerType int
-
-const (
-	JoinerNode JoinerType = iota
-	JoinerClient
-)
-
-func (jt *JoinerType) String() string {
-	switch *jt {
-	case JoinerNode:
-		return "node"
-	case JoinerClient:
-		return "client"
-	default:
-		return "unknown"
-	}
-}
-
-// MessageJoin is used to tell us that either participant or ingest wants to join the room
-type MessageJoin struct {
-	MessageBase
-	JoinerType JoinerType `json:"joiner_type"`
-}
-
-// AnswerType is an enum for the type of answer, signaling Room state for a joiner
-type AnswerType int
-
-const (
-	AnswerOffline AnswerType = iota // For participant/client, when the room is offline without stream
-	AnswerInUse                     // For ingest/node joiner, when the room is already in use by another ingest/node
-	AnswerOK                        // For both, when the join request is handled successfully
-)
-
-// MessageAnswer is used to send the answer to a join request
-type MessageAnswer struct {
-	MessageBase
-	AnswerType AnswerType `json:"answer_type"`
-}
-
-// SendLogMessageWS sends a log message to the given WebSocket connection.
-func (ws *SafeWebSocket) SendLogMessageWS(level, message string) error {
-	msg := MessageLog{
-		MessageBase: MessageBase{PayloadType: "log"},
-		Level:       level,
-		Message:     message,
-		Time:        time.Now().Format(time.RFC3339),
-	}
-	return ws.SendJSON(msg)
-}
-
-// SendMetricsMessageWS sends a metrics message to the given WebSocket connection.
-func (ws *SafeWebSocket) SendMetricsMessageWS(usageCPU, usageMemory float64, uptime uint64, pipelineLatency float64) error {
-	msg := MessageMetrics{
-		MessageBase:     MessageBase{PayloadType: "metrics"},
+func NewMessageMetrics(t string, usageCPU, usageMemory float64, uptime uint64, pipelineLatency float64) *MessageMetrics {
+	return &MessageMetrics{
+		MessageBase: MessageBase{
+			Type: t,
+		},
 		UsageCPU:        usageCPU,
 		UsageMemory:     usageMemory,
 		Uptime:          uptime,
 		PipelineLatency: pipelineLatency,
 	}
-	return ws.SendJSON(msg)
 }
 
-// SendICECandidateMessageWS sends an ICE candidate message to the given WebSocket connection.
-func (ws *SafeWebSocket) SendICECandidateMessageWS(candidate webrtc.ICECandidateInit) error {
-	msg := MessageICECandidate{
-		MessageBase: MessageBase{PayloadType: "ice"},
-		Candidate:   candidate,
-	}
-	return ws.SendJSON(msg)
+type MessageICE struct {
+	MessageBase
+	Candidate webrtc.ICECandidateInit `json:"candidate"`
 }
 
-// SendSDPMessageWS sends an SDP message to the given WebSocket connection.
-func (ws *SafeWebSocket) SendSDPMessageWS(sdp webrtc.SessionDescription) error {
-	msg := MessageSDP{
-		MessageBase: MessageBase{PayloadType: "sdp"},
-		SDP:         sdp,
+func NewMessageICE(t string, candidate webrtc.ICECandidateInit) *MessageICE {
+	return &MessageICE{
+		MessageBase: MessageBase{
+			Type: t,
+		},
+		Candidate: candidate,
 	}
-	return ws.SendJSON(msg)
 }
 
-// SendAnswerMessageWS sends an answer message to the given WebSocket connection.
-func (ws *SafeWebSocket) SendAnswerMessageWS(answer AnswerType) error {
-	msg := MessageAnswer{
-		MessageBase: MessageBase{PayloadType: "answer"},
-		AnswerType:  answer,
-	}
-	return ws.SendJSON(msg)
+type MessageSDP struct {
+	MessageBase
+	SDP webrtc.SessionDescription `json:"sdp"`
+}
+
+func NewMessageSDP(t string, sdp webrtc.SessionDescription) *MessageSDP {
+	return &MessageSDP{
+		MessageBase: MessageBase{
+			Type: t,
+		},
+		SDP: sdp,
+	}
 }