chore: Clean up webrtc-latency-test directory - remove POC duplications

Removed duplicate files from old WebRTC POC:
- docs/AUTOMATED_TESTING.md, TESTING_INSTRUCTIONS.md
- requirements.txt (old POC dependencies)
- scripts/ (install.sh, start.sh, stop.sh)
- server/ (webrtc-server.py, webrtc-client.html)
- tests/ (test_latency_playwright.py)

Now webrtc-latency-test/ contains ONLY the microservices architecture:
- gateway/ (orchestrator)
- services/ (Whisper, LLM, TTS, MuseTalk)
- shared/proto/ (Protocol Buffers)
- start-all.sh, stop-all.sh (microservices scripts)
- test_latency.py (microservices test)
- docker-compose.yml, README.md, ARCHITECTURE.md

Result: Cleaner, focused project structure for VAST.ai deployment

webrtc-latency-test/docs/AUTOMATED_TESTING.md

@@ -1,391 +0,0 @@
-# 🧪 Teste Automatizado de Latência com Playwright
-
-## 📋 Visão Geral
-
-Este documento descreve como executar testes automatizados de latência usando Playwright headless para medir a performance do servidor WebRTC com um ou múltiplos usuários simultâneos.
-
-## 🎯 Objetivos
-
-- Testar latência de forma automatizada e repetível
-- Medir latência com múltiplos usuários simultâneos
-- Gerar relatórios JSON com métricas detalhadas
-- Validar escalabilidade do servidor
-
-## 📦 Requisitos
-
-### Instalação
-
-```bash
-pip3 install playwright
-playwright install chromium
-```
-
-## 🚀 Como Executar
-
-### Teste com 1 Usuário
-
-```bash
-python3 test_latency_playwright.py 1 true
-```
-
-### Teste com Múltiplos Usuários
-
-```bash
-# 5 usuários simultâneos
-python3 test_latency_playwright.py 5 true
-
-# 10 usuários simultâneos
-python3 test_latency_playwright.py 10 true
-
-# 3 usuários sequencialmente
-python3 test_latency_playwright.py 3 false
-```
-
-### Parâmetros
-
-```bash
-python3 test_latency_playwright.py <num_usuarios> <simultaneo>
-```
-
-- `<num_usuarios>`: Número de usuários para testar (padrão: 1)
-- `<simultaneo>`: `true` para simultâneo, `false` para sequencial (padrão: true)
-
-## 📊 O Que o Teste Faz
-
-### Para Cada Usuário:
-
-1. **Abre navegador headless** (Chromium)
-2. **Navega para o servidor** (mede tempo de navegação)
-3. **Clica em "Conectar"** (mede tempo de conexão)
-4. **Aguarda estabilização** (3 segundos)
-5. **Captura 10 medições de latência**:
-   - Captura timestamp local
-   - Lê timestamp do vídeo do servidor
-   - Calcula diferença (latência)
-6. **Captura FPS final**
-7. **Fecha navegador**
-
-### Métricas Coletadas:
-
-- ✅ Tempo de navegação (page load)
-- ✅ Tempo de conexão WebRTC
-- ✅ Latência (10 medições por usuário)
-  - Média
-  - Mínima
-  - Máxima
-- ✅ FPS (frames por segundo)
-- ✅ Taxa de sucesso de conexão
-
-## 📈 Saída do Teste
-
-### Console:
-
-```
-🎬 Teste Automatizado de Latência WebRTC
-============================================================
-
-🧪 Iniciando teste com 5 usuário(s)...
-Modo: Simultâneo
-Servidor: http://38.117.87.48:9000
-
-Usuário 0: Conectado em 245.32ms
-Usuário 1: Conectado em 278.91ms
-Usuário 2: Conectado em 231.45ms
-Usuário 3: Conectado em 289.12ms
-Usuário 4: Conectado em 254.67ms
-✅ Usuário 0: Latência=267.45ms, FPS=29.8
-✅ Usuário 1: Latência=289.12ms, FPS=28.5
-✅ Usuário 2: Latência=251.34ms, FPS=30.0
-✅ Usuário 3: Latency=298.67ms, FPS=28.9
-✅ Usuário 4: Latência=276.23ms, FPS=29.2
-
-============================================================
-📊 RESULTADOS AGREGADOS
-============================================================
-Usuários testados: 5
-Conexões bem-sucedidas: 5/5
-Taxa de sucesso: 100.0%
-Tempo total do teste: 45.23s
-
-📈 LATÊNCIA
-   Média: 276.56ms
-   Mínima: 251.34ms
-   Máxima: 298.67ms
-   Medidas totais: 50
-
-⏱️  TEMPO DE CONEXÃO
-   Média: 259.89ms
-   Mínima: 231.45ms
-   Máxima: 289.12ms
-
-🎬 FPS
-   Média: 29.3
-   Mínimo: 28.5
-   Máximo: 30.0
-
-🎯 CLASSIFICAÇÃO
-   ✅ BOM (276.56ms) - Ideal para conversação
-============================================================
-
-💾 Resultados salvos em: /root/livekit-poc/latency_test_20251224_143727.json
-
-✅ Teste concluído!
-```
-
-### Arquivo JSON:
-
-```json
-{
-  "test_config": {
-    "num_users": 5,
-    "concurrent": true,
-    "server_url": "http://38.117.87.48:9000",
-    "test_date": "2024-12-24T14:37:27.123456"
-  },
-  "results": {
-    "successful_connections": 5,
-    "success_rate": 100.0,
-    "total_test_time": 45.23,
-    "latency": {
-      "all_measurements": [267.45, 289.12, 251.34, 298.67, 276.23, ...],
-      "avg": 276.56,
-      "min": 251.34,
-      "max": 298.67,
-      "num_measurements": 50
-    },
-    "connection_time": {
-      "all": [245.32, 278.91, 231.45, 289.12, 254.67],
-      "avg": 259.89,
-      "min": 231.45,
-      "max": 289.12
-    },
-    "fps": {
-      "all": [29.8, 28.5, 30.0, 28.9, 29.2],
-      "avg": 29.3,
-      "min": 28.5,
-      "max": 30.0
-    }
-  },
-  "user_results": [...]
-}
-```
-
-## 🔧 Executando Testes
-
-### Opção 1: Via SSH Tunnel (Recomendado)
-
-1. Crie o tunnel SSH em um terminal:
-
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 -L 9000:localhost:9000
-```
-
-2. Em outro terminal, execute o teste:
-
-```bash
-cd /tmp
-python3 test_latency_playwright.py 5 true
-```
-
-**Nota**: O teste usará `http://localhost:9000` por padrão. Para usar o tunnel, edite a linha:
-
-```python
-SERVER_URL = "http://localhost:9000"  # Mude de 38.117.87.48 para localhost
-```
-
-### Opção 2: No Servidor Remoto
-
-1. Copie o script para o servidor:
-
-```bash
-scp -i ~/.ssh/id_rsa -P 43060 test_latency_playwright.py root@38.117.87.48:/root/livekit-poc/
-```
-
-2. Instale Playwright no servidor:
-
-```bash
-ssh -o StrictHostKeyChecking=no -p 43060 root@38.117.87.48
-pip3 install playwright
-playwright install chromium
-```
-
-3. Execute o teste:
-
-```bash
-cd /root/livekit-poc
-python3 test_latency_playwright.py 10 true
-```
-
-### Opção 3: Localmente com Servidor Acessível
-
-Se o servidor for acessível externamente (firewall aberto):
-
-```bash
-python3 test_latency_playwright.py 5 true
-```
-
-## 📊 Interpretação dos Resultados
-
-### Latência
-
-| Latência | Classificação | Uso |
-|----------|--------------|-----|
-| < 100ms | ✅ Excelente | Quase imperceptível |
-| 100-300ms | ✅ Bom | Ideal para conversação |
-| 300-500ms | ⚠️ Aceitável | Pequenos delays possíveis |
-| > 500ms | ❌ Ruim | Latência muito alta |
-
-### FPS
-
-| FPS | Classificação |
-|-----|--------------|
-| 28-30 | ✅ Excelente |
-| 25-27 | ✅ Bom |
-| 20-24 | ⚠️ Aceitável |
-| < 20 | ❌ Ruim |
-
-### Taxa de Sucesso
-
-| Taxa | Classificação |
-|------|--------------|
-| 100% | ✅ Excelente |
-| 90-99% | ✅ Bom |
-| 80-89% | ⚠️ Aceitável |
-| < 80% | ❌ Problemas |
-
-## 🧪 Cenários de Teste
-
-### Teste Básico (1 Usuário)
-```bash
-python3 test_latency_playwright.py 1 true
-```
-**Objetivo**: Validar funcionamento básico do servidor
-
-### Teste de Carga (5 Usuários)
-```bash
-python3 test_latency_playwright.py 5 true
-```
-**Objetivo**: Testar com carga moderada
-
-### Teste de Estresse (10 Usuários)
-```bash
-python3 test_latency_playwright.py 10 true
-```
-**Objetivo**: Testar limite atual do servidor
-
-### Teste Sequencial (3 Usuários)
-```bash
-python3 test_latency_playwright.py 3 false
-```
-**Objetivo**: Testar se servidor se recupera entre conexões
-
-## 📈 Analisando Resultados
-
-### Ler arquivo JSON:
-
-```python
-import json
-
-with open('latency_test_20251224_143727.json', 'r') as f:
-    data = json.load(f)
-
-print(f"Latência média: {data['results']['latency']['avg']:.2f}ms")
-print(f"FPS médio: {data['results']['fps']['avg']:.1f}")
-print(f"Taxa de sucesso: {data['results']['success_rate']:.1f}%")
-```
-
-### Comparar Múltiplos Testes:
-
-```python
-import json
-import glob
-
-files = glob.glob('latency_test_*.json')
-for file in sorted(files):
-    with open(file, 'r') as f:
-        data = json.load(f)
-    print(f"{file}: {data['results']['latency']['avg']:.2f}ms")
-```
-
-## 🔧 Troubleshooting
-
-### Erro: "Page.goto: Timeout 30000ms exceeded"
-
-**Causa**: Servidor não acessível
-**Solução**: 
-- Verifique se servidor está rodando: `ps aux | grep webrtc-server`
-- Use SSH tunnel se firewall bloquear acesso direto
-
-### Erro: "Erro ao conectar"
-
-**Causa**: WebRTC connection falhou
-**Solução**:
-- Verifique logs do servidor: `tail -f /tmp/webrtc.log`
-- Verifique se navegador tem suporte a WebRTC
-
-### Latência muito alta (> 500ms)
-
-**Causas possíveis**:
-- Rede lenta
-- Sobrecarga do servidor
-- Problemas no WebRTC
-
-**Solução**:
-- Execute com menos usuários
-- Verifique recursos do servidor: `top`
-- Teste rede: `ping 38.117.87.48`
-
-## 📝 Relatório de Teste Exemplo
-
-```markdown
-# Relatório de Teste de Latência - 24/12/2024
-
-## Configuração do Teste
-- Usuários: 10
-- Modo: Simultâneo
-- Servidor: http://38.117.87.48:9000
-
-## Resultados
-
-### Latência
-- Média: 289.45ms ✅
-- Mínima: 251.23ms
-- Máxima: 342.67ms
-
-### Conexão
-- Sucesso: 10/10 (100%)
-- Tempo médio: 267.89ms
-
-### Performance
-- FPS médio: 29.1 ✅
-
-## Conclusão
-✅ **APROVADO** - Servidor apresenta latência aceitável para conversação
-   - Latência dentro do esperado (100-300ms)
-   - Taxa de sucesso de 100%
-   - FPS estável em 30
-   - Recomendado para produção até 20 usuários simultâneos
-
-## Recomendações
-1. Monitorar latência com 20+ usuários
-2. Considerar LiveKit Server para escala
-3. Adicionar monitoramento contínuo
-```
-
-## 🚀 Próximos Passos
-
-1. **Automatizar Testes**: Criar cron job para testes periódicos
-2. **Dashboard**: Criar dashboard com histórico de testes
-3. **Alertas**: Configurar alertas para latência > 300ms
-4. **CI/CD**: Integrar testes no pipeline de deploy
-5. **Stress Test**: Testar com 50+ usuários
-
-## 📚 Referências
-
-- [Playwright Documentation](https://playwright.dev/python/)
-- [WebRTC Performance](https://webrtc.org/getting-started/performance)
-- [Latency Best Practices](https://docs.livekit.io/guides/performance)
-
----
-
-**Teste automatizado pronto para uso!** 🎯

webrtc-latency-test/docs/TESTING_INSTRUCTIONS.md

@@ -1,178 +0,0 @@
-# 🎬 Instruções de Teste - WebRTC Latency Test
-
-## ✅ Servidor Ativo
-
-**Status**: 🟢 RODANDO
-**URL**: http://38.117.87.48:9000
-**Porta**: 9000
-
-## 📝 Como Testar
-
-### Opção 1: Acesso Direto (se a porta 9000 estiver aberta no firewall)
-
-Abra seu navegador e acesse:
-```
-http://38.117.87.48:9000
-```
-
-### Opção 2: Via SSH Tunnel (mais seguro)
-
-1. Abra um terminal no seu computador local
-2. Crie o tunnel SSH:
-
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 -L 9000:localhost:9000
-```
-
-3. Mantenha o terminal aberto
-4. Abra seu navegador e acesse:
-```
-http://localhost:9000
-```
-
-## 🧪 Teste de Latência
-
-1. **Conecte**: Clique no botão "Conectar"
-2. **Observe**: O vídeo com timestamps começará a ser exibido
-3. **Meça**: Compare o timestamp no vídeo com o horário local
-
-### Como Calcular a Latência
-
-```
-Latência = Hora Local - Timestamp no Vídeo
-```
-
-Exemplo:
-- Timestamp no vídeo: `14:30:15.500`
-- Hora local ao receber: `14:30:15.750`
-- **Latência: 250ms**
-
-## 📊 Métricas Exibidas
-
-O cliente mostra:
-- **FPS Recebidos**: Frames por segundo no cliente
-- **Frames Totais**: Total de frames recebidos
-- **Tempo Decorrido**: Tempo desde o início da conexão
-- **Latência Estimada**: Compare manualmente os timestamps
-
-## 🎯 Expectativas
-
-### Latência Ideal
-- **< 100ms**: Excelente (quase imperceptível)
-- **100-300ms**: ✅ Bom (ideal para conversação)
-- **300-500ms**: Aceitável
-- **> 500ms**: Ruim (notável delay)
-
-### FPS Esperado
-- **30 FPS**: Ideal para vídeo suave
-- **15-25 FPS**: Aceitável
-- **< 15 FPS**: Problema na conexão ou servidor
-
-## 🔍 Diagnóstico
-
-### Vídeo não aparece
-- Verifique se o servidor está rodando:
-  ```bash
-  ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "ps aux | grep webrtc-server"
-  ```
-
-### Conexão falha
-- Verifique logs do servidor:
-  ```bash
-  ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "tail -f /tmp/webrtc-server.log"
-  ```
-
-### Latência muito alta (> 500ms)
-- Verifique sua conexão de internet
-- Verifique carga do servidor:
-  ```bash
-  ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "top -n 1 | head -20"
-  ```
-
-## 📋 Arquivos no Servidor
-
-Localização: `/root/livekit-poc/`
-- `webrtc-server.py` - Servidor WebRTC
-- `webrtc-client.html` - Cliente web
-- `requirements.txt` - Dependências Python
-- `README.md` - Documentação completa
-
-## 🛠 Comandos Úteis
-
-### Verificar status do servidor
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "ps aux | grep webrtc-server"
-```
-
-### Verificar logs em tempo real
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "tail -f /tmp/webrtc-server.log"
-```
-
-### Reiniciar o servidor
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "cd /root/livekit-poc && pkill -f webrtc-server && nohup python3 webrtc-server.py > /tmp/webrtc-server.log 2>&1 &"
-```
-
-### Parar o servidor
-```bash
-ssh -i ~/.ssh/id_rsa -p 43060 root@38.117.87.48 "pkill -f webrtc-server"
-```
-
-## 🎨 O que você verá no vídeo
-
-O vídeo gerado mostra:
-- **Título**: "WebRTC Latency Test"
-- **Timestamp**: Hora atual com milissegundos (preciso)
-- **Frame Number**: Contador de frames
-- **FPS**: Taxa de frames por segundo
-- **Elapsed Time**: Tempo decorrido desde o início
-- **Borda Colorida**: Muda de cor continuamente (visualiza atualização)
-
-## 💡 Dicas
-
-1. **Teste múltiplas vezes**: A latência pode variar
-2. **Teste em diferentes momentos**: Condições de rede mudam
-3. **Teste em diferentes dispositivos**: Desktop vs mobile
-4. **Compare com outros serviços**: Use como baseline
-
-## 📊 Relatório de Testes
-
-Após testar, documente:
-```
-Data: ___________
-Hora: ___________
-Dispositivo: ___________
-Conexão: ___________
-
-Latência Média: _______ ms
-Latência Mínima: _______ ms
-Latência Máxima: _______ ms
-FPS Recebidos: _______
-
-Observações: ___________
-```
-
-## 🚀 Próximos Passos
-
-Após validar a latência, você pode:
-
-1. **Usar LiveKit Server**: Para produção com múltiplos usuários
-2. **Adicionar Áudio**: Para conversação full-duplex
-3. **Escalabilidade**: Testar com múltiplas conexões simultâneas
-4. **Integrar com LLM**: Criar avatar conversacional
-
-## 📞 Suporte
-
-Se tiver problemas:
-1. Verifique os logs do servidor
-2. Verifique a conexão de rede
-3. Use as ferramentas de debug do navegador:
-   - Chrome: `chrome://webrtc-internals`
-   - Firefox: `about:webrtc`
-
----
-
-**Servidor configurado e pronto para testes!** 🎉
-
-Acesse: http://38.117.87.48:9000

webrtc-latency-test/requirements.txt

@@ -1,5 +0,0 @@
-aiortc>=1.6.0
-aiohttp>=3.8.0
-opencv-python>=4.8.0
-numpy>=1.24.0
-av>=10.0.0

webrtc-latency-test/scripts/install.sh

@@ -1,125 +0,0 @@
-#!/bin/bash
-#
-# WebRTC Latency Test POC - Installation Script
-# Installs dependencies for the WebRTC latency testing system
-#
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
-
-GREEN='\033[0;32m'
-CYAN='\033[0;36m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-success() { echo -e "${GREEN}✓${NC} $1"; }
-warn() { echo -e "${YELLOW}⚠${NC} $1"; }
-header() { echo -e "\n${CYAN}$1${NC}"; }
-
-echo ""
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║          WEBRTC LATENCY TEST - INSTALLATION                   ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-
-# ============================================================
-# 1. CHECK PYTHON
-# ============================================================
-header "[1/5] Checking Python version..."
-
-PYTHON_VERSION=$(python3 --version 2>&1 | awk '{print $2}')
-PYTHON_MAJOR=$(echo $PYTHON_VERSION | cut -d. -f1)
-PYTHON_MINOR=$(echo $PYTHON_VERSION | cut -d. -f2)
-
-if [ "$PYTHON_MAJOR" -ge 3 ] && [ "$PYTHON_MINOR" -ge 8 ]; then
-    success "Python $PYTHON_VERSION detected"
-else
-    echo -e "${YELLOW}⚠${NC} Python 3.8+ required (found $PYTHON_VERSION)"
-    echo "  Please install Python 3.8 or later"
-    exit 1
-fi
-
-# ============================================================
-# 2. INSTALL PYTHON DEPENDENCIES
-# ============================================================
-header "[2/5] Installing Python dependencies..."
-
-cd "$PROJECT_DIR"
-
-if [ -f "requirements.txt" ]; then
-    pip3 install -r requirements.txt --quiet
-    success "Python dependencies installed"
-else
-    # Fallback: install common dependencies
-    pip3 install --quiet \
-        aiortc>=1.6.0 \
-        aiohttp>=3.8.0 \
-        opencv-python>=4.8.0 \
-        numpy>=1.24.0 \
-        av>=10.0.0 \
-        playwright>=1.40.0
-    success "Python dependencies installed (fallback)"
-fi
-
-# ============================================================
-# 3. INSTALL PLAYWRIGHT BROWSER
-# ============================================================
-header "[3/5] Installing Playwright and Chromium..."
-
-pip3 install playwright --quiet
-
-# Install Chromium (headless browser for automated tests)
-playwright install chromium --quiet 2>/dev/null || {
-    echo "  Downloading Chromium (may take a moment)..."
-    playwright install chromium
-}
-
-success "Playwright and Chromium installed"
-
-# ============================================================
-# 4. VERIFY DOCKER
-# ============================================================
-header "[4/5] Checking Docker..."
-
-if command -v docker &> /dev/null; then
-    DOCKER_VERSION=$(docker --version | awk '{print $3}')
-    success "Docker $DOCKER_VERSION detected"
-else
-    warn "Docker not found (optional for LiveKit)"
-    echo "  To install Docker:"
-    echo "    curl -fsSL https://get.docker.com -o get-docker.sh"
-    echo "    sh get-docker.sh"
-fi
-
-# ============================================================
-# 5. CREATE LOG DIRECTORY
-# ============================================================
-header "[5/5] Setting up log directories..."
-
-mkdir -p /tmp/webrtc-logs 2>/dev/null || true
-success "Log directories created"
-
-# ============================================================
-# COMPLETE
-# ============================================================
-echo ""
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║          INSTALLATION COMPLETE!                              ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-echo "  Components installed:"
-echo "    • Python WebRTC server (aiortc)"
-echo "    • OpenCV for video processing"
-echo "    • Playwright for automated tests"
-echo "    • Chromium headless browser"
-echo ""
-echo "  To start the server:"
-echo "    $SCRIPT_DIR/start_webrtc.sh"
-echo ""
-echo "  To run automated tests:"
-echo "    python3 test_latency_playwright.py <users> <concurrent>"
-echo ""
-success "Installation completed successfully!"
-echo ""

webrtc-latency-test/scripts/start.sh

@@ -1,211 +0,0 @@
-#!/bin/bash
-#
-# WebRTC Latency Test POC - Start Script
-# Starts the WebRTC server for latency testing
-#
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
-
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-success() { echo -e "${GREEN}✓${NC} $1"; }
-warn() { echo -e "${YELLOW}⚠${NC} $1"; }
-error() { echo -e "${RED}✗${NC} $1"; }
-header() { echo -e "\n${CYAN}$1${NC}"; }
-
-# Default configuration
-HOST="0.0.0.0"
-PORT=9000
-LOG_FILE="/tmp/webrtc-server.log"
-PID_FILE="/tmp/webrtc-server.pid"
-SERVER_SCRIPT="$PROJECT_DIR/webrtc-server-fixed.py"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -p|--port)
-            PORT="$2"
-            shift 2
-            ;;
-        -h|--host)
-            HOST="$2"
-            shift 2
-            ;;
-        --no-daemon)
-            NO_DAEMON=true
-            shift
-            ;;
-        *)
-            echo "Unknown option: $1"
-            echo "Usage: $0 [--port PORT] [--host HOST] [--no-daemon]"
-            exit 1
-            ;;
-    esac
-done
-
-echo ""
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║          WEBRTC LATENCY TEST - START SERVER                   ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-
-# ============================================================
-# CHECK IF SERVER SCRIPT EXISTS
-# ============================================================
-if [ ! -f "$SERVER_SCRIPT" ]; then
-    error "Server script not found: $SERVER_SCRIPT"
-    echo "  Please install the project first:"
-    echo "    $SCRIPT_DIR/install_webrtc.sh"
-    exit 1
-fi
-
-# ============================================================
-# CHECK IF ALREADY RUNNING
-# ============================================================
-if [ -f "$PID_FILE" ]; then
-    PID=$(cat "$PID_FILE")
-    if ps -p "$PID" > /dev/null 2>&1; then
-        header "Server already running"
-        echo "  PID: $PID"
-        echo "  Port: $PORT"
-        echo ""
-        echo "  To stop: $SCRIPT_DIR/stop_webrtc.sh"
-        exit 0
-    else
-        # Stale PID file, remove it
-        rm -f "$PID_FILE"
-    fi
-fi
-
-# ============================================================
-# STOP EXISTING PROCESSES
-# ============================================================
-header "Stopping existing WebRTC server processes..."
-
-# Kill any existing webrtc-server processes
-pkill -f "webrtc-server" 2>/dev/null || true
-sleep 1
-
-# Kill any process using the port
-if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-    lsof -ti :$PORT | xargs kill -9 2>/dev/null || true
-fi
-
-success "Cleanup completed"
-
-# ============================================================
-# START SERVER
-# ============================================================
-header "Starting WebRTC server..."
-
-cd "$PROJECT_DIR"
-
-if [ "$NO_DAEMON" = "true" ]; then
-    # Run in foreground
-    echo "  Starting in foreground mode..."
-    echo "  Host: $HOST"
-    echo "  Port: $PORT"
-    echo "  Log: $LOG_FILE"
-    echo ""
-    python3 -u "$SERVER_SCRIPT" > "$LOG_FILE" 2>&1
-else
-    # Run in background
-    echo "  Host: $HOST"
-    echo "  Port: $PORT"
-    echo "  Log: $LOG_FILE"
-    echo ""
-    
-    # Start in background with nohup
-    nohup python3 -u "$SERVER_SCRIPT" > "$LOG_FILE" 2>&1 &
-    SERVER_PID=$!
-    
-    # Save PID
-    echo $SERVER_PID > "$PID_FILE"
-    
-    # Wait a moment for startup
-    sleep 3
-    
-    # Check if process is still running
-    if ps -p $SERVER_PID > /dev/null 2>&1; then
-        success "Server started successfully"
-        echo "  PID: $SERVER_PID"
-        
-        # Wait for port to be listening
-        for i in {1..10}; do
-            if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-                success "Server listening on port $PORT"
-                break
-            fi
-            sleep 1
-        done
-    else
-        error "Server failed to start"
-        echo "  Check log: $LOG_FILE"
-        rm -f "$PID_FILE"
-        exit 1
-    fi
-fi
-
-# ============================================================
-# DISPLAY STATUS
-# ============================================================
-header "SERVER STATUS"
-echo ""
-
-printf "  %-15s %-10s %s\n" "Service" "Port" "Status"
-echo "  ─────────────────────────────────"
-
-if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-    printf "  %-15s %-10s ${GREEN}✓ Online${NC}\n" "WebRTC Server" "$PORT"
-    
-    # Show last few log lines
-    if [ -f "$LOG_FILE" ]; then
-        echo ""
-        echo "  Last log entries:"
-        tail -5 "$LOG_FILE" | sed 's/^/    /'
-    fi
-else
-    printf "  %-15s %-10s ${RED}✗ Offline${NC}\n" "WebRTC Server" "$PORT"
-    echo ""
-    error "Server is not responding"
-    exit 1
-fi
-
-# ============================================================
-# ACCESS INFORMATION
-# ============================================================
-header "ACCESS INFORMATION"
-echo ""
-
-if [ "$HOST" = "0.0.0.0" ]; then
-    echo "  Local access:   http://localhost:$PORT"
-    echo "  Network access: http://$(hostname -I | awk '{print $1}'):$PORT"
-else
-    echo "  Server URL:     http://$HOST:$PORT"
-fi
-
-echo ""
-echo "  Web client:     Open http://localhost:$PORT in browser"
-echo "  Logs:           tail -f $LOG_FILE"
-echo ""
-
-# ============================================================
-# QUICK TEST COMMANDS
-# ============================================================
-echo "  Quick test commands:"
-echo "    • Manual test:  Open http://localhost:$PORT in browser"
-echo "    • Auto test:    python3 test_latency_playwright.py 1 true"
-echo "    • Load test:    python3 test_latency_playwright.py 5 true"
-echo ""
-echo "  To stop server: $SCRIPT_DIR/stop_webrtc.sh"
-echo ""
-
-success "WebRTC server started successfully!"
-echo ""

