live-platform

Una llamada en el navegador que comparte pantalla, voz y cámara desde un enlace, servida por un único binario Go con su propio servidor de medios WebRTC.

Go · TypeScriptversatile.shcódigo abierto (GPL-3.0-or-later)Servidor Go 1.27.4, Pion SFU, gnetCliente React 19, Vite, Tailwind 4Licencia GPL-3.0-or-laterUnidad de despliegue un contenedor, sin base de datosgithub.com/versatile-sh/live-platform
sfu

Visión general

live-platform es una llamada en el navegador para quien necesita mostrarle algo a alguien ahora mismo: una sesión de pair programming, un vistazo rápido a una pantalla, una llamada con un amigo que no tiene cuenta en ningún sitio. La sala es la dirección, y quien abre un nombre libre es el dueño de esa sala. Sin cuenta, nada que instalar.

Un proceso Go sirve la página, la señalización y su propia unidad de reenvío selectivo (SFU) construida sobre Pion. Los medios no pasan por un servicio alojado ni usan una malla peer-to-peer, donde cada persona subiría una copia por oyente.

Es deliberadamente acotado. No es un producto de grabación ni de transcripción, y todavía no tiene cifrado de extremo a extremo. La sección de seguridad lista lo que está construido y lo que no.

DatoValor
Tamaño de la salaHasta 10 personas
Liberación de la sala30 segundos después de que salga la última persona
AccesoPública (enlace) o privada (código de sala); cualquiera puede aparecer en el lobby
MediosMicrófono, cámara, pantalla con su sonido, push to talk, desenfoque de fondo
ExtrasChat, mano levantada, pizarra Excalidraw, controles del dueño
IdiomasInglés y portugués, según el navegador

Ejecutarlo

Requiere Go 1.27.4, Node.js 26 y un navegador con WebRTC. Dos terminales; el servidor de desarrollo de Vite hace proxy de /api a 127.0.0.1:8080 y de /ws a 127.0.0.1:8081.

Desarrollosh
cd server
PUBLIC_ORIGIN=http://localhost:5173 go run ./cmd/live

cd web
npm ci
npm run dev        # http://localhost:5173

Abre http://localhost:5173/any-name en dos pestañas para probar una llamada. Para servir todo desde un único binario:

Binario únicosh
cd web && npm ci && npm run build
cd ../server && CGO_ENABLED=0 go build -trimpath -o live ./cmd/live
WEB_DIR=../web/dist ./live        # page and API on :8080; GET /up answers 200

Sin WEB_DIR el servidor responde solo la API. La página y la señalización usan puertos distintos, así que frente a un navegador ambos deben quedar detrás de un único origen. El Dockerfile construye un binario estático sobre distroless, sin root, con PORT=3000, SIGNAL_PORT=3001 y WEB_DIR=/web.

Comprobacionessh
mise install        # pinned Go, golangci-lint, vlint, revive
lefthook install    # fast lint on commit, changed-package lint on push
mise run check      # lint-full, race tests, Semgrep
mise run test       # go test -race -count=1 ./...
cd web && npx vitest run
cd web && npm run test:live   # client against a real server
VariablePor defectoEfecto
PORT8080 (3000 en la imagen)HTTP: página, API y /up
SIGNAL_PORT8081 (3001 en la imagen)WebSocket de señalización en /ws
PUBLIC_ORIGINvacíoOrígenes autorizados a abrir el socket; vacío permite solo el host de la propia petición
WEB_DIRvacío (/web en la imagen)Cliente compilado; vacío sirve solo la API
WEB_LIVE_DIRvacíoDirectorio superpuesto a WEB_DIR para servir un cliente más nuevo sin reiniciar
MEDIAonoff ejecuta presencia y chat sin el SFU
MEDIA_UDP_PORT0Un puerto UDP compartido para todos los medios; 0 deja que cada conexión elija el suyo
MEDIA_PUBLIC_IPvacíoDirección anunciada a los navegadores detrás de NAT
HANDOVER_DIRvacíoDirectorio compartido con el siguiente proceso en reinicios planificados
AUDIT_DIRvacíoDirectorio del registro de auditoría; vacío lo desactiva
AUDIT_RETENTION_DAYS183Días de archivos de auditoría que se conservan
OTEL_EXPORTER_OTLP_ENDPOINTvacíoColector OTLP/HTTP; vacío desactiva el tracing

Todo se lee del entorno una sola vez, al arrancar. Un valor que no se puede interpretar detiene el servidor y nombra el ajuste.

Arquitectura

Un binario, tres listeners. HTTP sirve el cliente compilado y una pequeña API JSON. Un event loop de gnet transporta el WebSocket lv.1. Pion transporta los medios por UDP con DTLS-SRTP, directamente entre navegador y servidor.

