initial commit

server/api/live/[id].delete.js

@@ -0,0 +1,35 @@
+import { requireAuth } from '../../utils/authHelpers.js'
+import { getLiveSession, deleteLiveSession } from '../../utils/liveSessions.js'
+import { closeRouter, getProducer, getTransport } from '../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event)
+  const id = event.context.params?.id
+  if (!id) throw createError({ statusCode: 400, message: 'id required' })
+
+  const session = getLiveSession(id)
+  if (!session) throw createError({ statusCode: 404, message: 'Live session not found' })
+  if (session.userId !== user.id) throw createError({ statusCode: 403, message: 'Forbidden' })
+
+  // Clean up producer if it exists
+  if (session.producerId) {
+    const producer = getProducer(session.producerId)
+    if (producer) {
+      producer.close()
+    }
+  }
+
+  // Clean up transport if it exists
+  if (session.transportId) {
+    const transport = getTransport(session.transportId)
+    if (transport) {
+      transport.close()
+    }
+  }
+
+  // Clean up router
+  await closeRouter(id)
+
+  deleteLiveSession(id)
+  return { ok: true }
+})

server/api/live/[id].patch.js

@@ -0,0 +1,31 @@
+import { requireAuth } from '../../utils/authHelpers.js'
+import { getLiveSession, updateLiveSession } from '../../utils/liveSessions.js'
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event)
+  const id = event.context.params?.id
+  if (!id) throw createError({ statusCode: 400, message: 'id required' })
+
+  const session = getLiveSession(id)
+  if (!session) throw createError({ statusCode: 404, message: 'Live session not found' })
+  if (session.userId !== user.id) throw createError({ statusCode: 403, message: 'Forbidden' })
+
+  const body = await readBody(event).catch(() => ({}))
+  const lat = Number(body?.lat)
+  const lng = Number(body?.lng)
+  const updates = {}
+  if (Number.isFinite(lat)) updates.lat = lat
+  if (Number.isFinite(lng)) updates.lng = lng
+  if (Object.keys(updates).length) {
+    updateLiveSession(id, updates)
+  }
+
+  const updated = getLiveSession(id)
+  return {
+    id: updated.id,
+    label: updated.label,
+    lat: updated.lat,
+    lng: updated.lng,
+    updatedAt: updated.updatedAt,
+  }
+})

server/api/live/debug-request-host.get.js

@@ -0,0 +1,15 @@
+import { getRequestHost, getRequestURL } from 'h3'
+import { requireAuth } from '../../utils/authHelpers.js'
+
+/**
+ * Diagnostic: returns the host the server sees for this request.
+ * Use from the phone or laptop to verify the server receives the expected hostname (e.g. LAN IP).
+ * Auth required.
+ */
+export default defineEventHandler((event) => {
+  requireAuth(event)
+  return {
+    host: getRequestHost(event),
+    hostname: getRequestURL(event).hostname,
+  }
+})

server/api/live/start.post.js

@@ -0,0 +1,40 @@
+import { requireAuth } from '../../utils/authHelpers.js'
+import {
+  createSession,
+  getActiveSessionByUserId,
+  deleteLiveSession,
+} from '../../utils/liveSessions.js'
+import { closeRouter, getProducer, getTransport } from '../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event, { role: 'adminOrLeader' })
+  const body = await readBody(event).catch(() => ({}))
+  const label = typeof body?.label === 'string' ? body.label.trim() : ''
+
+  // Replace any existing live session for this user (one session per user)
+  const existing = getActiveSessionByUserId(user.id)
+  if (existing) {
+    if (existing.producerId) {
+      const producer = getProducer(existing.producerId)
+      if (producer) producer.close()
+    }
+    if (existing.transportId) {
+      const transport = getTransport(existing.transportId)
+      if (transport) transport.close()
+    }
+    if (existing.routerId) {
+      await closeRouter(existing.id).catch((err) => {
+        console.error('[live.start] Error closing previous router:', err)
+      })
+    }
+    deleteLiveSession(existing.id)
+    console.log('[live.start] Replaced previous session:', existing.id)
+  }
+
+  const session = createSession(user.id, label || `Live: ${user.identifier || 'User'}`)
+  console.log('[live.start] Session created:', { id: session.id, userId: user.id, label: session.label })
+  return {
+    id: session.id,
+    label: session.label,
+  }
+})

server/api/live/webrtc/connect-transport.post.js

@@ -0,0 +1,34 @@
+import { requireAuth } from '../../../utils/authHelpers.js'
+import { getLiveSession } from '../../../utils/liveSessions.js'
+import { getTransport } from '../../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  requireAuth(event) // Verify authentication
+  const body = await readBody(event).catch(() => ({}))
+  const { sessionId, transportId, dtlsParameters } = body
+
+  if (!sessionId || !transportId || !dtlsParameters) {
+    throw createError({ statusCode: 400, message: 'sessionId, transportId, and dtlsParameters required' })
+  }
+
+  const session = getLiveSession(sessionId)
+  if (!session) {
+    throw createError({ statusCode: 404, message: 'Session not found' })
+  }
+  // Note: Both publisher and viewers can connect their own transports
+  // The transportId ensures they can only connect transports they created
+
+  const transport = getTransport(transportId)
+  if (!transport) {
+    throw createError({ statusCode: 404, message: 'Transport not found' })
+  }
+
+  try {
+    await transport.connect({ dtlsParameters })
+    return { connected: true }
+  }
+  catch (err) {
+    console.error('[connect-transport] Transport connect failed:', transportId, err.message || err)
+    throw createError({ statusCode: 500, message: err.message || 'Transport connect failed' })
+  }
+})

server/api/live/webrtc/create-consumer.post.js

