add ci (#1)

Co-authored-by: Madison Grubb <madison@elastiflow.com>
Reviewed-on: #1

server/utils/mediasoup.js

@@ -1,21 +1,18 @@
-/**
- * Mediasoup SFU (Selective Forwarding Unit) setup and management.
- * Handles WebRTC router, transport, producer, and consumer creation.
- */
-
 import os from 'node:os'
 import mediasoup from 'mediasoup'
 
 let worker = null
-const routers = new Map() // sessionId -> Router
-const transports = new Map() // transportId -> WebRtcTransport
-export const producers = new Map() // producerId -> Producer
+const routers = new Map()
+const transports = new Map()
+export const producers = new Map()
 
-/**
- * Initialize Mediasoup worker (singleton).
- * @returns {Promise<mediasoup.types.Worker>} The Mediasoup worker.
- */
-export async function getWorker() {
+const MEDIA_CODECS = [
+  { kind: 'video', mimeType: 'video/H264', clockRate: 90000, parameters: { 'packetization-mode': 1, 'profile-level-id': '42e01f' } },
+  { kind: 'video', mimeType: 'video/VP8', clockRate: 90000 },
+  { kind: 'video', mimeType: 'video/VP9', clockRate: 90000 },
+]
+
+export const getWorker = async () => {
   if (worker) return worker
   worker = await mediasoup.createWorker({
     logLevel: process.env.NODE_ENV === 'development' ? 'debug' : 'warn',
@@ -30,50 +27,15 @@ export async function getWorker() {
   return worker
 }
 
-/**
- * Create or get a router for a live session.
- * @param {string} sessionId
- * @returns {Promise<mediasoup.types.Router>} Router for the session.
- */
-export async function getRouter(sessionId) {
-  if (routers.has(sessionId)) {
-    return routers.get(sessionId)
-  }
-  const w = await getWorker()
-  const router = await w.createRouter({
-    mediaCodecs: [
-      {
-        kind: 'video',
-        mimeType: 'video/H264',
-        clockRate: 90000,
-        parameters: {
-          'packetization-mode': 1,
-          'profile-level-id': '42e01f',
-        },
-      },
-      {
-        kind: 'video',
-        mimeType: 'video/VP8',
-        clockRate: 90000,
-      },
-      {
-        kind: 'video',
-        mimeType: 'video/VP9',
-        clockRate: 90000,
-      },
-    ],
-  })
+export const getRouter = async (sessionId) => {
+  const existing = routers.get(sessionId)
+  if (existing) return existing
+  const router = await (await getWorker()).createRouter({ mediaCodecs: MEDIA_CODECS })
   routers.set(sessionId, router)
   return router
 }
 
-/**
- * True if the string is a valid IPv4 address (numeric a.b.c.d, each octet 0-255).
- * Used to accept request Host as announced IP only when it's safe (no hostnames/DNS rebinding).
- * @param {string} host
- * @returns {boolean} True if host is a valid IPv4 address.
- */
-function isIPv4(host) {
+const isIPv4 = (host) => {
   if (typeof host !== 'string' || !host) return false
   const parts = host.split('.')
   if (parts.length !== 4) return false
@@ -84,45 +46,24 @@ function isIPv4(host) {
   return true
 }
 
-/**
- * First non-internal IPv4 from network interfaces (no env read).
- * @returns {string | null} First non-internal IPv4 address or null.
- */
-function getAnnouncedIpFromInterfaces() {
-  const ifaces = os.networkInterfaces()
-  for (const addrs of Object.values(ifaces)) {
+const getAnnouncedIpFromInterfaces = () => {
+  for (const addrs of Object.values(os.networkInterfaces())) {
     if (!addrs) continue
     for (const addr of addrs) {
-      if (addr.family === 'IPv4' && !addr.internal) {
-        return addr.address
-      }
+      if (addr.family === 'IPv4' && !addr.internal) return addr.address
     }
   }
   return null
 }
 
-/**
- * Resolve announced IP: env override, then request host if IPv4, then auto-detect. Pure and deterministic.
- * @param {string | undefined} requestHost - Host header from the client.
- * @returns {string | null} The IP to announce in ICE, or null for localhost-only.
- */
-function resolveAnnouncedIp(requestHost) {
+const resolveAnnouncedIp = (requestHost) => {
   const envIp = process.env.MEDIASOUP_ANNOUNCED_IP?.trim()
   if (envIp) return envIp
   if (requestHost && isIPv4(requestHost)) return requestHost
   return getAnnouncedIpFromInterfaces()
 }
 
-/**
- * Create a WebRTC transport for a router.
- * @param {mediasoup.types.Router} router
- * @param {boolean} _isProducer - true for publisher, false for consumer (reserved for future use)
- * @param {string} [requestHost] - Hostname from the request (e.g. getRequestURL(event).hostname). If a valid IPv4, used as announced IP so the client can reach the server.
- * @returns {Promise<{ transport: mediasoup.types.WebRtcTransport, params: object }>} Transport and connection params.
- */
-// eslint-disable-next-line no-unused-vars
-export async function createTransport(router, _isProducer = false, requestHost = undefined) {
-  // LAN first so the phone (and remote viewers) try the reachable IP before 127.0.0.1 (loopback on the client).
+export const createTransport = async (router, requestHost = undefined) => {
   const announcedIp = resolveAnnouncedIp(requestHost)
   const listenIps = announcedIp
     ? [{ ip: '0.0.0.0', announcedIp }, { ip: '127.0.0.1' }]
@@ -138,10 +79,10 @@ export async function createTransport(router, _isProducer = false, requestHost =
     console.error('[mediasoup] Transport creation failed:', err)
     throw new Error(`Failed to create transport: ${err.message || String(err)}`)
   })
+
   transports.set(transport.id, transport)
-  transport.on('close', () => {
-    transports.delete(transport.id)
-  })
+  transport.on('close', () => transports.delete(transport.id))
+
   return {
     transport,
     params: {
@@ -153,61 +94,22 @@ export async function createTransport(router, _isProducer = false, requestHost =
   }
 }
 
-/**
- * Get transport by ID.
- * @param {string} transportId
- * @returns {mediasoup.types.WebRtcTransport | undefined} Transport or undefined.
- */
-export function getTransport(transportId) {
-  return transports.get(transportId)
-}
+export const getTransport = transportId => transports.get(transportId)
 
-/**
- * Create a producer (publisher's video track).
- * @param {mediasoup.types.WebRtcTransport} transport
- * @param {MediaStreamTrack} track
- * @returns {Promise<mediasoup.types.Producer>} The producer.
- */
-export async function createProducer(transport, track) {
+export const createProducer = async (transport, track) => {
   const producer = await transport.produce({ track })
   producers.set(producer.id, producer)
-  producer.on('close', () => {
-    producers.delete(producer.id)
-  })
+  producer.on('close', () => producers.delete(producer.id))
   return producer
 }
 
-/**
- * Get producer by ID.
- * @param {string} producerId
- * @returns {mediasoup.types.Producer | undefined} Producer or undefined.
- */
-export function getProducer(producerId) {
-  return producers.get(producerId)
-}
+export const getProducer = producerId => producers.get(producerId)
 
-/**
- * Get transports Map (for cleanup).
- * @returns {Map<string, mediasoup.types.WebRtcTransport>} Map of transport ID to transport.
- */
-export function getTransports() {
-  return transports
-}
+export const getTransports = () => transports
 
-/**
- * Create a consumer (viewer subscribes to producer's stream).
- * @param {mediasoup.types.WebRtcTransport} transport
- * @param {mediasoup.types.Producer} producer
- * @param {boolean} rtpCapabilities
- * @returns {Promise<{ consumer: mediasoup.types.Consumer, params: object }>} Consumer and connection params.
- */
-export async function createConsumer(transport, producer, rtpCapabilities) {
-  if (producer.closed) {
-    throw new Error('Producer is closed')
-  }
-  if (producer.paused) {
-    await producer.resume()
-  }
+export const createConsumer = async (transport, producer, rtpCapabilities) => {
+  if (producer.closed) throw new Error('Producer is closed')
+  if (producer.paused) await producer.resume()
 
   const consumer = await transport.consume({
     producerId: producer.id,
@@ -229,11 +131,7 @@ export async function createConsumer(transport, producer, rtpCapabilities) {
   }
 }
 
-/**
- * Clean up router for a session.
- * @param {string} sessionId
- */
-export async function closeRouter(sessionId) {
+export const closeRouter = async (sessionId) => {
   const router = routers.get(sessionId)
   if (router) {
     router.close()
@@ -241,10 +139,4 @@ export async function closeRouter(sessionId) {
   }
 }
 
-/**
- * Get all active routers (for debugging/monitoring).
- * @returns {Array<string>} Session IDs with active routers
- */
-export function getActiveRouters() {
-  return Array.from(routers.keys())
-}
+export const getActiveRouters = () => Array.from(routers.keys())