text
Browser (React 19)                     live (one Go process)
+----------------------+  HTTPS        +---------------------------+
| pages and stores     |-------------->| net/http   page, /api     |
|                      |  WSS /ws      +---------------------------+
|                      |-------------->| gnet + gobwas/ws  lv.1    |
|                      |               |        |                  |
|                      |               |  presence hub             |
|                      |               |  one actor per room       |
|                      |               |        |                  |
| publish PeerConn     |  UDP, DTLS    |  Pion SFU                 |
| subscribe PeerConn   |<=============>|                           |
+----------------------+  SRTP         +---------------------------+
ListenerBibliotecaTransporta
HTTP (PORT)net/httpcliente, GET /api/rooms/{slug}, /api/lobby, /api/project, /api/pass/{id}, /up
Señalización (SIGNAL_PORT)gnet + gobwas/wslv.1: presencia, chat, pizarra, acciones del dueño, SDP e ICE
Medios (MEDIA_UDP_PORT)Pion WebRTCRTP sobre DTLS-SRTP

El servidor sigue puertos y adaptadores, con las dependencias apuntando hacia dentro.

text
server/
  cmd/live/            binary; `live audit` reads the audit trail
  app/                 composition root: env read and checked once
  core/room/           Room aggregate. Pure: no clock, no I/O
  port/inbound|outbound/
  service/presence/    hub + one goroutine per room
  signal/              lv.1 over WebSocket on gnet
  httpapi/  page/      JSON routes; client with security headers
  sfu/                 Pion media engine
  handoff/  audit/  guestpass/  clientinfo/  github/

El cliente vive en web/src, una carpeta por responsabilidad: room, media, signal, session, lobby, board, domain, ui, i18n. No usa router ni librería de estado; tres páginas y un store por responsabilidad no los necesitan.

Flujo de entrada

linkseat
Un enlace es una entrada: el invitado cruza la puerta, la sala le asigna un asiento y todos los de dentro se enteran.
  1. 1Abrir el socketEl navegador abre el WebSocket lv.1 y envía join. El socket acepta solo los orígenes configurados.
  2. 2Reclamar un asientoEl servidor de señalización pasa el frame al hub de presencia. El actor de la sala reclama un asiento.
  3. 3Recibir el estadoEl navegador recibe joined con su asiento, generación y secreto de reanudación, y después todo el roster con un número de versión.
  4. 4Negociar la publicaciónEl navegador envía su SDP offer por el mismo socket en un frame rtc. El hub negocia con el SFU la conexión de publicación.
  5. 5Enviar mediosLos medios van directo al SFU por UDP. El SFU reenvía los paquetes, sin decodificar, a todos los demás.
  6. 6Difundir cambiosCada cambio en la sala envía a todos un roster completo nuevo.

Cada participante mantiene dos conexiones peer: una publica, otra recibe a todos los demás. Los tracks reenviados se nombran por quién los envió y qué son (micrófono, cámara, pantalla, sonido de pantalla), según las fuentes que declaró el publicador.

Presencia

roster4 s?hereunsureheld
El roster es del servidor: un invitado callado pasa a inestable, uno que recarga conserva su asiento retenido y un temporizador decide a quién se retira.

El servidor es la única autoridad sobre quién está en una sala. Los navegadores solo informan. Vigila tres señales: el socket, un heartbeat y la ruta de medios.

  1. 1Primera señal perdidaLos demás ven al participante como inestable.
  2. 2Tras 4 segundos de graciaEl participante aparece como reconectando.
  3. 3Sin regresoSe retira al participante. Salir a propósito es inmediato.

Recargar conserva el asiento. El navegador guarda un secreto por sala durante la vida de la pestaña y lo presenta para reanudar. El secreto rota en cada reanudación y el anterior se rechaza.

En un reinicio planificado, el servidor que se detiene puede escribir sus salas en HANDOVER_DIR. El nuevo proceso las adopta y retiene cada asiento 12 segundos mientras los navegadores se reconectan. Un crash pierde las salas.

Modelo de sala

Todo cambio en una sala pasa por su actor, en orden, así que no hay locks alrededor del estado de la sala. Al agregado Room de core/room se le da la hora y responde con lo que cambió. No tiene reloj ni I/O, así que cada regla de presencia es un test unitario simple.

  • Los asientos son un bitmap uint64.
  • Lo que un participante tiene activo (micrófono, cámara, pantalla, audio de pantalla, mano, dueño, inestable) es un uint16 de flags.
  • Los rosters se envían completos, con número de versión, nunca como diff. Un navegador que perdió un mensaje queda al día en el siguiente.
  • Cada sala publica un resumen atómico, así que listar el lobby nunca bloquea sobre la goroutine de una sala.

La derivación del código de sala en salas privadas se trata en Seguridad. El agregado de sala guarda las reglas del dueño: transferir, expulsar, banear, silenciar a todos, hablar por mano levantada, cambios de acceso y de listado.

Protocolo lv.1

Frames de texto JSON sobre un WebSocket, cada uno con su tipo en t.