@@ -0,0 +1,55 @@
+import { requireAuth } from '../../../utils/authHelpers.js'
+import { getLiveSession } from '../../../utils/liveSessions.js'
+import { getRouter, getTransport, getProducer, createConsumer } from '../../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  requireAuth(event) // Verify authentication
+  const body = await readBody(event).catch(() => ({}))
+  const { sessionId, transportId, rtpCapabilities } = body
+
+  if (!sessionId || !transportId || !rtpCapabilities) {
+    throw createError({ statusCode: 400, message: 'sessionId, transportId, and rtpCapabilities required' })
+  }
+
+  const session = getLiveSession(sessionId)
+  if (!session) {
+    throw createError({ statusCode: 404, message: `Session not found: ${sessionId}` })
+  }
+  if (!session.producerId) {
+    throw createError({ statusCode: 404, message: 'No producer available for this session' })
+  }
+
+  const transport = getTransport(transportId)
+  if (!transport) {
+    throw createError({ statusCode: 404, message: `Transport not found: ${transportId}` })
+  }
+
+  const producer = getProducer(session.producerId)
+  if (!producer) {
+    console.error('[create-consumer] Producer not found:', session.producerId)
+    throw createError({ statusCode: 404, message: `Producer not found: ${session.producerId}` })
+  }
+
+  if (producer.paused) {
+    await producer.resume()
+  }
+
+  if (producer.closed) {
+    throw createError({ statusCode: 404, message: 'Producer is closed' })
+  }
+
+  const router = await getRouter(sessionId)
+  const canConsume = router.canConsume({ producerId: producer.id, rtpCapabilities })
+  if (!canConsume) {
+    throw createError({ statusCode: 400, message: 'Cannot consume this producer' })
+  }
+
+  try {
+    const { params } = await createConsumer(transport, producer, rtpCapabilities)
+    return params
+  }
+  catch (err) {
+    console.error('[create-consumer] Error creating consumer:', err)
+    throw createError({ statusCode: 500, message: `Failed to create consumer: ${err.message || String(err)}` })
+  }
+})

server/api/live/webrtc/create-producer.post.js

@@ -0,0 +1,43 @@
+import { requireAuth } from '../../../utils/authHelpers.js'
+import { getLiveSession, updateLiveSession } from '../../../utils/liveSessions.js'
+import { getTransport, producers } from '../../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event)
+  const body = await readBody(event).catch(() => ({}))
+  const { sessionId, transportId, kind, rtpParameters } = body
+
+  if (!sessionId || !transportId || !kind || !rtpParameters) {
+    throw createError({ statusCode: 400, message: 'sessionId, transportId, kind, and rtpParameters required' })
+  }
+
+  const session = getLiveSession(sessionId)
+  if (!session) {
+    throw createError({ statusCode: 404, message: 'Session not found' })
+  }
+  if (session.userId !== user.id) {
+    throw createError({ statusCode: 403, message: 'Forbidden' })
+  }
+
+  const transport = getTransport(transportId)
+  if (!transport) {
+    throw createError({ statusCode: 404, message: 'Transport not found' })
+  }
+
+  const producer = await transport.produce({ kind, rtpParameters })
+  producers.set(producer.id, producer)
+  producer.on('close', () => {
+    producers.delete(producer.id)
+    const s = getLiveSession(sessionId)
+    if (s && s.producerId === producer.id) {
+      updateLiveSession(sessionId, { producerId: null })
+    }
+  })
+
+  updateLiveSession(sessionId, { producerId: producer.id })
+
+  return {
+    id: producer.id,
+    kind: producer.kind,
+  }
+})

server/api/live/webrtc/create-transport.post.js

@@ -0,0 +1,39 @@
+import { getRequestURL } from 'h3'
+import { requireAuth } from '../../../utils/authHelpers.js'
+import { getLiveSession, updateLiveSession } from '../../../utils/liveSessions.js'
+import { getRouter, createTransport } from '../../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event)
+  const body = await readBody(event).catch(() => ({}))
+  const { sessionId, isProducer } = body
+
+  if (!sessionId) {
+    throw createError({ statusCode: 400, message: 'sessionId required' })
+  }
+
+  const session = getLiveSession(sessionId)
+  if (!session) {
+    throw createError({ statusCode: 404, message: 'Session not found' })
+  }
+
+  // Only publisher (session owner) can create producer transport
+  // Viewers can create consumer transports
+  if (isProducer && session.userId !== user.id) {
+    throw createError({ statusCode: 403, message: 'Forbidden' })
+  }
+
+  const url = getRequestURL(event)
+  const requestHost = url.hostname
+  const router = await getRouter(sessionId)
+  const { transport, params } = await createTransport(router, Boolean(isProducer), requestHost)
+
+  if (isProducer) {
+    updateLiveSession(sessionId, {
+      transportId: transport.id,
+      routerId: router.id,
+    })
+  }
+
+  return params
+})

server/api/live/webrtc/router-rtp-capabilities.get.js

@@ -0,0 +1,20 @@
+import { requireAuth } from '../../../utils/authHelpers.js'
+import { getLiveSession } from '../../../utils/liveSessions.js'
+import { getRouter } from '../../../utils/mediasoup.js'
+
+export default defineEventHandler(async (event) => {
+  requireAuth(event)
+  const sessionId = getQuery(event).sessionId
+
+  if (!sessionId) {
+    throw createError({ statusCode: 400, message: 'sessionId required' })
+  }
+
+  const session = getLiveSession(sessionId)
+  if (!session) {
+    throw createError({ statusCode: 404, message: 'Session not found' })
+  }
+
+  const router = await getRouter(sessionId)
+  return router.rtpCapabilities
+})