Spaces:

BeBank
/

DappMeetingV3

Build error

App Files Files Community

Luisnguyen1 commited on Feb 24, 2025

Commit

c77381d

1 Parent(s): 3feb9c4

sua track

Browse files

Files changed (8) hide show

.env +2 -2
.env.example +15 -0
basic.html +522 -0
go.mod +22 -18
go.sum +43 -37
index.js +7 -0
main.go +769 -864
public/js/room.js +2 -0

.env CHANGED Viewed

@@ -3,8 +3,8 @@ DEBUG=false
 DEBUG=true
 NODE_ENV='development'
-CLOUDFLARE_APP_ID='b0ec9f519563a78aacb031048bd9bb2b'
-CLOUDFLARE_APP_SECRET='e5aa7484fe2ddf300e69e0e66dd3dd06d8628a5764ac8c237f63f7762d5db234'
 CLOUDFLARE_TURN_ID='4f88cf5ab3d61f069a9c7fe38502ddef'
 CLOUDFLARE_TURN_TOKEN='5a8acf5e87457eea45222ec73195fb560704cbfe949928946694f05b7c76f5f3'

 DEBUG=true
 NODE_ENV='development'
+CLOUDFLARE_APP_ID='d8f5af0fe38ea134ebd03e7bf0a8ae14'
+CLOUDFLARE_APP_SECRET='3d9031d1c83112f68636517a1b4c765161bf0b7667fe9a665b528f760b1f4f28'
 CLOUDFLARE_TURN_ID='4f88cf5ab3d61f069a9c7fe38502ddef'
 CLOUDFLARE_TURN_TOKEN='5a8acf5e87457eea45222ec73195fb560704cbfe949928946694f05b7c76f5f3'

.env.example ADDED Viewed

	@@ -0,0 +1,15 @@

+# Cloudflare Calls Configuration
+CLOUDFLARE_APP_ID=your_app_id
+CLOUDFLARE_APP_SECRET=your_app_secret
+CLOUDFLARE_TURN_ID=your_turn_id
+CLOUDFLARE_TURN_TOKEN=your_turn_token
+CLOUDFLARE_APPS_URL=https://rtc.live.cloudflare.com/v1/apps
+# Server Configuration
+PORT=50000
+GIN_MODE=debug
+JWT_SECRET=your_jwt_secret
+# Feature Flags
+AUTH_REQUIRED=false
+DEBUG=true

basic.html ADDED Viewed

	@@ -0,0 +1,522 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Simple Video Call</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/webrtc-adapter/8.1.2/adapter.min.js"></script>