webrtc-latency-test/scripts/stop.sh

@@ -1,141 +0,0 @@
-#!/bin/bash
-#
-# WebRTC Latency Test POC - Stop Script
-# Stops the WebRTC server
-#
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-success() { echo -e "${GREEN}✓${NC} $1"; }
-warn() { echo -e "${YELLOW}⚠${NC} $1"; }
-error() { echo -e "${RED}✗${NC} $1"; }
-header() { echo -e "\n${CYAN}$1${NC}"; }
-
-PID_FILE="/tmp/webrtc-server.pid"
-PORT=9000
-
-echo ""
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║          WEBRTC LATENCY TEST - STOP SERVER                    ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-
-# ============================================================
-# CHECK IF SERVER IS RUNNING
-# ============================================================
-header "Checking server status..."
-
-SERVER_RUNNING=false
-
-# Check PID file
-if [ -f "$PID_FILE" ]; then
-    PID=$(cat "$PID_FILE")
-    if ps -p "$PID" > /dev/null 2>&1; then
-        echo "  Found server process (PID: $PID)"
-        SERVER_RUNNING=true
-    else
-        warn "PID file exists but process not running (stale)"
-        rm -f "$PID_FILE"
-    fi
-fi
-
-# Also check for processes using the port
-if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-    echo "  Found process listening on port $PORT"
-    SERVER_RUNNING=true
-fi
-
-if [ "$SERVER_RUNNING" = false ]; then
-    echo ""
-    echo "  ${YELLOW}Server is not running${NC}"
-    echo ""
-    exit 0
-fi
-
-# ============================================================
-# STOP SERVER
-# ============================================================
-header "Stopping WebRTC server..."
-
-# Kill by PID if available
-if [ -f "$PID_FILE" ]; then
-    PID=$(cat "$PID_FILE")
-    if ps -p "$PID" > /dev/null 2>&1; then
-        echo "  Stopping server (PID: $PID)..."
-        kill $PID 2>/dev/null || true
-        
-        # Wait for process to stop
-        for i in {1..5}; do
-            if ! ps -p $PID > /dev/null 2>&1; then
-                success "Server stopped"
-                break
-            fi
-            sleep 1
-        done
-        
-        # Force kill if still running
-        if ps -p $PID > /dev/null 2>&1; then
-            echo "  Force killing server..."
-            kill -9 $PID 2>/dev/null || true
-        fi
-    fi
-    rm -f "$PID_FILE"
-fi
-
-# Kill any webrtc-server processes
-echo "  Killing webrtc-server processes..."
-pkill -f "webrtc-server" 2>/dev/null || true
-
-# Kill any process using the port
-if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-    echo "  Killing process using port $PORT..."
-    lsof -ti :$PORT | xargs kill -9 2>/dev/null || true
-fi
-
-# Wait a moment
-sleep 2
-
-success "Server stopped"
-
-# ============================================================
-# VERIFY STOPPED
-# ============================================================
-header "Verifying..."
-
-STILL_RUNNING=false
-
-if lsof -Pi :$PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
-    error "Something is still listening on port $PORT"
-    STILL_RUNNING=true
-elif pgrep -f "webrtc-server" > /dev/null 2>&1; then
-    error "Some webrtc-server processes still running"
-    STILL_RUNNING=true
-fi
-
-if [ "$STILL_RUNNING" = false ]; then
-    success "All processes stopped"
-fi
-
-# ============================================================
-# DISPLAY LOG
-# ============================================================
-header "Last log entries"
-
-LOG_FILE="/tmp/webrtc-server.log"
-if [ -f "$LOG_FILE" ]; then
-    tail -10 "$LOG_FILE" | sed 's/^/    /'
-else
-    echo "  No log file found"
-fi
-
-echo ""
-success "Stop completed!"
-echo ""