DirecciónFrames
Navegador a servidorjoin, resume, hb, leave, media, rtc, look, photo, chat, board, owner, remove, ban, transfer, listed, password
Servidor a navegadorjoined, roster (versionado, completo), rtc, chat, photo, board, error

Los códigos de cierre de la aplicación le dicen al navegador por qué terminó un socket.

CódigoSignificado
4001Reemplazado por otra pestaña
4012Servidor reiniciando
4400Frame inválido
4401Sin hello
4403Expulsado
4404Baneado
4408Silencioso
4409Demasiado lento para leer
4429Inundación

Límites de señalización: 128 KiB por frame, 2 MiB de datos sin enviar, 20 frames por segundo con una ráfaga de 80. Un cliente que los supera se desconecta con un código que dice por qué.

Ruta de medios

sfu
El SFU es una oficina de correos: cada track que envía un invitado se reenvía, sin abrir, a todos los demás.
  • El SFU reenvía RTP sin decodificarlo.
  • Los códecs son los por defecto de Pion. El servidor pide a los publicadores un keyframe cada 2 segundos para que quien entra tarde vea imagen rápido.
  • Sin simulcast ni reenvío bajo demanda: cada stream llega a todos con la calidad con que se envió.
  • El procesamiento de audio corre solo en el navegador: RNNoise para el filtro de voz más fuerte, más ganancia, una noise gate y cancelación de eco. El desenfoque de fondo ejecuta MediaPipe en el navegador.
  • Un puerto UDP para todos los medios cuando MEDIA_UDP_PORT está definido, anunciado en MEDIA_PUBLIC_IP.
  • No hay relay TURN, así que una red que bloquea UDP no puede transportar medios.

Como cada stream se reenvía a todos los demás participantes, el upload del servidor crece con el cuadrado del tamaño de la sala. El tope de 10 por sala lo acota.

La pizarra es Excalidraw, fijada en una versión y cargada solo al abrirla. Vive en los navegadores; el servidor retransmite sus piezas sin leerlas y no guarda nada.

Modelo de seguridad

En una sala privada el navegador deriva 64 bytes del código de sala con PBKDF2-SHA-256 a 600.000 iteraciones, con la dirección de la sala como sal. Los primeros 32 bytes son un verificador enviado al servidor, que guarda solo su SHA-256. Los otros 32 quedan reservados como clave de medios y nunca salen del navegador. Un enlace compartido lleva el código tras #, que los navegadores no envían. Diez intentos erróneos bloquean la puerta durante cinco minutos.

  • CSP: default-src 'none', scripts, estilos, fuentes y conexiones del propio origen, sin script ni estilo inline. 'wasm-unsafe-eval' se permite para el filtro de voz y el desenfoque.
  • Cadena de suministro: versiones exactas, lockfiles versionados, scripts de instalación de npm desactivados, imágenes base y acciones de CI fijadas por digest, Dependabot, govulncheck, go mod verify, npm audit y un SBOM CycloneDX para servidor y cliente.
  • Imagen: distroless, estática, sin root.
  • Auditoría: sin AUDIT_DIR el servidor no registra nada. Con él, una línea JSON por hecho va a un archivo diario, borrado tras AUDIT_RETENTION_DAYS. El texto del chat de una sala pública se registra; el chat de una sala privada guarda solo quién, cuándo y longitud.
  • Los spans de tracing llevan el nombre de la sala y flags, nunca una dirección, un nombre ni texto de chat.

Sin cifrado de extremo a extremo. Los medios se cifran entre cada navegador y el servidor (DTLS-SRTP) y el servidor podría leerlos. El chat, los mensajes privados y la pizarra pasan por el servidor en claro.

Decisiones

DecisiónElegidoDescartadoPor qué
Topología de mediosSFU propio sobre Pion para cada salaMalla; SFU alojadoUna malla cuesta a cada persona un upload por oyente; un SFU alojado pone los medios en el servidor de otro.
SeñalizaciónEvent loop de gnetWebSocket de net/http simpleMantiene muchos sockets inactivos de forma barata. Transporta solo señalización.
Página y APInet/httpUn frameworkNada aquí necesita más.
Estado del clienteSin router ni librería de estadoRouter y store globalTres páginas y un store por responsabilidad no los necesitan.
Estado de la salaUn actor por salaEstado compartido con locksCambios ordenados, agregado puro, tests unitarios simples.
Sincronización del rosterRoster completo, versionadoDiffsUn mensaje perdido se corrige en el siguiente.
  • Todavía sin cifrado de extremo a extremo; la clave de medios derivada queda reservada para él.
  • Sin relay TURN: las redes que bloquean UDP no reciben medios.
  • Sin simulcast ni reenvío bajo demanda: los streams ocultos igualmente llegan al cliente.
  • Las salas sobreviven solo a un handover planificado, no a un crash.
  • No construido: grabación, transcripción, extensiones.

Archivos