+</head>
+<body>
+    <div class="container">
+        <h1>Video Call</h1>
+        <div class="video-grid">
+            <div>
+                <h2>Local Video</h2>
+                <video id="localVideo" autoplay muted playsinline></video>
+            </div>
+            <div>
+                <h2>Remote Video</h2>
+                <video id="remoteVideo" autoplay playsinline></video>
+            </div>
+        </div>
+        <div class="controls">
+            <button id="startButton">Start Call</button>
+            <input id="sessionInput" placeholder="Enter session ID to join">
+            <button id="joinButton">Join Call</button>
+            <button id="endButton">End Call</button>
+            <div>
+                <label for="sessionId">Session ID:</label>
+                <input id="sessionId" readonly>
+                <button id="copyButton">Copy</button>
+            </div>
+        </div>
+    </div>
+    <script>
+        const APP_ID = "d8f5af0fe38ea134ebd03e7bf0a8ae14"; // Thay thế bằng APP_ID của bạn
+        const APP_TOKEN = "3d9031d1c83112f68636517a1b4c765161bf0b7667fe9a665b528f760b1f4f28"; // Thay thế bằng APP_TOKEN của bạn
+        const API_BASE = `https://rtc.live.cloudflare.com/v1/apps/${APP_ID}`;
+        let localStream;
+        let localPeerConnection;
+        let localSessionId;
+        let remoteSessionId = null; // Thêm biến để lưu session id của người tham gia
+        const localVideo = document.getElementById('localVideo');
+        const remoteVideo = document.getElementById('remoteVideo');
+        const startButton = document.getElementById('startButton');
+        const endButton = document.getElementById('endButton');
+        const sessionInput = document.getElementById('sessionInput');
+        const joinButton = document.getElementById('joinButton');
+        const sessionIdInput = document.getElementById('sessionId');
+        const copyButton = document.getElementById('copyButton');
+        startButton.onclick = startCall;
+        endButton.onclick = endCall;
+        joinButton.onclick = joinCall;
+        copyButton.onclick = () => {
+            sessionIdInput.select();
+            document.execCommand('copy');
+            alert('Session ID copied to clipboard');
+        };
+        async function createSession() {
+            const response = await fetch(`${API_BASE}/sessions/new`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${APP_TOKEN}`,
+                    "Content-Type": "application/json"
+                }
+            }).then(res => res.json());
+            if (response.errorCode) {
+                throw new Error(response.errorDescription);
+            }
+            return response.sessionId;
+        }
+        async function createPeerConnection() {
+            const peerConnection = new RTCPeerConnection({
+                iceServers: [{
+                    urls: "stun:stun.cloudflare.com:3478"
+                }],
+                bundlePolicy: "max-bundle"
+            });
+            // Add ICE candidate handling
+            peerConnection.onicecandidate = (event) => {
+                if (event.candidate) {
+                    console.log("New ICE candidate:", event.candidate);
+                }
+            };
+            // Add connection state handling
+            peerConnection.onconnectionstatechange = (event) => {
+                console.log("Connection state:", peerConnection.connectionState);
+            };
+            // Add track handling
+            peerConnection.ontrack = (event) => {
+                console.log("Received remote track:", event);
+                if (remoteVideo.srcObject !== event.streams[0]) {
+                    remoteVideo.srcObject = event.streams[0];
+                }
+            };
+            return peerConnection;
+        }
+        async function startCall() {
+            try {
+                // Get local media stream
+                localStream = await navigator.mediaDevices.getUserMedia({
+                    audio: true,
+                    video: true
+                });
+                localVideo.srcObject = localStream;
+                // Create new session
+                localSessionId = await createSession();
+                localPeerConnection = await createPeerConnection();
+                // Add tracks using addTransceiver API like in demo.html
+                const transceivers = localStream.getTracks().map(track =>
+                    localPeerConnection.addTransceiver(track, {
+                        direction: "sendonly"
+                    })
+                );
+                // Create and set local offer
+                const offer = await localPeerConnection.createOffer();
+                await localPeerConnection.setLocalDescription(offer);
+                // Format request according to API schema
+                const requestBody = {
+                    sessionDescription: {
+                        sdp: offer.sdp,
+                        type: "offer"
+                    },
+                    tracks: transceivers.map(({mid, sender}) => ({
+                        location: "local",
+                        mid: mid,
+                        trackName: sender.track?.id
+                    }))
+                };
+                // Set up ICE connection state handler
+                const connected = new Promise((resolve, reject) => {
+                    setTimeout(() => reject(new Error("ICE connection timeout")), 5000);
+                    const iceConnectionStateChangeHandler = () => {
+                        if (localPeerConnection.iceConnectionState === "connected") {
+                            localPeerConnection.removeEventListener(
+                                "iceconnectionstatechange",
+                                iceConnectionStateChangeHandler
+                            );
+                            resolve();
+                        }
+                    };
+                    localPeerConnection.addEventListener(
+                        "iceconnectionstatechange",
+                        iceConnectionStateChangeHandler
+                    );
+                });
+                // Send tracks to API
+                const response = await fetch(`${API_BASE}/sessions/${localSessionId}/tracks/new`, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${APP_TOKEN}`,
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify(requestBody)
+                });
+                if (!response.ok) {
+                    throw new Error(`API error: ${response.status}`);
+                }
+                const responseData = await response.json();
+                // Set remote description from response
+                await localPeerConnection.setRemoteDescription(
+                    new RTCSessionDescription(responseData.sessionDescription)
+                );
+                // Wait for ICE connection
+                await connected;
+                // Update UI
+                sessionIdInput.value = localSessionId;
+                startSessionCheck(localSessionId);
+            } catch (err) {
+                console.error("Error starting call:", err);
+                alert("Error starting call: " + err.message);
+            }
+        }
+        async function joinCall() {
+            try {
+                const sessionToJoin = sessionInput.value.trim();
+                if (!sessionToJoin) {
+                    alert('Please enter a session ID');
+                    return;
+                }
+                // Get session state first
+                const sessionState = await fetch(`${API_BASE}/sessions/${sessionToJoin}`, {
+                    headers: {
+                        "Authorization": `Bearer ${APP_TOKEN}`
+                    }
+                }).then(res => res.json());
+                console.log("Session state:", sessionState);
+                if (!sessionState.tracks || sessionState.tracks.length === 0) {
+                    throw new Error("No active tracks in session");
+                }
+                // Initialize local resources
+                localStream = await navigator.mediaDevices.getUserMedia({
+                    audio: true,
+                    video: true
+                });
+                localVideo.srcObject = localStream;
+                localPeerConnection = await createPeerConnection();
+                localSessionId = await createSession();
+                // First add our local tracks
+                const localTransceivers = localStream.getTracks().map(track =>
+                    localPeerConnection.addTransceiver(track, {
+                        direction: "sendonly"
+                    })
+                );
+                // Create and set local offer for our tracks
+                const localOffer = await localPeerConnection.createOffer();
+                await localPeerConnection.setLocalDescription(localOffer);
+                // Send our tracks first
+                const addLocalTracksResponse = await fetch(`${API_BASE}/sessions/${localSessionId}/tracks/new`, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${APP_TOKEN}`,
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({
+                        sessionDescription: {
+                            sdp: localOffer.sdp,
+                            type: "offer"
+                        },
+                        tracks: localTransceivers.map(({mid, sender}) => ({
+                            location: "local",
+                            mid: mid,
+                            trackName: sender.track?.id
+                        }))
+                    })
+                }).then(res => res.json());
+                // Handle local tracks response
+                await localPeerConnection.setRemoteDescription(
+                    new RTCSessionDescription(addLocalTracksResponse.sessionDescription)
+                );
+                // Now pull the remote tracks
+                const pullRequest = {
+                    tracks: sessionState.tracks
+                        .filter(track => track.status === 'active')
+                        .map(track => ({
+                            location: "remote",
+                            sessionId: sessionToJoin,
+                            trackName: track.trackName
+                        }))
+                };
+                // Set up track handling for remote tracks
+                const resolvingTracks = new Promise((resolve, reject) => {
+                    let receivedTracks = [];
+                    const timeout = setTimeout(() => reject(new Error("Track timeout")), 10000);
+                    const handleTrack = (event) => {
+                        console.log("Received track:", event.track);
+                        receivedTracks.push(event.track);
+                        if (receivedTracks.length === pullRequest.tracks.length) {
+                            clearTimeout(timeout);
+                            localPeerConnection.removeEventListener('track', handleTrack);
+                            resolve(receivedTracks);
+                        }
+                    };
+                    localPeerConnection.addEventListener('track', handleTrack);
+                });
+                // Pull remote tracks
+                const pullResponse = await fetch(`${API_BASE}/sessions/${localSessionId}/tracks/new`, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${APP_TOKEN}`,
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify(pullRequest)
+                }).then(res => res.json());
+                // Handle remote tracks
+                if (pullResponse.requiresImmediateRenegotiation) {
+                    await localPeerConnection.setRemoteDescription(
+                        new RTCSessionDescription(pullResponse.sessionDescription)
+                    );
+                    const answer = await localPeerConnection.createAnswer();
+                    await localPeerConnection.setLocalDescription(answer);
+                    await fetch(`${API_BASE}/sessions/${localSessionId}/renegotiate`, {
+                        method: "PUT",
+                        headers: {
+                            "Authorization": `Bearer ${APP_TOKEN}`,
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({
+                            sessionDescription: {
+                                sdp: answer.sdp,
+                                type: "answer"
+                            }
+                        })
+                    }).then(res => res.json());
+                }
+                // Wait for and display remote tracks
+                const pulledTracks = await resolvingTracks;
+                const remoteStream = new MediaStream();
+                pulledTracks.forEach(track => remoteStream.addTrack(track));
+                remoteVideo.srcObject = remoteStream;
+                startSessionCheck(localSessionId);
+                startSessionCheck(sessionToJoin);
+            } catch (err) {
+                console.error("Error joining call:", err);
+                alert("Error joining call: " + err.message);
+            }
+        }
+        async function endCall() {
+            try {
+                if (localSessionId) {
+                    // Close tracks following schema
+                    await fetch(`${API_BASE}/sessions/${localSessionId}/tracks/close`, {
+                        method: "PUT",
+                        headers: {
+                            "Authorization": `Bearer ${APP_TOKEN}`,
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({
+                            tracks: [], // Close all tracks
+                            force: true // Force close without renegotiation
+                        })
+                    });
+                }
+                // Clean up resources
+                if (localStream) {
+                    localStream.getTracks().forEach(track => track.stop());
+                }
+                if (localPeerConnection) {
+                    localPeerConnection.close();
+                }
+                localVideo.srcObject = null;
+                remoteVideo.srcObject = null;
+                sessionIdInput.value = '';
+                sessionInput.value = '';
+            } catch (err) {
+                console.error("Error ending call:", err);
+            }
+        }
+        // Sửa lại hàm startSessionCheck để thêm xử lý khi có người tham gia
+        function startSessionCheck(sessionId) {
+            const checkInterval = setInterval(async () => {
+                try {
+                    const response = await fetch(`${API_BASE}/sessions/${sessionId}`, {
+                        headers: {
+                            "Authorization": `Bearer ${APP_TOKEN}`
+                        }
+                    }).then(res => res.json());
+                    if (response.errorCode) {
+                        clearInterval(checkInterval);
+                        console.log(`Session ${sessionId} ended`);
+                        return;
+                    }
+                    // Kiểm tra nếu là session gốc và có tracks mới
+                    if (sessionId === localSessionId && response.tracks) {
+                        const newTracks = response.tracks.filter(track =>
+                            track.status === 'active' &&
+                            track.sessionId !== localSessionId &&
+                            track.sessionId !== remoteSessionId
+                        );
+                        if (newTracks.length > 0) {
+                            console.log("New participant joined, pulling their tracks");
+                            remoteSessionId = newTracks[0].sessionId;
+                            await pullRemoteTracks(newTracks);
+                        }
+                    }
+                } catch (err) {
+                    clearInterval(checkInterval);
+                    console.error("Session check failed:", err);
+                }
+            }, 5000);
+        }
+        // Thêm hàm mới để pull tracks từ người tham gia
+        async function pullRemoteTracks(tracks) {
+            try {
+                // Set up track handling
+                const resolvingTracks = new Promise((resolve, reject) => {
+                    let receivedTracks = [];
+                    const timeout = setTimeout(() => reject(new Error("Track timeout")), 10000);
+                    const handleTrack = (event) => {
+                        console.log("Received remote participant track:", event.track);
+                        receivedTracks.push(event.track);
+                        if (receivedTracks.length === tracks.length) {
+                            clearTimeout(timeout);
+                            localPeerConnection.removeEventListener('track', handleTrack);
+                            resolve(receivedTracks);
+                        }
+                    };
+                    localPeerConnection.addEventListener('track', handleTrack);
+                });
+                // Pull remote tracks
+                const pullResponse = await fetch(`${API_BASE}/sessions/${localSessionId}/tracks/new`, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${APP_TOKEN}`,
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({
+                        tracks: tracks.map(track => ({
+                            location: "remote",
+                            sessionId: track.sessionId,
+                            trackName: track.trackName
+                        }))
+                    })
+                }).then(res => res.json());
+                if (pullResponse.requiresImmediateRenegotiation) {
+                    await localPeerConnection.setRemoteDescription(
+                        new RTCSessionDescription(pullResponse.sessionDescription)
+                    );
+                    const answer = await localPeerConnection.createAnswer();
+                    await localPeerConnection.setLocalDescription(answer);
+                    await fetch(`${API_BASE}/sessions/${localSessionId}/renegotiate`, {
+                        method: "PUT",
+                        headers: {
+                            "Authorization": `Bearer ${APP_TOKEN}`,
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({
+                            sessionDescription: {
+                                sdp: answer.sdp,
+                                type: "answer"
+                            }
+                        })
+                    }).then(res => res.json());
+                }
+                // Wait for and display remote tracks
+                const pulledTracks = await resolvingTracks;
+                const remoteStream = remoteVideo.srcObject instanceof MediaStream ?
+                    remoteVideo.srcObject : new MediaStream();
+                pulledTracks.forEach(track => remoteStream.addTrack(track));
+                remoteVideo.srcObject = remoteStream;
+            } catch (err) {
+                console.error("Error pulling remote tracks:", err);
+            }
+        }
+    </script>
+    <style>
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .video-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin: 20px 0;
+        }
+        video {
+            width: 100%;
+            background: #333;
+        }
+        .controls {
+            text-align: center;
+        }
+        button {
+            padding: 10px 20px;
+            margin: 0 10px;
+        }
+        .controls div {
+            margin-top: 10px;
+        }
+        #sessionId {
+            width: 200px;
+            margin-right: 10px;
+        }
+    </style>
+</body>
+</html>

go.mod CHANGED Viewed

@@ -1,40 +1,44 @@
-module cloudflare-calls-backend
-go 1.23.5
 require (
 	github.com/gin-gonic/gin v1.10.0
-	github.com/golang-jwt/jwt/v5 v5.2.1
-	github.com/google/uuid v1.6.0
-	github.com/gorilla/websocket v1.5.3
 	github.com/joho/godotenv v1.5.1
 )
 require (
-	github.com/bytedance/sonic v1.11.6 // indirect
-	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.20.0 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
-	golang.org/x/net v0.35.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
-	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

+module dappmeeting
+go 1.21.0
+toolchain go1.23.5
 require (
+	github.com/gin-contrib/cors v1.7.3
 	github.com/gin-gonic/gin v1.10.0
+	github.com/golang-jwt/jwt/v5 v5.0.0
+	github.com/google/uuid v1.3.0
+	github.com/gorilla/websocket v1.5.0
 	github.com/joho/godotenv v1.5.1
 )
 require (
+	github.com/bytedance/sonic v1.12.6 // indirect
+	github.com/bytedance/sonic/loader v0.2.1 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.7 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.23.0 // indirect
+	github.com/goccy/go-json v0.10.4 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
+	golang.org/x/arch v0.12.0 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/net v0.33.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
+	google.golang.org/protobuf v1.36.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum CHANGED Viewed

@@ -1,16 +1,20 @@
-github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
-github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
-github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
 github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
-github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
@@ -21,27 +25,31 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
-github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
-github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
-github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
-github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
-github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
-github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -51,47 +59,45 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
-golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
-google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

+github.com/bytedance/sonic v1.12.6 h1:/isNmCUF2x3Sh8RAp/4mh4ZGkcFAX/hLrzrK3AvpRzk=
+github.com/bytedance/sonic v1.12.6/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.1 h1:1GgorWTqf12TA8mma4DDSbaQigE2wOgQo7iCjjJv3+E=
+github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
 github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
+github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
+github.com/gin-contrib/cors v1.7.3 h1:hV+a5xp8hwJoTw7OY+a70FsL8JkVVFTXw9EcfrYUdns=
+github.com/gin-contrib/cors v1.7.3/go.mod h1:M3bcKZhxzsvI+rlRSkkxHyljJt1ESd93COUvemZ79j4=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
+github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
+github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/golang-jwt/jwt/v5 v5.0.0 h1:1n1XNM9hk7O9mnQoNBGolZvzebBQ7p93ULHRc28XJUE=
+github.com/golang-jwt/jwt/v5 v5.0.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
+github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
+github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
+golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
+google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

index.js CHANGED Viewed

@@ -265,6 +265,13 @@ app.post('/api/rooms/:roomId/sessions/:sessionId/publish', verifyToken, async (r
             tracks
         })
     });
     const data = await cfResp.json();
     if (data.sessionDescription) {
         // Emit a 'track-published' event to other participants in the room

             tracks
         })
     });
+    const requestData = {
+        sessionDescription: offer,
+        tracks
+    };
+    // Log request JSON
+    console.log('Request JSON:', JSON.stringify(requestData, null, 2));
     const data = await cfResp.json();
     if (data.sessionDescription) {
         // Emit a 'track-published' event to other participants in the room

main.go CHANGED Viewed

@@ -11,10 +11,8 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"os/signal"
 	"strconv"
 	"sync"
-	"syscall"
 	"time"
 	"github.com/gin-gonic/gin"
@@ -57,6 +55,14 @@ func initConfig() {
 	if cloudflareAppID == "" || cloudflareAppSecret == "" {
 		log.Fatal("CLOUDFLARE_APP_ID and CLOUDFLARE_APP_SECRET must be set")
 	}
 }
 // Helper function to get environment variables with default values
@@ -142,7 +148,7 @@ var wsConnections = struct {
 // --- JWT Verification Middleware ---
 func verifyToken(c *gin.Context) {
-	if (!authRequired) {
 		// Even when auth is disabled, set a default user
 		defaultUser := &User{
 			UserID:      uuid.NewString(),
@@ -161,7 +167,7 @@ func verifyToken(c *gin.Context) {
 	}
 	authHeader := c.GetHeader("Authorization")
-	if (authHeader == "*") {
 		defaultUser := &User{
 			UserID:      uuid.NewString(),
 			Username:    "Anonymous",
@@ -224,8 +230,11 @@ func verifyToken(c *gin.Context) {
 func createCloudflareSession() (string, error) {
 	url := fmt.Sprintf("%s/sessions/new", cloudflareBasePath)
 	req, err := http.NewRequest("POST", url, nil)
 	if err != nil {
 		return "", err
 	}
@@ -233,82 +242,165 @@ func createCloudflareSession() (string, error) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
 		return "", err
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return "", err
 	}
 	var responseData map[string]interface{}
 	if err := json.Unmarshal(body, &responseData); err != nil {
 		return "", err
 	}
 	sessionID, ok := responseData["sessionId"].(string)
 	if !ok {
 		return "", fmt.Errorf("sessionId not found in response: %s", string(body))
 	}
 	return sessionID, nil
 }
-func publishToCloudflare(sessionId string, offer map[string]interface{}, tracks []map[string]interface{}) (map[string]interface{}, error) {
-    url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
-    requestBody := map[string]interface{}{
-        "sessionDescription": offer,
-        "tracks":            tracks,
-    }
-    jsonData, err := json.Marshal(requestBody)
-    if (err != nil) {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Publishing to Cloudflare: %s", string(jsonData))
-    }
-    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
-    if (err != nil) {
-        return nil, err
-    }
-    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", cloudflareAppSecret))
-    req.Header.Set("Content-Type", "application/json")
-    client := &http.Client{
-        Timeout: time.Second * 30,
-    }
-    resp, err := client.Do(req)
-    if (err != nil) {
-        return nil, err
-    }
-    defer resp.Body.Close()
-    body, err := io.ReadAll(resp.Body)
-    if (err != nil) {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Cloudflare publish response: %s", string(body))
-    }
-    var responseData map[string]interface{}
-    if err := json.Unmarshal(body, &responseData); err != nil {
-        return nil, fmt.Errorf("error parsing Cloudflare response: %v. Response body: %s", err, string(body))
-    }
-    // Check for non-2xx status codes
-    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-        return responseData, fmt.Errorf("cloudflare error (status %d): %s", resp.StatusCode, string(body))
-    }
-    return responseData, nil
 }
 func unpublishToCloudflare(cfUrl string, requestBody map[string]interface{}) (map[string]interface{}, error) {
@@ -345,103 +437,78 @@ func unpublishToCloudflare(cfUrl string, requestBody map[string]interface{}) (ma
 }
 func pullFromCloudflare(sessionId string, tracksToPull []map[string]interface{}) (map[string]interface{}, error) {
-    url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
-    // Properly structure the request body as Cloudflare expects
-    requestBody := map[string]interface{}{
-        "tracks": tracksToPull,
-    }
-    jsonData, err := json.Marshal(requestBody)
-    if err != nil {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Sending request to Cloudflare: %s", string(jsonData))
-    }
-    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
-    if err != nil {
-        return nil, err
-    }
-    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", cloudflareAppSecret))
-    req.Header.Set("Content-Type", "application/json")
-    client := &http.Client{}
-    resp, err := client.Do(req)
-    if err != nil {
-        return nil, err
-    }
-    defer resp.Body.Close()
-    body, err := io.ReadAll(resp.Body)
-    if err != nil {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Cloudflare response: %s", string(body))
-    }
-    var responseData map[string]interface{}
-    if err := json.Unmarshal(body, &responseData); err != nil {
-        return nil, fmt.Errorf("error parsing Cloudflare response: %v. Response body: %s", err, string(body))
-    }
-    return responseData, nil
 }
 func renegotiateWithCloudflare(sessionId string, body map[string]interface{}) (map[string]interface{}, error) {
-    url := fmt.Sprintf("%s/sessions/%s/renegotiate", cloudflareBasePath, sessionId)
-    jsonData, err := json.Marshal(body)
-    if err != nil {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Renegotiate request to Cloudflare: %s", string(jsonData))
-    }
-    req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
-    if err != nil {
-        return nil, err
-    }
-    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", cloudflareAppSecret))
-    req.Header.Set("Content-Type", "application/json")
-    client := &http.Client{
-        Timeout: time.Second * 30, // Add reasonable timeout
-    }
-    resp, err := client.Do(req)
-    if err != nil {
-        return nil, err
-    }
-    defer resp.Body.Close()
-    responseBody, err := io.ReadAll(resp.Body)
-    if err != nil {
-        return nil, err
-    }
-    if debug {
-        log.Printf("Cloudflare renegotiate response: %s", string(responseBody))
-    }
-    var responseData map[string]interface{}
-    if err := json.Unmarshal(responseBody, &responseData); err != nil {
-        return nil, fmt.Errorf("error parsing Cloudflare response: %v. Response body: %s", err, string(responseBody))
-    }
-    // If not a 2xx status code, return the error from Cloudflare
-    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-        return responseData, fmt.Errorf("cloudflare error: %s", string(responseBody))
-    }
-    return responseData, nil
 }
 func manageDataChannelsWithCloudflare(cfUrl string, dataChannels []map[string]interface{}) (map[string]interface{}, error) {
@@ -478,9 +545,11 @@ func manageDataChannelsWithCloudflare(cfUrl string, dataChannels []map[string]in
 func getSessionStateFromCloudflare(sessionId string) (map[string]interface{}, error) {
 	url := fmt.Sprintf("%s/sessions/%s", cloudflareBasePath, sessionId)
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -488,17 +557,22 @@ func getSessionStateFromCloudflare(sessionId string) (map[string]interface{}, er
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
 	var responseData map[string]interface{}
 	if err := json.Unmarshal(body, &responseData); err != nil {
 		return nil, err
 	}
@@ -517,83 +591,6 @@ func serializeRoom(roomId string, room *Room) gin.H {
 	}
 }
-func contains(slice []string, str string) bool {
-	for _, v := range slice {
-		if v == str {
-			return true
-		}
-	}
-	return false
-}
-// Add these struct methods to improve participant management
-func (r *Room) FindParticipant(sessionId string) *Participant {
-    r.RLock()
-    defer r.RUnlock()
-    for _, p := range r.Participants {
-        if p.SessionID == sessionId {
-            return p
-        }
-    }
-    return nil
-}
-func (r *Room) AddParticipant(p *Participant) {
-    r.Lock()
-    defer r.Unlock()
-    r.Participants = append(r.Participants, p)
-}
-func (r *Room) RemoveParticipant(sessionId string) *Participant {
-    r.Lock()
-    defer r.Unlock()
-    for i, p := range r.Participants {
-        if p.SessionID == sessionId {
-            // Remove participant
-            r.Participants = append(r.Participants[:i], r.Participants[i+1:]...)
-            return p
-        }
-    }
-    return nil
-}
-func (r *Room) GetOtherParticipants(excludeSessionId string) []SessionInfo {
-    r.RLock()
-    defer r.RUnlock()
-    others := make([]SessionInfo, 0)
-    for _, p := range r.Participants {
-        if p.SessionID != excludeSessionId {
-            others = append(others, SessionInfo{
-                UserId:          p.UserID,
-                SessionId:       p.SessionID,
-                PublishedTracks: p.PublishedTracks,
-            })
-        }
-    }
-    return others
-}
-func (p *Participant) AddTrack(trackName string) bool {
-    for _, t := range p.PublishedTracks {
-        if t == trackName {
-            return false // Track already exists
-        }
-    }
-    p.PublishedTracks = append(p.PublishedTracks, trackName)
-    return true
-}
-func (p *Participant) RemoveTrack(trackName string) bool {
-    for i, t := range p.PublishedTracks {
-        if t == trackName {
-            p.PublishedTracks = append(p.PublishedTracks[:i], p.PublishedTracks[i+1:]...)
-            return true
-        }
-    }
-    return false
-}
 // --- Route Handlers ---
 func createRoom(c *gin.Context) {
@@ -656,203 +653,240 @@ func inspectRooms(c *gin.Context) {
 }
 func joinRoom(c *gin.Context) {
-    roomId := c.Param("roomId")
-    user, _ := c.Get("user")
-    currentUser, ok := user.(*User)
-    if !ok {
-        c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Forbidden: Invalid user"})
-        return
-    }
-    userId := currentUser.UserID
-    rooms.Lock()
-    room, exists := rooms.m[roomId]
-    if !exists {
-        // Create new room if it doesn't exist
-        room = &Room{
-            RoomId:       roomId,
-            Name:         "New Room",
-            Metadata:     make(map[string]interface{}),
-            Participants: make([]*Participant, 0),
-            CreatedAt:    time.Now().Unix(),
-        }
-        rooms.m[roomId] = room
-    }
-    rooms.Unlock()
-    // Create Cloudflare Session
-    sessionID, err := createCloudflareSession()
-    if err != nil {
-        if debug {
-            log.Printf("Error creating Cloudflare session: %v", err)
-        }
-        c.JSON(http.StatusInternalServerError, gin.H{
-            "errorCode": "SESSION_CREATION_ERROR",
-            "errorDescription": "Could not create Calls session",
-        })
-        return
-    }
-    // Create new participant
-    participant := &Participant{
-        UserID:          userId,
-        SessionID:       sessionID,
-        CreatedAt:       time.Now().Unix(),
-        PublishedTracks: make([]string, 0),
-    }
-    // Add participant to room
-    room.AddParticipant(participant)
-    // Get other participants
-    otherSessions := room.GetOtherParticipants(sessionID)
-    // Ensure WebSocket connections map exists for this room
-    wsConnections.Lock()
-    if _, exists := wsConnections.m[roomId]; !exists {
-        wsConnections.m[roomId] = make(map[string]*websocket.Conn)
-    }
-    wsConnections.Unlock()
-    // Broadcast join event
-    broadcastToRoom(roomId, gin.H{
-        "type": "participant-joined",
-        "payload": gin.H{
-            "userId":    userId,
-            "username":  currentUser.Username,
-            "sessionId": sessionID,
-        },
-    }, userId)
-    if debug {
-        log.Printf("User %s joined room %s with session %s", userId, roomId, sessionID)
-    }
-    response := SessionResponse{
-        SessionId:     sessionID,
-        OtherSessions: otherSessions,
-    }
-    c.JSON(http.StatusOK, response)
 }
 func publishTracks(c *gin.Context) {
-    roomId := c.Param("roomId")
-    sessionId := c.Param("sessionId")
-    rooms.RLock()
-    room, ok := rooms.m[roomId]
-    rooms.RUnlock()
-    if (!ok) {
-        c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
-        return
-    }
-    var participant *Participant
-    room.RLock()
-    for _, p := range room.Participants {
-        if p.SessionID == sessionId {
-            participant = p
-            break
-        }
-    }
-    room.RUnlock()
-    if (participant == nil) {
-        c.JSON(http.StatusNotFound, gin.H{"error": "Session not found in this room"})
-        return
-    }
-    var req struct {
-        Offer  map[string]interface{} `json:"offer"`
-        Tracks []struct {
-            TrackName string `json:"trackName"`
-            Mid       string `json:"mid"`
-            Location  string `json:"location,omitempty"`
-        } `json:"tracks"`
-    }
-    if err := c.ShouldBindJSON(&req); err != nil {
-        c.JSON(http.StatusBadRequest, gin.H{
-            "errorCode": "INVALID_REQUEST",
-            "errorDescription": err.Error(),
-        })
-        return
-    }
-    // Validate required fields
-    if req.Offer == nil || len(req.Tracks) == 0 {
-        c.JSON(http.StatusBadRequest, gin.H{
-            "errorCode": "INVALID_REQUEST",
-            "errorDescription": "offer and tracks are required",
-        })
-        return
-    }
-    // Build tracks array with proper structure
-    tracks := make([]map[string]interface{}, len(req.Tracks))
-    for i, t := range req.Tracks {
-        track := map[string]interface{}{
-            "trackName": t.TrackName,
-            "mid":       t.Mid,
-        }
-        if t.Location != "" {
-            track["location"] = t.Location
-        } else {
-            track["location"] = "local" // Default to local if not specified
-        }
-        tracks[i] = track
-    }
-    if debug {
-        log.Printf("Publishing tracks with data: %+v", tracks)
-    }
-    data, err := publishToCloudflare(sessionId, req.Offer, tracks)
-    if err != nil {
-        if debug {
-            log.Printf("Error from Cloudflare: %v", err)
-        }
-        c.JSON(http.StatusInternalServerError, gin.H{
-            "errorCode": "PUBLISH_ERROR",
-            "errorDescription": err.Error(),
-        })
-        return
-    }
-    // If there's a Cloudflare error, return it
-    if errorCode, hasError := data["errorCode"]; hasError {
-        c.JSON(http.StatusBadRequest, gin.H{
-            "errorCode": errorCode,
-            "errorDescription": data["errorDescription"],
-        })
-        return
-    }
-    // Update participant's published tracks
-    room.Lock()
-    for _, t := range req.Tracks {
-        if !contains(participant.PublishedTracks, t.TrackName) {
-            participant.PublishedTracks = append(participant.PublishedTracks, t.TrackName)
-        }
-    }
-    room.Unlock()
-    // Emit track-published event if successful
-    if data["sessionDescription"] != nil {
-        trackNames := make([]string, len(req.Tracks))
-        for i, t := range req.Tracks {
-            trackNames[i] = t.TrackName
-        }
-        broadcastToRoom(roomId, gin.H{
-            "type": "track-published",
-            "payload": gin.H{
-                "sessionId":  sessionId,
-                "trackNames": trackNames,
-            },
-        }, participant.UserID)
-    }
-    c.JSON(http.StatusOK, data)
 }
 func unpublishTrack(c *gin.Context) {
@@ -866,19 +900,19 @@ func unpublishTrack(c *gin.Context) {
 	}
 	var req struct {
-			TrackName          string                 `json:"trackName"`
-			Mid                string                 `json:"mid"`
-			Force              bool                   `json:"force"`
-			SessionDescription map[string]interface{} `json:"sessionDescription"`
 	}
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-	// If trying to force unpublish someone else's track
 	if req.Force && sessionId != currentUser.UserID {
-		// Check if user is moderator
 		if !currentUser.IsModerator {
 			c.JSON(http.StatusForbidden, gin.H{
 				"errorCode":        "NOT_AUTHORIZED",
@@ -911,16 +945,16 @@ func unpublishTrack(c *gin.Context) {
 	if debug {
 		log.Println("Calling Cloudflare API:", cfUrl)
 	}
-	// The 'tracks' array MUST contain objects with a 'mid' field
 	requestBody := map[string]interface{}{
-		"tracks": []map[string]interface{}{
 			{"mid": req.Mid},
 		},
 		"force":              req.Force,
 		"sessionDescription": req.SessionDescription,
 	}
 	if debug {
-		log.Printf("Request body: %+v\n", requestBody)
 	}
 	data, err := unpublishToCloudflare(cfUrl, requestBody)
@@ -931,134 +965,133 @@ func unpublishTrack(c *gin.Context) {
 	if debug {
 		log.Println("Cloudflare API response:", data)
 	}
-	// Check for Cloudflare errors before broadcasting
-	if cfErr, ok := data["errorCode"]; ok {
-		c.JSON(http.StatusBadRequest, gin.H{"error": cfErr, "message": data["errorDescription"]})
-		return
-	}
 	broadcastToRoom(roomId, gin.H{
 		"type":    "track-unpublished",
 		"payload": gin.H{"sessionId": sessionId, "trackName": req.TrackName},
 	}, sessionId)
 	c.JSON(http.StatusOK, data)
 }
 func pullTracks(c *gin.Context) {
-    roomId := c.Param("roomId")
-    sessionId := c.Param("sessionId")
-    rooms.RLock()
-    room, ok := rooms.m[roomId]
-    rooms.RUnlock()
-    if (!ok) {
-        c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
-        return
-    }
-    var participant *Participant
-    room.RLock()
-    for _, p := range room.Participants {
-        if p.SessionID == sessionId {
-            participant = p
-            break
-        }
-    }
-    room.RUnlock()
-    if participant == nil {
-        c.JSON(http.StatusNotFound, gin.H{"error": "Session not found in this room"})
-        return
-    }
-    var req struct {
-        RemoteSessionID string `json:"remoteSessionId"`
-        TrackName       string `json:"trackName"`
-    }
-    if err := c.ShouldBindJSON(&req); err != nil {
-        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-        return
-    }
-    // Validate required fields
-    if req.RemoteSessionID == "" || req.TrackName == "" {
-        c.JSON(http.StatusBadRequest, gin.H{
-            "errorCode": "INVALID_REQUEST",
-            "errorDescription": "remoteSessionId and trackName are required",
-        })
-        return
-    }
-    // Build tracks array exactly as Cloudflare expects it
-    tracksToPull := []map[string]interface{}{
-        {
-            "location":  "remote",
-            "sessionId": req.RemoteSessionID,
-            "trackName": req.TrackName,
-        },
-    }
-    if debug {
-        log.Printf("Pulling track with data: %+v", tracksToPull)
-    }
-    data, err := pullFromCloudflare(sessionId, tracksToPull)
-    if err != nil {
-        if debug {
-            log.Printf("Error from Cloudflare: %v", err)
-        }
-        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-        return
-    }
-    // Check for Cloudflare errors
-    if errorCode, hasError := data["errorCode"]; hasError {
-        c.JSON(http.StatusBadRequest, gin.H{
-            "errorCode": errorCode,
-            "errorDescription": data["errorDescription"],
-        })
-        return
-    }
-    c.JSON(http.StatusOK, data)
 }
 func renegotiateSession(c *gin.Context) {
-    sessionId := c.Param("sessionId")
-    // Fixed: Accept raw JSON structure to match Express implementation
-    var req struct {
-        SDP  string `json:"sdp"`
-        Type string `json:"type"`
-    }
-    if err := c.ShouldBindJSON(&req); err != nil {
-        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-        return
-    }
-    body := map[string]interface{}{
-        "sessionDescription": map[string]interface{}{
-            "sdp":  req.SDP,
-            "type": req.Type,
-        },
-    }
-    data, err := renegotiateWithCloudflare(sessionId, body)
-    if err != nil {
-        if data != nil && data["errorCode"] != nil {
-            c.JSON(http.StatusBadRequest, data)
-            return
-        }
-        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-        return
-    }
-    c.JSON(http.StatusOK, data)
 }
 func manageDataChannels(c *gin.Context) {
@@ -1067,9 +1100,9 @@ func manageDataChannels(c *gin.Context) {
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
-	log.Println(room)
 	rooms.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
@@ -1086,16 +1119,15 @@ func manageDataChannels(c *gin.Context) {
 	}
 	cfUrl := fmt.Sprintf("%s/sessions/%s/datachannels/new", cloudflareBasePath, sessionId)
-	// --- CRITICAL: Build the dataChannels array correctly ---
 	dataChannels := make([]map[string]interface{}, len(req.DataChannels))
 	for i, dc := range req.DataChannels {
 		dataChannels[i] = map[string]interface{}{
 			"location":        dc.Location,
-			"dataChannelName": dc.DataChannelName, // Use the correct field name
 		}
 	}
-	data, err := manageDataChannelsWithCloudflare(cfUrl, dataChannels) // Use the helper
 	if err != nil {
 		if data != nil && data["errorCode"] != nil { // Check for Cloudflare error
 			c.JSON(http.StatusBadRequest, data)
@@ -1120,7 +1152,7 @@ func getParticipants(c *gin.Context) {
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
@@ -1135,7 +1167,7 @@ func getParticipantTracks(c *gin.Context) {
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
@@ -1149,7 +1181,7 @@ func getParticipantTracks(c *gin.Context) {
 	}
 	room.RUnlock()
-	if (participant == nil) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Participant not found"})
 		return
 	}
@@ -1202,7 +1234,6 @@ func getICEServers(c *gin.Context) {
 	c.JSON(http.StatusOK, iceServers)
 }
 func getToken(c *gin.Context) {
 	var req struct {
 		Username string `json:"username"`
@@ -1270,7 +1301,7 @@ func getUserInfo(c *gin.Context) {
 		users.RLock()
 		userInfo, ok := users.m[currentUser.UserID]
 		users.RUnlock()
-		if (!ok) {
 			c.JSON(http.StatusNotFound, gin.H{
 				"errorCode":        "USER_NOT_FOUND",
 				"errorDescription": "Current user not found",
@@ -1284,7 +1315,7 @@ func getUserInfo(c *gin.Context) {
 	users.RLock()
 	requestedUser, ok := users.m[userIdParam]
 	users.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{
 			"errorCode":        "USER_NOT_FOUND",
 			"errorDescription": "User not found",
@@ -1312,7 +1343,7 @@ func leaveRoom(c *gin.Context) {
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
@@ -1422,7 +1453,7 @@ func updateRoomMetadata(c *gin.Context) {
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
-	if (!ok) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
@@ -1466,132 +1497,76 @@ var upgrader = websocket.Upgrader{
 }
 func websocketHandler(c *gin.Context) {
-    // Set headers for WebSocket upgrade
-    c.Writer.Header().Set("Sec-WebSocket-Protocol", "")
-    c.Writer.Header().Set("Connection", "Upgrade")
-    c.Writer.Header().Set("Upgrade", "websocket")
-    if debug {
-        log.Printf("Attempting WebSocket upgrade for: %s\n", c.Request.RemoteAddr)
-        log.Printf("Headers: %+v\n", c.Request.Header)
-    }
-    ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-    if err != nil {
-        log.Printf("Failed to upgrade connection: %v\n", err)
-        return
-    }
-    // Set connection parameters
-    ws.SetReadLimit(512 * 1024) // 512KB read limit
-    ws.SetReadDeadline(time.Time{}) // No read deadline for now
-    ws.SetWriteDeadline(time.Time{}) // No write deadline for now
-    // Handle the WebSocket connection
-    go handleWebSocket(ws)
 }
 func handleWebSocket(ws *websocket.Conn) {
-    if debug {
-        log.Printf("New WebSocket connection established from: %s\n", ws.RemoteAddr().String())
-    }
-    // Set ping handler
-    ws.SetPingHandler(func(data string) error {
-        return ws.WriteControl(websocket.PongMessage, []byte(data), time.Now().Add(10*time.Second))
-    })
-    // Create a done channel to signal when to stop the ping routine
-    done := make(chan struct{})
-    defer close(done)
-    // Start a goroutine to send pings periodically
-    go func() {
-        ticker := time.NewTicker(30 * time.Second)
-        defer ticker.Stop()
-        for {
-            select {
-            case <-ticker.C:
-                if err := ws.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(10*time.Second)); err != nil {
-                    log.Printf("ping error: %v", err)
-                    return
-                }
-            case <-done:
-                return
-            }
-        }
-    }()
-    var userId string
-    var roomId string
-    for {
-        messageType, message, err := ws.ReadMessage()
-        if err != nil {
-            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
-                log.Printf("WebSocket error: %v", err)
-            }
-            handleWSDisconnect(ws, roomId, userId)
-            break
-        }
-        // Skip processing ping/pong messages
-        if messageType == websocket.PingMessage || messageType == websocket.PongMessage {
-            continue
-        }
-        var data map[string]interface{}
-        if err := json.Unmarshal(message, &data); err != nil {
-            log.Println("Error parsing message:", err)
-            continue
-        }
-        messageTypeStr, ok := data["type"].(string)
-        if !ok {
-            log.Println("Invalid message format: missing or invalid 'type'")
-            continue
-        }
-        switch messageTypeStr {
-        case "join-websocket":
-            payload, ok := data["payload"].(map[string]interface{})
-            if !ok {
-                log.Println("Invalid 'join-websocket' payload")
-                continue
-            }
-            // Store these values for disconnect handling
-            roomId, _ = payload["roomId"].(string)
-            userId, _ = payload["userId"].(string)
-            handleWSJoin(ws, payload)
-        case "data-message":
-            if authRequired && (!ws.IsAuthenticated()) {
-                _ = ws.WriteJSON(map[string]string{"error": "Unauthorized: Please authenticate first"})
-                if debug {
-                    log.Println("Unauthenticated websocket request to send data-message")
-                }
-                continue
-            }
-            payload, ok := data["payload"].(map[string]interface{})
-            if !ok {
-                log.Println("Invalid 'data-message' payload")
-                continue
-            }
-            handleDataMessage(ws, payload)
-        default:
-            log.Println("Unknown message type:", messageTypeStr)
-        }
-    }
-}
-// Add IsAuthenticated method to *websocket.Conn
-func (ws *websocket.Conn) IsAuthenticated() bool {
-    // You can store this as a property on connection establishment
-    return true // For now, always return true since auth is disabled
 }
 // --- WebSocket Helper Functions ---
@@ -1700,196 +1675,126 @@ func handleDataMessage(ws *websocket.Conn, payload map[string]interface{}) {
 	}, from) // Exclude the sender
 }
-func handleWSDisconnect(ws *websocket.Conn, roomId, userId string) {
 	wsConnections.Lock()
 	defer wsConnections.Unlock()
-	// Remove user from the specific room
-	if roomConns, ok := wsConnections.m[roomId]; ok {
-		delete(roomConns, userId)
 		if debug {
 			log.Printf("User %s disconnected from room %s\n", userId, roomId)
 		}
-		// Optionally, clean up the room map if it's now empty
-		if len(roomConns) == 0 {
-			delete(wsConnections.m, roomId)
-		}
 	}
 }
 func broadcastToRoom(roomId string, message gin.H, excludeUserId string) {
-    if debug {
-        log.Printf("Broadcasting to room %s: %+v (excluding: %s)", roomId, message, excludeUserId)
-    }
-    // Check room exists
-    rooms.RLock()
-    _, ok := rooms.m[roomId]
-    rooms.RUnlock()
-    if !ok {
-        if debug {
-            log.Printf("Room %s not found for broadcast", roomId)
-        }
-        return
-    }
-    // Safely get connections
-    wsConnections.RLock()
-    connections, ok := wsConnections.m[roomId]
-    if !ok {
-        wsConnections.RUnlock()
-        if debug {
-            log.Printf("No WebSocket connections found for room %s", roomId)
-        }
-        return
-    }
-    // Create a copy of connections to avoid holding the lock
-    connectionsCopy := make(map[string]*websocket.Conn)
-    for userId, conn := range connections {
-        if userId != excludeUserId {
-            connectionsCopy[userId] = conn
-        }
-    }
-    wsConnections.RUnlock()
-    // Prepare message once
-    messageBytes, err := json.Marshal(message)
-    if err != nil {
-        log.Printf("Error marshaling broadcast message: %v", err)
-        return
-    }
-    // Broadcast to all connections
-    for userId, conn := range connectionsCopy {
-        if conn == nil {
-            continue
-        }
-        // Use a write deadline to prevent hanging
-        _ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
-        err := conn.WriteMessage(websocket.TextMessage, messageBytes)
-        if err != nil {
-            log.Printf("Error broadcasting to user %s: %v", userId, err)
-            // Clean up dead connection
-            wsConnections.Lock()
-            if roomConns, exists := wsConnections.m[roomId]; exists {
-                delete(roomConns, userId)
-                // If room is empty, remove it
-                if len(roomConns) == 0 {
-                    delete(wsConnections.m, roomId)
-                }
-            }
-            wsConnections.Unlock()
-        } else if debug {
-            log.Printf("Successfully broadcast to user %s in room %s", userId, roomId)
-        }
-    }
 }
 func main() {
-    initConfig()
-    r := gin.Default()
-    // Comprehensive CORS middleware
-    r.Use(func(c *gin.Context) {
-        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
-        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
-        c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH")
-        c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With, X-Auth-Token, Upgrade, Connection")
-        // Handle WebSocket pre-flight
-        if c.Request.Method == "OPTIONS" {
-            // Special handling for WebSocket upgrade requests
-            if c.Request.Header.Get("Upgrade") == "websocket" {
-                c.Writer.Header().Set("Connection", "Upgrade")
-                c.Writer.Header().Set("Upgrade", "websocket")
-            }
-            c.AbortWithStatus(204)
-            return
-        }
-        c.Next()
-    })
-    // Initialize WebSocket upgrader with proper settings
-    upgrader = websocket.Upgrader{
-        CheckOrigin: func(r *http.Request) bool {
-            return true // Be careful with this in production
-        },
-        ReadBufferSize:  1024,
-        WriteBufferSize: 1024,
-        HandshakeTimeout: 10 * time.Second,
-        EnableCompression: true,
-    }
-    // Auth endpoints
-    r.POST("/auth/token", getToken)
-    // WebSocket endpoint - no auth required for upgrade
-    r.GET("/ws", func(c *gin.Context) {
-        websocketHandler(c)
-    })
-    // Protected API routes
-    api := r.Group("/api", verifyToken)
-    {
-        api.POST("/rooms", createRoom)
-        api.GET("/rooms", getRooms)
-        api.GET("/inspect-rooms", inspectRooms)
-        api.POST("/rooms/:roomId/join", joinRoom)
-        api.POST("/rooms/:roomId/sessions/:sessionId/publish", publishTracks)
-        api.POST("/rooms/:roomId/sessions/:sessionId/unpublish", unpublishTrack)
-        api.POST("/rooms/:roomId/sessions/:sessionId/pull", pullTracks)
-        api.PUT("/rooms/:roomId/sessions/:sessionId/renegotiate", renegotiateSession)
-        api.POST("/rooms/:roomId/sessions/:sessionId/datachannels/new", manageDataChannels)
-        api.GET("/rooms/:roomId/participants", getParticipants)
-        api.GET("/rooms/:roomId/participant/:sessionId/tracks", getParticipantTracks)
-        api.GET("/ice-servers", getICEServers)
-        api.GET("/rooms/:roomId/sessions/:sessionId/state", getSessionState)
-        api.GET("/users/:userId", getUserInfo)
-        api.POST("/rooms/:roomId/leave", leaveRoom)
-        api.POST("/rooms/:roomId/sessions/:sessionId/track-status", updateTrackStatus)
-        api.PUT("/rooms/:roomId/metadata", updateRoomMetadata)
-    }
-    // Set up signal handling for graceful shutdown
-    quit := make(chan os.Signal, 1)
-    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-    go func() {
-        <-quit
-        log.Println("Shutting down server...")
-        // Clean up code here
-        users.Lock()
-        users.m = make(map[string]*User)
-        users.Unlock()
-        rooms.Lock()
-        rooms.m = make(map[string]*Room)
-        rooms.Unlock()
-        wsConnections.Lock()
-        for roomId, conns := range wsConnections.m {
-            for userId, conn := range conns {
-                if conn != nil {
-                    conn.Close()
-                }
-                delete(conns, userId)
-            }
-            delete(wsConnections.m, roomId)
-        }
-        wsConnections.Unlock()
-        os.Exit(0)
-    }()
-    // Start the server
-    log.Printf("Server listening on http://localhost:%s\n", port)
-    if err := r.Run(":" + port); err != nil {
-        log.Fatal("Failed to start server:", err)
-    }
 }

 	"log"
 	"net/http"
 	"os"
 	"strconv"
 	"sync"
 	"time"
 	"github.com/gin-gonic/gin"
 	if cloudflareAppID == "" || cloudflareAppSecret == "" {
 		log.Fatal("CLOUDFLARE_APP_ID and CLOUDFLARE_APP_SECRET must be set")
 	}
+	// Thêm log để kiểm tra biến môi trường
+	log.Println("Biến môi trường đã tải:")
+	log.Println("CLOUDFLARE_APP_ID:", cloudflareAppID)
+	log.Println("CLOUDFLARE_APP_SECRET:", cloudflareAppSecret)
+	log.Println("JWT_SECRET:", secretKey)
+	log.Println("CLOUDFLARE_APPS_URL:", cloudflareCallsBaseURL)
+	log.Println("DEBUG:", debug)
 }
 // Helper function to get environment variables with default values
 // --- JWT Verification Middleware ---
 func verifyToken(c *gin.Context) {
+	if !authRequired {
 		// Even when auth is disabled, set a default user
 		defaultUser := &User{
 			UserID:      uuid.NewString(),
 	}
 	authHeader := c.GetHeader("Authorization")
+	if authHeader == "*" {
 		defaultUser := &User{
 			UserID:      uuid.NewString(),
 			Username:    "Anonymous",
 func createCloudflareSession() (string, error) {
 	url := fmt.Sprintf("%s/sessions/new", cloudflareBasePath)
+	log.Printf("[Cloudflare API] Creating new session: %s", url)
 	req, err := http.NewRequest("POST", url, nil)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to create request: %v", err)
 		return "", err
 	}
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to execute request: %v", err)
 		return "", err
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to read response body: %v", err)
 		return "", err
 	}
+	log.Printf("[Cloudflare API Response] Status: %d, Body: %s", resp.StatusCode, string(body))
 	var responseData map[string]interface{}
 	if err := json.Unmarshal(body, &responseData); err != nil {
+		log.Printf("[Cloudflare API Error] Failed to parse response: %v", err)
 		return "", err
 	}
 	sessionID, ok := responseData["sessionId"].(string)
 	if !ok {
+		log.Printf("[Cloudflare API Error] Session ID not found in response")
 		return "", fmt.Errorf("sessionId not found in response: %s", string(body))
 	}
+	log.Printf("[Cloudflare API Success] Created session: %s", sessionID)
 	return sessionID, nil
 }
+func makeCloudflareRequest(method string, url string, requestBody map[string]interface{}) (map[string]interface{}, error, int) {
+	var reqBodyBytes []byte = nil
+	if requestBody != nil {
+		var errMarshal error
+		reqBodyBytes, errMarshal = json.Marshal(requestBody)
+		if errMarshal != nil {
+			log.Printf("Lỗi Marshal body yêu cầu JSON: %v", errMarshal)
+			return nil, errMarshal, http.StatusInternalServerError
+		}
+	}
+	req, errNewRequest := http.NewRequest(method, url, bytes.NewBuffer(reqBodyBytes))
+	if errNewRequest != nil {
+		log.Printf("Lỗi tạo yêu cầu HTTP mới: %v", errNewRequest)
+		return nil, errNewRequest, http.StatusInternalServerError
+	}
+	// Thiết lập các header quan trọng và phổ biến
+	req.Header.Set("Authorization", "Bearer "+cloudflareAppSecret) // Đảm bảo cloudflareAppSecret có giá trị
+	if requestBody != nil {
+		req.Header.Set("Content-Type", "application/json") // Cho các yêu cầu có body JSON
+	}
+	req.Header.Set("Accept", "application/json")               // Yêu cầu phản hồi JSON
+	req.Header.Set("User-Agent", "CloudflareCalls-Backend-Go") // Thêm User-Agent để nhận diện backend (tùy chọn)
+	// Bạn có thể thêm các header khác nếu cần, ví dụ:
+	// req.Header.Set("Cache-Control", "no-cache")
+	// req.Header.Set("Connection", "keep-alive")
+	log.Println("Yêu cầu HTTP:")
+	log.Println("  Method:", method)
+	log.Println("  URL:", url)
+	log.Println("  Headers:", req.Header)
+	if requestBody != nil {
+		log.Println("  Body yêu cầu:", string(reqBodyBytes))
+	}
+	client := &http.Client{}
+	resp, errClientDo := client.Do(req)
+	if errClientDo != nil {
+		log.Printf("Lỗi khi thực hiện yêu cầu HTTP: %v", errClientDo)
+		return nil, errClientDo, http.StatusInternalServerError
+	}
+	defer resp.Body.Close()
+	respBodyBytes, errReadAll := io.ReadAll(resp.Body)
+	if errReadAll != nil {
+		log.Printf("Lỗi đọc body phản hồi: %v", errReadAll)
+		return nil, errReadAll, http.StatusInternalServerError
+	}
+	log.Println("Phản hồi HTTP:")
+	log.Println("  Mã trạng thái:", resp.StatusCode)
+	log.Println("  Body phản hồi:", string(respBodyBytes))
+	var responseData map[string]interface{}
+	errUnmarshal := json.Unmarshal(respBodyBytes, &responseData)
+	if errUnmarshal != nil {
+		log.Printf("Lỗi Unmarshal body phản hồi JSON: %v", errUnmarshal)
+		return nil, errUnmarshal, http.StatusInternalServerError
+	}
+	return responseData, nil, resp.StatusCode
+}
+func publishToCloudflare(sessionId string, offer map[string]interface{}, tracks []struct {
+	TrackName string `json:"trackName"`
+	Mid       string `json:"mid"`
+	Location  string `json:"location"`
+}) (map[string]interface{}, error) {
+	url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
+	log.Printf("[Cloudflare API] Publishing tracks to session %s", sessionId)
+	trackData := make([]map[string]interface{}, len(tracks))
+	for i, t := range tracks {
+		location := t.Location
+		if location == "" {
+			location = "local"
+		}
+		trackData[i] = map[string]interface{}{
+			"trackName": t.TrackName,
+			"mid":       t.Mid,
+			"location":  location,
+		}
+	}
+	requestBody := map[string]interface{}{
+		"sessionDescription": offer,
+		"tracks":             trackData,
+	}
+	jsonData, err := json.Marshal(requestBody)
+	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to marshal request body: %v", err)
+		return nil, err
+	}
+	log.Printf("[Cloudflare API Request] URL: %s, Body: %s", url, string(jsonData))
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to create request: %v", err)
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+cloudflareAppSecret)
+	req.Header.Set("Content-Type", "application/json")
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to execute request: %v", err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to read response body: %v", err)
+		return nil, err
+	}
+	log.Printf("[Cloudflare API Response] Status: %d, Body: %s", resp.StatusCode, string(body))
+	var responseData map[string]interface{}
+	if err := json.Unmarshal(body, &responseData); err != nil {
+		log.Printf("[Cloudflare API Error] Failed to parse response: %v", err)
+		return nil, err
+	}
+	return responseData, nil
 }
 func unpublishToCloudflare(cfUrl string, requestBody map[string]interface{}) (map[string]interface{}, error) {
 }
 func pullFromCloudflare(sessionId string, tracksToPull []map[string]interface{}) (map[string]interface{}, error) {
+	url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
+	requestBody := map[string]interface{}{
+		"tracks": tracksToPull,
+	}
+	jsonData, err := json.Marshal(requestBody)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+cloudflareAppSecret)
+	req.Header.Set("Content-Type", "application/json")
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	var responseData map[string]interface{}
+	if err := json.Unmarshal(body, &responseData); err != nil {
+		return nil, err
+	}
+	return responseData, nil
 }
 func renegotiateWithCloudflare(sessionId string, body map[string]interface{}) (map[string]interface{}, error) {
+	url := fmt.Sprintf("%s/sessions/%s/renegotiate", cloudflareBasePath, sessionId)
+	jsonData, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+cloudflareAppSecret)
+	req.Header.Set("Content-Type", "application/json")
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	var responseData map[string]interface{}
+	if err := json.Unmarshal(responseBody, &responseData); err != nil {
+		return nil, err
+	}
+	return responseData, nil
 }
 func manageDataChannelsWithCloudflare(cfUrl string, dataChannels []map[string]interface{}) (map[string]interface{}, error) {
 func getSessionStateFromCloudflare(sessionId string) (map[string]interface{}, error) {
 	url := fmt.Sprintf("%s/sessions/%s", cloudflareBasePath, sessionId)
+	log.Printf("[Cloudflare API] Getting session state: %s", url)
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to create request: %v", err)
 		return nil, err
 	}
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to execute request: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
+		log.Printf("[Cloudflare API Error] Failed to read response body: %v", err)
 		return nil, err
 	}
+	log.Printf("[Cloudflare API Response] Status: %d, Body: %s", resp.StatusCode, string(body))
 	var responseData map[string]interface{}
 	if err := json.Unmarshal(body, &responseData); err != nil {
+		log.Printf("[Cloudflare API Error] Failed to parse response: %v", err)
 		return nil, err
 	}
 	}
 }
 // --- Route Handlers ---
 func createRoom(c *gin.Context) {
 }
 func joinRoom(c *gin.Context) {
+	roomId := c.Param("roomId")
+	user, _ := c.Get("user")
+	currentUser, ok := user.(*User)
+	if !ok {
+		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Forbidden: Invalid user"})
+		return
+	}
+	userId := currentUser.UserID
+	rooms.Lock() // Lock for writing
+	room, exists := rooms.m[roomId]
+	if !exists {
+		// Create new room if it doesn't exist
+		room = &Room{
+			Name:         "New Room",
+			Metadata:     make(map[string]interface{}),
+			Participants: make([]*Participant, 0),
+			CreatedAt:    time.Now().Unix(),
+		}
+		rooms.m[roomId] = room
+	}
+	rooms.Unlock()
+	// Create Calls Session
+	sessionID, err := createCloudflareSession()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not create Calls session"})
+		return
+	}
+	participant := &Participant{
+		UserID:          userId,
+		SessionID:       sessionID,
+		CreatedAt:       time.Now().Unix(),
+		PublishedTracks: make([]string, 0),
+	}
+	room.Lock()
+	room.Participants = append(room.Participants, participant)
+	// Create otherSessions list safely with complete track information
+	otherSessions := make([]SessionInfo, 0)
+	for _, p := range room.Participants {
+		if p.UserID != userId {
+			// Lấy state của session từ Cloudflare để có thông tin track đầy đủ
+			state, err := getSessionStateFromCloudflare(p.SessionID)
+			if err != nil {
+				log.Printf("Error getting session state for %s: %v", p.SessionID, err)
+				continue
+			}
+			// Extract tracks info from state
+			tracks := make([]string, 0)
+			if tracksArray, ok := state["tracks"].([]interface{}); ok {
+				for _, track := range tracksArray {
+					if trackMap, ok := track.(map[string]interface{}); ok {
+						if trackName, ok := trackMap["trackName"].(string); ok {
+							tracks = append(tracks, trackName)
+						}
+					}
+				}
+			}
+			otherSessions = append(otherSessions, SessionInfo{
+				UserId:          p.UserID,
+				SessionId:       p.SessionID,
+				PublishedTracks: tracks,
+			})
+		}
+	}
+	room.Unlock()
+	// Initialize WebSocket connections map for the room
+	wsConnections.Lock()
+	if _, exists := wsConnections.m[roomId]; !exists {
+		wsConnections.m[roomId] = make(map[string]*websocket.Conn)
+	}
+	wsConnections.Unlock()
+	// Add more detail to the participant-joined event
+	broadcastToRoom(roomId, gin.H{
+		"type": "participant-joined",
+		"payload": gin.H{
+			"userId":    userId,
+			"username":  currentUser.Username,
+			"sessionId": sessionID,
+		},
+	}, userId)
+	response := SessionResponse{
+		SessionId:     sessionID,
+		OtherSessions: otherSessions,
+	}
+	if debug {
+		log.Printf("Join room response: %+v\n", response)
+	}
+	c.JSON(http.StatusOK, response)
 }
+// Sửa lại struct request cho publishTracks để match với Express
 func publishTracks(c *gin.Context) {
+	roomId := c.Param("roomId")
+	sessionId := c.Param("sessionId")
+	rooms.RLock()
+	room, ok := rooms.m[roomId]
+	rooms.RUnlock()
+	if !ok {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
+		return
+	}
+	var participant *Participant
+	room.RLock()
+	for _, p := range room.Participants {
+		if p.SessionID == sessionId {
+			participant = p
+			break
+		}
+	}
+	room.RUnlock()
+	if participant == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Session not found in this room"})
+		return
+	}
+	var req struct {
+		Offer  map[string]interface{} `json:"offer"`
+		Tracks []struct {
+			TrackName string `json:"trackName"`
+			Mid       string `json:"mid"` // Thêm mid
+			Location  string `json:"location"`
+		} `json:"tracks"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if debug {
+		log.Printf("Publishing tracks for session %s: %+v\n", sessionId, req.Tracks)
+	}
+	// Prepare track data for Cloudflare API
+	tracks := make([]map[string]interface{}, len(req.Tracks))
+	trackNames := make([]string, len(req.Tracks))
+	for i, t := range req.Tracks {
+		location := t.Location
+		if location == "" {
+			location = "local"
+		}
+		tracks[i] = map[string]interface{}{
+			"trackName": t.TrackName,
+			"location":  location,
+			"mid":       t.Mid,
+		}
+		trackNames[i] = t.TrackName
+	}
+	// Call Cloudflare API
+	requestBody := map[string]interface{}{
+		"sessionDescription": req.Offer,
+		"tracks":             tracks,
+	}
+	url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
+	jsonData, err := json.Marshal(requestBody)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	cfReq, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	cfReq.Header.Set("Authorization", "Bearer "+cloudflareAppSecret)
+	cfReq.Header.Set("Content-Type", "application/json")
+	client := &http.Client{}
+	resp, err := client.Do(cfReq)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	defer resp.Body.Close()
+	var data map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	// Update participant's published tracks
+	room.Lock()
+	for _, t := range req.Tracks {
+		if !contains(participant.PublishedTracks, t.TrackName) {
+			participant.PublishedTracks = append(participant.PublishedTracks, t.TrackName)
+		}
+	}
+	room.Unlock()
+	// Broadcast track-published event with complete information
+	if data["sessionDescription"] != nil {
+		broadcastToRoom(roomId, gin.H{
+			"type": "track-published",
+			"payload": gin.H{
+				"userId":    participant.UserID,
+				"sessionId": sessionId,
+				"tracks":    trackNames,
+			},
+		}, participant.UserID)
+		if debug {
+			log.Printf("Track published event broadcasted for session %s with tracks: %v\n", sessionId, trackNames)
+		}
+	}
+	c.JSON(http.StatusOK, data)
+}
+// Helper function to check if slice contains string
+func contains(slice []string, str string) bool {
+	for _, v := range slice {
+		if v == str {
+			return true
+		}
+	}
+	return false
 }
 func unpublishTrack(c *gin.Context) {
 	}
 	var req struct {
+		TrackName          string                 `json:"trackName"`
+		Mid                string                 `json:"mid"`
+		Force              bool                   `json:"force"`
+		SessionDescription map[string]interface{} `json:"sessionDescription"`
 	}
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
+	//If trying to force unpublish someone else's track
 	if req.Force && sessionId != currentUser.UserID {
+		//Check if user is moderator
 		if !currentUser.IsModerator {
 			c.JSON(http.StatusForbidden, gin.H{
 				"errorCode":        "NOT_AUTHORIZED",
 	if debug {
 		log.Println("Calling Cloudflare API:", cfUrl)
 	}
 	requestBody := map[string]interface{}{
+		"tracks": []map[string]string{
 			{"mid": req.Mid},
 		},
 		"force":              req.Force,
 		"sessionDescription": req.SessionDescription,
 	}
 	if debug {
+		log.Printf("Request body: %+v\n", requestBody) // Use %+v for detailed printing
 	}
 	data, err := unpublishToCloudflare(cfUrl, requestBody)
 	if debug {
 		log.Println("Cloudflare API response:", data)
 	}
 	broadcastToRoom(roomId, gin.H{
 		"type":    "track-unpublished",
 		"payload": gin.H{"sessionId": sessionId, "trackName": req.TrackName},
 	}, sessionId)
 	c.JSON(http.StatusOK, data)
 }
 func pullTracks(c *gin.Context) {
+	roomId := c.Param("roomId")
+	sessionId := c.Param("sessionId")
+	// Struct to hold request body, khớp với frontend JavaScript (_pullTracks)
+	var req struct {
+		RemoteSessionId string `json:"remoteSessionId"` // camelCase, khớp với frontend
+		TrackName       string `json:"trackName"`       // Kéo từng track một
+	}
+	// Bind JSON request body từ request Gin
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	// Lấy thông tin room từ bộ nhớ
+	rooms.RLock()
+	room, ok := rooms.m[roomId]
+	rooms.RUnlock()
+	if !ok {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
+		return
+	}
+	participant := findParticipantBySessionId(room, sessionId)
+	if participant == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Session not found in this room"})
+		return
+	}
+	// Tạo cấu trúc tracksToPull cho Cloudflare API (kéo 1 track)
+	tracksToPull := []map[string]interface{}{
+		{
+			"location":  "remote",
+			"sessionId": req.RemoteSessionId, // Dùng RemoteSessionId từ request struct
+			"trackName": req.TrackName,       // Dùng TrackName từ request struct
+		},
+	}
+	// Gọi Cloudflare API để pull track (dùng hàm makeCloudflareRequest helper)
+	url := fmt.Sprintf("%s/sessions/%s/tracks/new", cloudflareBasePath, sessionId)
+	requestBody := map[string]interface{}{
+		"tracks": tracksToPull,
+	}
+	// Gọi makeCloudflareRequest để thực hiện request đến Cloudflare API
+	data, err, statusCode := makeCloudflareRequest("POST", url, requestBody)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to pull track", "detail": err.Error()})
+		return
+	}
+	// Kiểm tra mã trạng thái lỗi từ Cloudflare API
+	if statusCode >= 400 {
+		c.JSON(statusCode, gin.H{"error": "Cloudflare API error during pull track", "detail": data})
+		return
+	}
+	// Trả về phản hồi từ Cloudflare API cho frontend
+	c.JSON(http.StatusOK, data)
+}
+// Helper function để tìm participant theo sessionId (tái sử dụng từ code của bạn)
+func findParticipantBySessionId(room *Room, sessionId string) *Participant {
+	room.RLock()
+	defer room.RUnlock()
+	for _, p := range room.Participants {
+		if p.SessionID == sessionId {
+			return p
+		}
+	}
+	return nil
 }
 func renegotiateSession(c *gin.Context) {
+	sessionId := c.Param("sessionId")
+	var req struct {
+		SDP     string `json:"sdp"`
+		SDPType string `json:"type"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	sdp := req.SDP
+	sdpType := req.SDPType
+	// var req struct {
+	// 	SessionDescription struct {
+	// 		SDP  string `json:"sdp"`
+	// 		Type string `json:"type"`
+	// 	} `json:"sessionDescription"`
+	// }
+	// if err := c.ShouldBindJSON(&req); err != nil {
+	// 	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	// 	return
+	// }
+	body := map[string]interface{}{
+		"sessionDescription": map[string]string{
+			"sdp":  sdp,
+			"type": sdpType,
+		},
+	}
+	data, err := renegotiateWithCloudflare(sessionId, body)
+	if err != nil {
+		if data != nil && data["errorCode"] != nil { // Check for Cloudflare error
+			c.JSON(http.StatusBadRequest, data)
+			return
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, data)
 }
 func manageDataChannels(c *gin.Context) {
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
+	print(room)
 	rooms.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
 	}
 	cfUrl := fmt.Sprintf("%s/sessions/%s/datachannels/new", cloudflareBasePath, sessionId)
 	dataChannels := make([]map[string]interface{}, len(req.DataChannels))
 	for i, dc := range req.DataChannels {
 		dataChannels[i] = map[string]interface{}{
 			"location":        dc.Location,
+			"dataChannelName": dc.DataChannelName,
 		}
 	}
+	data, err := manageDataChannelsWithCloudflare(cfUrl, dataChannels)
 	if err != nil {
 		if data != nil && data["errorCode"] != nil { // Check for Cloudflare error
 			c.JSON(http.StatusBadRequest, data)
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
 	}
 	room.RUnlock()
+	if participant == nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Participant not found"})
 		return
 	}
 	c.JSON(http.StatusOK, iceServers)
 }
 func getToken(c *gin.Context) {
 	var req struct {
 		Username string `json:"username"`
 		users.RLock()
 		userInfo, ok := users.m[currentUser.UserID]
 		users.RUnlock()
+		if !ok {
 			c.JSON(http.StatusNotFound, gin.H{
 				"errorCode":        "USER_NOT_FOUND",
 				"errorDescription": "Current user not found",
 	users.RLock()
 	requestedUser, ok := users.m[userIdParam]
 	users.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{
 			"errorCode":        "USER_NOT_FOUND",
 			"errorDescription": "User not found",
 	rooms.RLock()
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
 	room, ok := rooms.m[roomId]
 	rooms.RUnlock()
+	if !ok {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Room not found"})
 		return
 	}
 }
 func websocketHandler(c *gin.Context) {
+	if debug {
+		log.Printf("Incoming WebSocket request from: %s\n", c.Request.RemoteAddr)
+	}
+	ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		log.Printf("Failed to upgrade connection: %v\n", err)
+		return
+	}
+	defer ws.Close()
+	handleWebSocket(ws)
 }
 func handleWebSocket(ws *websocket.Conn) {
+	if debug {
+		log.Printf("New WebSocket connection established from: %s\n", ws.RemoteAddr().String())
+	}
+	defer ws.Close()
+	var userId string
+	var roomId string
+	for {
+		// Đọc message
+		messageType, message, err := ws.ReadMessage()
+		log.Println("messageType", messageType)
+		if err != nil {
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+				log.Printf("WebSocket error: %v", err)
+			}
+			handleWSDisconnect(ws, roomId, userId)
+			break
+		}
+		// Parse message
+		var data map[string]interface{}
+		if err := json.Unmarshal(message, &data); err != nil {
+			log.Println("Error parsing message:", err)
+			continue
+		}
+		messageTypeStr, ok := data["type"].(string)
+		if !ok {
+			log.Println("Invalid message format: missing or invalid 'type'")
+			continue
+		}
+		switch messageTypeStr {
+		case "join-websocket":
+			// Format payload giống Express
+			payload := map[string]interface{}{
+				"roomId": data["payload"].(map[string]interface{})["roomId"],
+				"userId": data["payload"].(map[string]interface{})["userId"],
+				"token":  data["payload"].(map[string]interface{})["token"],
+			}
+			handleWSJoin(ws, payload)
+		case "data-message":
+			// Format payload giống Express
+			payload := map[string]interface{}{
+				"from": data["payload"].(map[string]interface{})["from"],
+				"data": data["payload"].(map[string]interface{})["data"],
+			}
+			handleDataMessage(ws, payload)
+		default:
+			log.Println("Unknown message type:", messageTypeStr)
+		}
+	}
 }
 // --- WebSocket Helper Functions ---
 	}, from) // Exclude the sender
 }
+func handleWSDisconnect(ws *websocket.Conn, roomId string, userId string) {
 	wsConnections.Lock()
 	defer wsConnections.Unlock()
+	//remove user from room
+	if _, ok := wsConnections.m[roomId]; ok {
+		delete(wsConnections.m[roomId], userId)
 		if debug {
 			log.Printf("User %s disconnected from room %s\n", userId, roomId)
 		}
 	}
 }
 func broadcastToRoom(roomId string, message gin.H, excludeUserId string) {
+	if debug {
+		log.Printf("Broadcasting to room %s: %+v (excluding: %s)\n", roomId, message, excludeUserId)
+	}
+	rooms.RLock()
+	_, ok := rooms.m[roomId]
+	rooms.RUnlock()
+	if !ok {
+		log.Printf("Room %s not found for broadcast\n", roomId)
+		return
+	}
+	wsConnections.RLock()
+	connections, ok := wsConnections.m[roomId]
+	wsConnections.RUnlock()
+	if !ok {
+		log.Printf("No WebSocket connections found for room %s\n", roomId)
+		return
+	}
+	// Serialize message once
+	msgBytes, err := json.Marshal(message)
+	if err != nil {
+		log.Printf("Error serializing broadcast message: %v\n", err)
+		return
+	}
+	if debug {
+		log.Printf("Serialized message for broadcast: %s\n", string(msgBytes))
+	}
+	wsConnections.RLock()
+	defer wsConnections.RUnlock()
+	for userId, conn := range connections {
+		if userId == excludeUserId {
+			continue
+		}
+		if conn != nil {
+			err := conn.WriteMessage(websocket.TextMessage, msgBytes)
+			if err != nil {
+				log.Printf("Error broadcasting to user %s: %v\n", userId, err)
+				// Clean up failed connection
+				wsConnections.Lock()
+				delete(wsConnections.m[roomId], userId)
+				wsConnections.Unlock()
+			} else if debug {
+				log.Printf("Successfully sent broadcast message to user: %s\n", userId)
+			}
+		}
+	}
 }
 func main() {
+	initConfig() // Initialize configuration
+	r := gin.Default()
+	// CORS middleware (configure as needed)
+	r.Use(func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*") // For development only!
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With, Upgrade, Connection")
+		c.Writer.Header().Set("Access-Control-Max-Age", "3600")
+		// Handle WebSocket pre-flight
+		if c.Request.Method == "OPTIONS" {
+			if c.Request.Header.Get("Upgrade") == "websocket" {
+				c.Writer.Header().Set("Connection", "Upgrade")
+				c.Writer.Header().Set("Upgrade", "websocket")
+			}
+			c.AbortWithStatus(204)
+			return
+		}
+		c.Next()
+	})
+	r.POST("/auth/token", getToken)
+	// Protected routes (require JWT)
+	api := r.Group("/api", verifyToken)
+	{
+		// Match Express routes
+		api.POST("/rooms", createRoom)
+		api.GET("/rooms", getRooms)
+		api.GET("/inspect-rooms", inspectRooms)
+		api.POST("/rooms/:roomId/join", joinRoom)
+		api.POST("/rooms/:roomId/sessions/:sessionId/publish", publishTracks)
+		api.POST("/rooms/:roomId/sessions/:sessionId/unpublish", unpublishTrack)
+		api.POST("/rooms/:roomId/sessions/:sessionId/pull", pullTracks)
+		api.PUT("/rooms/:roomId/sessions/:sessionId/renegotiate", renegotiateSession)
+		api.POST("/rooms/:roomId/sessions/:sessionId/datachannels/new", manageDataChannels)
+		api.GET("/rooms/:roomId/participants", getParticipants)
+		api.GET("/rooms/:roomId/participant/:sessionId/tracks", getParticipantTracks)
+		api.GET("/ice-servers", getICEServers)
+		api.GET("/rooms/:roomId/sessions/:sessionId/state", getSessionState)
+		api.GET("/users/:userId", getUserInfo)
+		api.POST("/rooms/:roomId/leave", leaveRoom)
+		api.POST("/rooms/:roomId/sessions/:sessionId/track-status", updateTrackStatus)
+		api.PUT("/rooms/:roomId/metadata", updateRoomMetadata)
+	}
+	r.GET("/ws", websocketHandler)
+	// Start the server
+	log.Printf("Server listening on http://localhost:%s\n", port)
+	//listen and serve for http
+	if err := r.Run(":" + port); err != nil {
+		log.Fatal("Failed to start server:", err)
+	}
 }

public/js/room.js CHANGED Viewed

@@ -286,6 +286,8 @@ function setupCallbacks() {
             container.appendChild(video);
             container.appendChild(name);
             videoGrid.appendChild(container);
         }
         const video = container.querySelector('video');

             container.appendChild(video);
             container.appendChild(name);
             videoGrid.appendChild(container);
         }
         const video = container.querySelector('video');