webrtc-latency-test/server/webrtc-client.html

@@ -1,366 +0,0 @@
-<!DOCTYPE html>
-<html lang="pt-BR">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>WebRTC Latency Test</title>
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-        body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
-            min-height: 100vh;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            padding: 20px;
-            color: #fff;
-        }
-        h1 {
-            margin-bottom: 20px;
-            text-align: center;
-            font-size: 2em;
-            color: #00d4ff;
-            text-shadow: 0 0 10px rgba(0, 212, 255, 0.5);
-        }
-        .container {
-            max-width: 1200px;
-            width: 100%;
-        }
-        .video-container {
-            background: #0a0a0a;
-            border-radius: 10px;
-            padding: 20px;
-            margin-bottom: 20px;
-            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5);
-        }
-        video {
-            width: 100%;
-            max-width: 640px;
-            display: block;
-            margin: 0 auto;
-            border-radius: 5px;
-            background: #000;
-        }
-        .controls {
-            display: flex;
-            gap: 10px;
-            margin-top: 20px;
-            justify-content: center;
-        }
-        button {
-            padding: 12px 24px;
-            font-size: 16px;
-            font-weight: bold;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-            transition: all 0.3s ease;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-        }
-        button:disabled {
-            opacity: 0.5;
-            cursor: not-allowed;
-        }
-        .btn-connect {
-            background: linear-gradient(135deg, #00d4ff 0%, #0099cc 100%);
-            color: #000;
-        }
-        .btn-connect:hover:not(:disabled) {
-            transform: translateY(-2px);
-            box-shadow: 0 4px 15px rgba(0, 212, 255, 0.4);
-        }
-        .btn-disconnect {
-            background: linear-gradient(135deg, #ff4757 0%, #cc3845 100%);
-            color: #fff;
-        }
-        .btn-disconnect:hover:not(:disabled) {
-            transform: translateY(-2px);
-            box-shadow: 0 4px 15px rgba(255, 71, 87, 0.4);
-        }
-        .stats {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 15px;
-            margin-top: 20px;
-        }
-        .stat-card {
-            background: rgba(255, 255, 255, 0.05);
-            border-radius: 8px;
-            padding: 15px;
-            border: 1px solid rgba(255, 255, 255, 0.1);
-        }
-        .stat-label {
-            font-size: 12px;
-            color: #888;
-            margin-bottom: 5px;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-        }
-        .stat-value {
-            font-size: 24px;
-            font-weight: bold;
-            color: #00d4ff;
-        }
-        .status {
-            text-align: center;
-            padding: 10px;
-            border-radius: 5px;
-            margin-bottom: 15px;
-            font-weight: bold;
-        }
-        .status.connected {
-            background: rgba(0, 212, 255, 0.2);
-            color: #00d4ff;
-            border: 1px solid #00d4ff;
-        }
-        .status.disconnected {
-            background: rgba(255, 71, 87, 0.2);
-            color: #ff4757;
-            border: 1px solid #ff4757;
-        }
-        .status.connecting {
-            background: rgba(255, 200, 0, 0.2);
-            color: #ffc800;
-            border: 1px solid #ffc800;
-        }
-        .info {
-            background: rgba(255, 200, 0, 0.1);
-            border-left: 4px solid #ffc800;
-            padding: 10px 15px;
-            margin-top: 20px;
-            border-radius: 5px;
-        }
-        .info p {
-            font-size: 14px;
-            color: #ffc800;
-            line-height: 1.6;
-        }
-        .timestamp-display {
-            font-family: 'Courier New', monospace;
-            font-size: 14px;
-            color: #0f0;
-            margin-top: 10px;
-            padding: 10px;
-            background: #000;
-            border-radius: 5px;
-            text-align: center;
-        }
-    </style>
-</head>
-<body>
-    <h1>🎬 WebRTC Latency Test</h1>
-    
-    <div class="container">
-        <div id="status" class="status disconnected">Desconectado</div>
-        
-        <div class="video-container">
-            <video id="video" autoplay playsinline muted></video>
-            <div class="timestamp-display" id="timestampDisplay">
-                Waiting for video stream...
-            </div>
-        </div>
-        
-        <div class="controls">
-            <button id="connectBtn" class="btn-connect" onclick="connect()">Conectar</button>
-            <button id="disconnectBtn" class="btn-disconnect" onclick="disconnect()" disabled>Desconectar</button>
-        </div>
-        
-        <div class="stats">
-            <div class="stat-card">
-                <div class="stat-label">FPS Recebidos</div>
-                <div class="stat-value" id="fps">0</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Frames Totais</div>
-                <div class="stat-value" id="totalFrames">0</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Tempo Decorrido</div>
-                <div class="stat-value" id="elapsed">0s</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Latência Estimada</div>
-                <div class="stat-value" id="latency">--</div>
-            </div>
-        </div>
-        
-        <div class="info">
-            <p><strong>Como medir a latência:</strong></p>
-            <p>1. Conecte ao servidor WebRTC</p>
-            <p>2. Observe o timestamp no vídeo (Time: HH:MM:SS.mmm)</p>
-            <p>3. Compare com o horário local exibido abaixo</p>
-            <p>4. Latência ≈ Hora Local - Timestamp no Vídeo</p>
-            <p><strong>Latência ideal para conversação: 100-300ms</strong></p>
-        </div>
-    </div>
-    
-    <script>
-        let pc = null;
-        let videoTrack = null;
-        let frameCount = 0;
-        let startTime = null;
-        let connectionStartTime = null;
-        
-        async function connect() {
-            const statusDiv = document.getElementById('status');
-            const connectBtn = document.getElementById('connectBtn');
-            const disconnectBtn = document.getElementById('disconnectBtn');
-            
-            statusDiv.className = 'status connecting';
-            statusDiv.textContent = 'Conectando...';
-            connectBtn.disabled = true;
-            
-            try {
-                // Criar RTCPeerConnection
-                pc = new RTCPeerConnection({
-                    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-                });
-                
-                // Lidar com incoming track
-                pc.ontrack = (event) => {
-                    console.log('Track received:', event.track.kind);
-                    if (event.track.kind === 'video') {
-                        videoTrack = event.track;
-                        const videoElement = document.getElementById('video');
-                        videoElement.srcObject = event.streams[0];
-                        startMeasurement();
-                    }
-                };
-                
-                pc.onconnectionstatechange = () => {
-                    console.log('Connection state:', pc.connectionState);
-                    if (pc.connectionState === 'connected') {
-                        statusDiv.className = 'status connected';
-                        statusDiv.textContent = 'Conectado via WebRTC';
-                        disconnectBtn.disabled = false;
-                        connectionStartTime = Date.now();
-                    } else if (pc.connectionState === 'disconnected' || 
-                               pc.connectionState === 'failed') {
-                        statusDiv.className = 'status disconnected';
-                        statusDiv.textContent = 'Desconectado';
-                        connectBtn.disabled = false;
-                        disconnectBtn.disabled = true;
-                    }
-                };
-                
-                // Criar offer
-                const offer = await pc.createOffer({ offerToReceiveVideo: true });
-                await pc.setLocalDescription(offer);
-                
-                // Aguardar ICE gathering
-                await new Promise(resolve => {
-                    if (pc.iceGatheringState === 'complete') {
-                        resolve();
-                    } else {
-                        pc.onicegatheringstatechange = () => {
-                            if (pc.iceGatheringState === 'complete') {
-                                resolve();
-                            }
-                        };
-                    }
-                });
-                
-                // Enviar offer ao servidor
-                const response = await fetch('/offer', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ sdp: pc.localDescription.sdp })
-                });
-                
-                if (!response.ok) {
-                    throw new Error('Falha ao conectar ao servidor');
-                }
-                
-                const answer = await response.json();
-                
-                // Configurar remote description
-                await pc.setRemoteDescription(new RTCSessionDescription({
-                    type: answer.type,
-                    sdp: answer.sdp
-                }));
-                
-                console.log('WebRTC connection established');
-                
-            } catch (error) {
-                console.error('Connection error:', error);
-                statusDiv.className = 'status disconnected';
-                statusDiv.textContent = 'Erro: ' + error.message;
-                connectBtn.disabled = false;
-                disconnectBtn.disabled = true;
-            }
-        }
-        
-        async function disconnect() {
-            if (pc) {
-                pc.close();
-                pc = null;
-            }
-            
-            const videoElement = document.getElementById('video');
-            videoElement.srcObject = null;
-            
-            document.getElementById('status').className = 'status disconnected';
-            document.getElementById('status').textContent = 'Desconectado';
-            document.getElementById('connectBtn').disabled = false;
-            document.getElementById('disconnectBtn').disabled = true;
-            
-            stopMeasurement();
-        }
-        
-        function startMeasurement() {
-            frameCount = 0;
-            startTime = Date.now();
-            updateDisplay();
-            
-            setInterval(updateDisplay, 1000);
-        }
-        
-        function stopMeasurement() {
-            document.getElementById('timestampDisplay').textContent = 'Waiting for video stream...';
-        }
-        
-        function updateDisplay() {
-            if (!startTime) return;
-            
-            const elapsed = (Date.now() - startTime) / 1000;
-            const currentTime = new Date();
-            const timestampText = currentTime.toLocaleTimeString() + '.' + 
-                                 currentTime.getMilliseconds().toString().padStart(3, '0');
-            
-            const fps = (frameCount / elapsed).toFixed(1);
-            
-            document.getElementById('fps').textContent = fps;
-            document.getElementById('totalFrames').textContent = frameCount;
-            document.getElementById('elapsed').textContent = elapsed.toFixed(1) + 's';
-            
-            document.getElementById('timestampDisplay').textContent = 
-                `Local Time: ${timestampText} | Frame: ${frameCount} | FPS: ${fps}`;
-            
-            // Estimativa de latência (baseada em análise visual)
-            // Em produção, você faria OCR para ler o timestamp do vídeo
-            if (connectionStartTime) {
-                const connectionTime = (Date.now() - connectionStartTime) / 1000;
-                document.getElementById('latency').textContent = 'Compare manualmente';
-            }
-        }
-        
-        // Atualizar contador de frames ( aproximado via polling do vídeo)
-        setInterval(() => {
-            const video = document.getElementById('video');
-            if (!video.paused && !video.ended && video.readyState >= 2) {
-                frameCount++;
-            }
-        }, 1000 / 30); // Aprox 30 FPS
-        
-        window.onload = function() {
-            console.log('WebRTC Latency Test loaded');
-        };
-    </script>
-</body>
-</html>

webrtc-latency-test/server/webrtc-server.py

@@ -1,130 +0,0 @@
-#!/usr/bin/env python3
-"""
-WebRTC Server Simples para Teste de Latência
-Versão simplificada sem borda animada
-"""
-import asyncio
-import logging
-from datetime import datetime
-import numpy as np
-import cv2
-from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
-from av import VideoFrame
-from aiohttp import web
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class VideoGeneratorTrack(VideoStreamTrack):
-    """Track que gera vídeo com timestamps"""
-    
-    def __init__(self):
-        super().__init__()
-        self.frame_count = 0
-        self.start_time = datetime.now()
-        self.fps = 30
-        
-    async def recv(self):
-        pts, time_base = await self.next_timestamp()
-        
-        # Criar frame
-        frame = np.zeros((480, 640, 3), dtype=np.uint8)
-        
-        # Fundo azul escuro
-        frame[:, :] = [20, 30, 50]
-        
-        # Timestamp atual
-        now = datetime.now()
-        timestamp = now.strftime("%H:%M:%S.%f")[:-3]
-        elapsed = (now - self.start_time).total_seconds()
-        
-        # Adicionar textos
-        cv2.putText(frame, "WebRTC Latency Test", (200, 100),
-                   cv2.FONT_HERSHEY_SIMPLEX, 1.2, (255, 255, 255), 3)
-        
-        cv2.putText(frame, f"Time: {timestamp}", (50, 220),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-        
-        cv2.putText(frame, f"Frame: #{self.frame_count}", (50, 270),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 200, 0), 2)
-        
-        cv2.putText(frame, f"FPS: {self.fps}", (50, 320),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 200, 0), 2)
-        
-        cv2.putText(frame, f"Elapsed: {elapsed:.2f}s", (50, 370),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 200, 255), 2)
-        
-        # Borda azul simples (sem animação)
-        cv2.rectangle(frame, (10, 10), (630, 470), (0, 212, 255), 4)
-        
-        self.frame_count += 1
-        
-        # Converter para VideoFrame
-        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        video_frame = VideoFrame.from_ndarray(frame_rgb, format="rgb24")
-        video_frame.pts = pts
-        video_frame.time_base = time_base
-        
-        return video_frame
-
-class WebRTCServer:
-    def __init__(self):
-        self.pc = RTCPeerConnection()
-        self.video_track = VideoGeneratorTrack()
-        self.pc.addTrack(self.video_track)
-        
-    async def handle_offer(self, offer_sdp):
-        offer = RTCSessionDescription(sdp=offer_sdp, type="offer")
-        await self.pc.setRemoteDescription(offer)
-        
-        answer = await self.pc.createAnswer()
-        await self.pc.setLocalDescription(answer)
-        
-        return {
-            "sdp": self.pc.localDescription.sdp,
-            "type": self.pc.localDescription.type
-        }
-
-web_rtc_server = None
-
-async def offer(request):
-    params = await request.json()
-    offer_sdp = params.get("sdp")
-    
-    if not offer_sdp:
-        return web.json_response({"error": "No SDP provided"}, status=400)
-    
-    global web_rtc_server
-    web_rtc_server = WebRTCServer()
-    
-    answer = await web_rtc_server.handle_offer(offer_sdp)
-    logger.info("Received WebRTC offer, sent answer")
-    
-    return web.json_response(answer)
-
-async def index(request):
-    with open('/root/livekit-poc/webrtc-client.html') as f:
-        return web.Response(text=f.read(), content_type='text/html')
-
-async def main():
-    app = web.Application()
-    app.router.add_get('/', index)
-    app.router.add_post('/offer', offer)
-    
-    runner = web.AppRunner(app)
-    await runner.setup()
-    
-    site = web.TCPSite(runner, '0.0.0.0', 9000)
-    await site.start()
-    
-    logger.info("WebRTC Server rodando em http://0.0.0.0:9000")
-    logger.info("Abra o navegador e acesse: http://38.117.87.48:9000")
-    
-    # Manter rodando
-    await asyncio.Event().wait()
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        logger.info("Servidor interrompido")

webrtc-latency-test/tests/test_latency_playwright.py

@@ -1,259 +0,0 @@
-#!/usr/bin/env python3
-"""
-Teste Automatizado de Latência com Playwright
-Testa a latência do servidor WebRTC com múltiplos usuários simultâneos
-"""
-import asyncio
-import time
-from datetime import datetime
-from playwright.async_api import async_playwright
-import json
-
-SERVER_URL = "http://38.117.87.48:9000"
-
-async def test_single_user(user_id):
-    """Testa latência com um único usuário"""
-    results = {
-        "user_id": user_id,
-        "connected": False,
-        "connection_time": 0,
-        "latency_measurements": [],
-        "fps": 0,
-        "errors": []
-    }
-    
-    async with async_playwright() as p:
-        try:
-            # Iniciar browser headless
-            browser = await p.chromium.launch(headless=True)
-            context = await browser.new_context()
-            page = await context.new_page()
-            
-            # Navegar para a página
-            start_time = time.time()
-            await page.goto(SERVER_URL)
-            navigation_time = (time.time() - start_time) * 1000
-            results["navigation_time"] = navigation_time
-            
-            # Clicar no botão de conectar
-            connect_start = time.time()
-            await page.click("#connectBtn")
-            
-            # Aguardar conexão
-            try:
-                await page.wait_for_selector('.status.connected', timeout=10000)
-                connection_time = (time.time() - connect_start) * 1000
-                results["connection_time"] = connection_time
-                results["connected"] = True
-                print(f"Usuário {user_id}: Conectado em {connection_time:.2f}ms")
-            except Exception as e:
-                results["errors"].append(f"Erro ao conectar: {str(e)}")
-                await browser.close()
-                return results
-            
-            # Aguardar estabilização do vídeo
-            await asyncio.sleep(3)
-            
-            # Capturar 10 medições de latência
-            for i in range(10):
-                try:
-                    # Capturar timestamp local
-                    local_time = datetime.now()
-                    
-                    # Capturar timestamp do vídeo (do elemento de texto)
-                    timestamp_text = await page.locator("#timestampDisplay").text_content()
-                    
-                    # Extrair timestamp do vídeo (formato: "Local Time: HH:MM:SS.mmm | Frame: X | FPS: Y")
-                    if "Local Time:" in timestamp_text:
-                        parts = timestamp_text.split("Local Time: ")[1].split(" |")[0]
-                        video_timestamp = datetime.strptime(parts, "%H:%M:%S.%f")
-                        
-                        # Calcular diferença (se mesmo minuto, caso contrário ignora)
-                        if local_time.hour == video_timestamp.hour and \
-                           local_time.minute == video_timestamp.minute:
-                            diff_ms = (local_time - video_timestamp).total_seconds() * 1000
-                            results["latency_measurements"].append(diff_ms)
-                    
-                    await asyncio.sleep(0.5)  # Esperar 500ms entre medições
-                except Exception as e:
-                    results["errors"].append(f"Erro na medição {i}: {str(e)}")
-            
-            # Capturar FPS final
-            try:
-                fps_text = await page.locator("#fps").text_content()
-                results["fps"] = float(fps_text) if fps_text else 0
-            except:
-                pass
-            
-            # Fechar browser
-            await browser.close()
-            
-        except Exception as e:
-            results["errors"].append(f"Erro geral: {str(e)}")
-        
-        # Calcular estatísticas de latência
-        if results["latency_measurements"]:
-            results["avg_latency"] = sum(results["latency_measurements"]) / len(results["latency_measurements"])
-            results["min_latency"] = min(results["latency_measurements"])
-            results["max_latency"] = max(results["latency_measurements"])
-            results["num_measurements"] = len(results["latency_measurements"])
-        
-        return results
-
-async def test_multiple_users(num_users, concurrent=True):
-    """Testa latência com múltiplos usuários"""
-    print(f"\n🧪 Iniciando teste com {num_users} usuário(s)...")
-    print(f"Modo: {'Simultâneo' if concurrent else 'Sequencial'}")
-    print(f"Servidor: {SERVER_URL}\n")
-    
-    start_time = time.time()
-    
-    if concurrent:
-        # Executar todos os testes simultaneamente
-        tasks = [test_single_user(i) for i in range(num_users)]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-    else:
-        # Executar testes sequencialmente
-        results = []
-        for i in range(num_users):
-            result = await test_single_user(i)
-            results.append(result)
-    
-    total_time = time.time() - start_time
-    
-    # Processar resultados
-    all_latencies = []
-    connection_times = []
-    fps_values = []
-    successful = 0
-    
-    for result in results:
-        if isinstance(result, Exception):
-            print(f"❌ Usuário com erro: {result}")
-            continue
-        
-        if result["connected"]:
-            successful += 1
-            if "latency_measurements" in result and result["latency_measurements"]:
-                all_latencies.extend(result["latency_measurements"])
-            if "connection_time" in result:
-                connection_times.append(result["connection_time"])
-            if "fps" in result and result["fps"] > 0:
-                fps_values.append(result["fps"])
-            
-            latency_str = f"{result['avg_latency']:.2f}ms" if "avg_latency" in result else "N/A"
-            print(f"✅ Usuário {result['user_id']}: Latência={latency_str}, FPS={result['fps']:.1f}")
-        else:
-            print(f"❌ Usuário {result['user_id']}: Falha na conexão")
-            if result["errors"]:
-                print(f"   Erros: {result['errors']}")
-    
-    # Estatísticas globais
-    print("\n" + "="*60)
-    print("📊 RESULTADOS AGREGADOS")
-    print("="*60)
-    print(f"Usuários testados: {num_users}")
-    print(f"Conexões bem-sucedidas: {successful}/{num_users}")
-    print(f"Taxa de sucesso: {(successful/num_users)*100:.1f}%")
-    print(f"Tempo total do teste: {total_time:.2f}s")
-    
-    if all_latencies:
-        print(f"\n📈 LATÊNCIA")
-        print(f"   Média: {sum(all_latencies)/len(all_latencies):.2f}ms")
-        print(f"   Mínima: {min(all_latencies):.2f}ms")
-        print(f"   Máxima: {max(all_latencies):.2f}ms")
-        print(f"   Medidas totais: {len(all_latencies)}")
-    
-    if connection_times:
-        print(f"\n⏱️  TEMPO DE CONEXÃO")
-        print(f"   Média: {sum(connection_times)/len(connection_times):.2f}ms")
-        print(f"   Mínima: {min(connection_times):.2f}ms")
-        print(f"   Máxima: {max(connection_times):.2f}ms")
-    
-    if fps_values:
-        print(f"\n🎬 FPS")
-        print(f"   Média: {sum(fps_values)/len(fps_values):.1f}")
-        print(f"   Mínimo: {min(fps_values):.1f}")
-        print(f"   Máximo: {max(fps_values):.1f}")
-    
-    # Classificação da latência
-    if all_latencies:
-        avg_latency = sum(all_latencies)/len(all_latencies)
-        print(f"\n🎯 CLASSIFICAÇÃO")
-        if avg_latency < 100:
-            print(f"   ✅ EXCELENTE ({avg_latency:.2f}ms) - Quase imperceptível")
-        elif avg_latency < 300:
-            print(f"   ✅ BOM ({avg_latency:.2f}ms) - Ideal para conversação")
-        elif avg_latency < 500:
-            print(f"   ⚠️  ACEITÁVEL ({avg_latency:.2f}ms) - Pequenos delays possíveis")
-        else:
-            print(f"   ❌ RUIM ({avg_latency:.2f}ms) - Latência muito alta")
-    
-    print("="*60)
-    
-    # Salvar resultados em JSON
-    output = {
-        "test_config": {
-            "num_users": num_users,
-            "concurrent": concurrent,
-            "server_url": SERVER_URL,
-            "test_date": datetime.now().isoformat()
-        },
-        "results": {
-            "successful_connections": successful,
-            "success_rate": (successful/num_users)*100 if num_users > 0 else 0,
-            "total_test_time": total_time,
-            "latency": {
-                "all_measurements": all_latencies,
-                "avg": sum(all_latencies)/len(all_latencies) if all_latencies else None,
-                "min": min(all_latencies) if all_latencies else None,
-                "max": max(all_latencies) if all_latencies else None,
-                "num_measurements": len(all_latencies)
-            },
-            "connection_time": {
-                "all": connection_times,
-                "avg": sum(connection_times)/len(connection_times) if connection_times else None,
-                "min": min(connection_times) if connection_times else None,
-                "max": max(connection_times) if connection_times else None
-            },
-            "fps": {
-                "all": fps_values,
-                "avg": sum(fps_values)/len(fps_values) if fps_values else None,
-                "min": min(fps_values) if fps_values else None,
-                "max": max(fps_values) if fps_values else None
-            }
-        },
-        "user_results": results
-    }
-    
-    # Salvar em arquivo
-    filename = f"/root/livekit-poc/latency_test_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    with open(filename, 'w') as f:
-        json.dump(output, f, indent=2)
-    print(f"\n💾 Resultados salvos em: {filename}")
-    
-    return output
-
-async def main():
-    """Função principal"""
-    import sys
-    
-    # Parâmetros padrão
-    num_users = 1
-    concurrent = True
-    
-    # Ler argumentos da linha de comando
-    if len(sys.argv) > 1:
-        num_users = int(sys.argv[1])
-    if len(sys.argv) > 2:
-        concurrent = sys.argv[2].lower() == 'true'
-    
-    print("🎬 Teste Automatizado de Latência WebRTC")
-    print("="*60)
-    
-    await test_multiple_users(num_users, concurrent)
-    
-    print("\n✅ Teste concluído!")
-
-if __name__ == "__main__":
-    asyncio.run(main())