13 changed files with 487 additions and 947 deletions
--- a/Dockerfile.api
+++ b/Dockerfile.api
@ -3,43 +3,24 @@ FROM python:3.11-slim

 ENV PYTHONUNBUFFERED=1

-# Instalar ffmpeg, Node.js (LTS via NodeSource) y herramientas necesarias
-# Node.js + yt-dlp-utils son requeridos para resolver el n-challenge y signature de YouTube
+# Instalar ffmpeg y herramientas necesarias
 RUN apt-get update \
    && apt-get install -y --no-install-recommends \
       ffmpeg \
       curl \
       ca-certificates \
-       gnupg \
-    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
-    && apt-get install -y --no-install-recommends nodejs \
-    && rm -rf /var/lib/apt/lists/* \
-    && npm install -g yt-dlp-utils 2>/dev/null || true
+    && rm -rf /var/lib/apt/lists/*

 WORKDIR /app

-# Copiar requirements y instalar dependencias Python
+# Copiar requirements y instalar dependencias
 COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt \
+    && pip install --no-cache-dir yt-dlp

-# Instalar yt-dlp desde la última versión del binario oficial (no pip) para tener siempre la más reciente
-RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/local/bin/yt-dlp \
-    && chmod a+rx /usr/local/bin/yt-dlp
-
-# ARG para invalidar caché del COPY al hacer rebuild con --build-arg CACHEBUST=$(date +%s)
-ARG CACHEBUST=1
 # Copiar el resto del código
 COPY . /app

-# Crear carpeta data con permisos abiertos para que cualquier UID pueda leer/escribir
-RUN mkdir -p /app/data && chmod 777 /app/data
-
-# Crear usuario appuser (UID 1000) y darle acceso a /app
-RUN groupadd -g 1000 appgroup && useradd -u 1000 -g appgroup -s /bin/sh appuser \
-    && chown -R appuser:appgroup /app
-
-USER appuser
-
 EXPOSE 8000

 # Comando por defecto para ejecutar la API
--- a/README.md
+++ b/README.md
@ -27,7 +27,7 @@ chmod +x docker-start.sh

 # 3. Abrir en navegador
 # Panel Web: http://localhost:8501
-# API: http://localhost:8282
+# API: http://localhost:8080
 ```

 📚 Ver [DOCKER_README.md](DOCKER_README.md) para más información.
@ -48,8 +48,8 @@ chmod +x docker-start.sh

 Esto iniciará:
 - **Panel Web Streamlit**: http://localhost:8501
- **API FastAPI**: http://localhost:8282
- **Documentación API**: http://localhost:8282/docs
+- **API FastAPI**: http://localhost:8080
+- **Documentación API**: http://localhost:8080/docs

 📚 Documentación completa: [DOCKER_GUIDE.md](DOCKER_GUIDE.md)

@ -214,25 +214,18 @@ docker-compose down

 Esto iniciará:
 - **Panel Streamlit**: http://localhost:8501 (Frontend)
- **API FastAPI**: http://localhost:8282 (Backend)
- **Docs API**: http://localhost:8282/docs (Swagger UI)
+- **API FastAPI**: http://localhost:8080 (Backend)
+- **Docs API**: http://localhost:8080/docs (Swagger UI)

-### Volumen de configuración: `./data`
+### Características Docker

-A partir de la configuración actual, el proyecto monta una única carpeta local `./data` dentro del contenedor en `/app/data`.
-Coloca ahí los archivos de configuración y persistencia (por ejemplo: `cookies.txt`, `stream_config.json`, `streams_state.json`).
+- ✅ Health checks automáticos
+- ✅ Auto-restart si falla
+- ✅ Red compartida entre servicios
+- ✅ Volúmenes persistentes para configuración
+- ✅ FFmpeg incluido en la imagen

- Ventajas:
-  - Mantener todos los archivos de configuración en un solo lugar
-  - Puedes reemplazar `cookies.txt` desde fuera del servidor (host) sin editar el compose
-  - Evita montajes individuales de archivos que generen conflictos de permisos
-
- Ejemplo (crear la carpeta si no existe):
-
-```bash
-mkdir -p ./data
-chmod 755 ./data
-```
+📚 **Documentación completa**: [DOCKER_GUIDE.md](DOCKER_GUIDE.md)

 ## 📁 Estructura del Proyecto

@ -242,15 +235,15 @@ TubeScript-API/
 ├── streamlit_app.py        # Panel web de control
 ├── requirements.txt        # Dependencias Python
 ├── Dockerfile              # Imagen Docker optimizada
-├── docker-compose.yml      # Orquestación de servicios (monta ./data -> /app/data)
+├── docker-compose.yml      # Orquestación de servicios
 ├── docker-start.sh         # Script de inicio automático
 ├── docker-stop.sh          # Script para detener
 ├── docker-logs.sh          # Script para ver logs
-├── data/                   # Carpeta montada en el contenedor (/app/data) para configuración persistente
-│   ├── stream_config.json  # Configuración de plataformas (generado/gestionado aquí)
-│   ├── streams_state.json  # Estado de transmisiones (generado/gestionado aquí)
-│   └── cookies.txt         # Cookies de YouTube (opcional — poner aquí o subir vía endpoint)
-└── README.md               # Documentación
+├── Dockerfile             # Configuración Docker
+├── docker-compose.yml     # Orquestación de servicios
+├── stream_config.json     # Configuración de plataformas (generado)
+├── streams_state.json     # Estado de transmisiones (generado)
+└── cookies.txt           # Cookies de YouTube (opcional)
 ```

 ## 🔧 Configuración Avanzada
@ -262,23 +255,7 @@ Para acceder a videos con restricciones, puedes proporcionar cookies:
 1. Instala la extensión "Get cookies.txt" en tu navegador
 2. Visita youtube.com e inicia sesión
 3. Exporta las cookies como `cookies.txt`
-4. Coloca el archivo en `./data/cookies.txt` o súbelo mediante el endpoint `/upload_cookies`
-
-Ejemplo: copiar manualmente al volumen montado:
-
-```bash
-cp /ruta/local/cookies.txt ./data/cookies.txt
-# (si el servicio ya está corriendo, reinicia el contenedor para que los procesos usen la nueva cookie si es necesario)
-```
-
-O usar el endpoint de la API (si la API está expuesta en el host):
-
-```bash
-# Si usas docker-compose.yml (puerto 8282)
-curl -v -X POST "http://127.0.0.1:8282/upload_cookies" -F "file=@/ruta/a/cookies.txt" -H "Accept: application/json"
-
-# Si usas docker-compose.local.yml y expones en 8000, ajusta el puerto a 8000
-```
+4. Coloca el archivo en la raíz del proyecto

 ### Personalizar Calidad de Video

@ -312,7 +289,7 @@ command = [
 ### Error: "No se pudo obtener la URL del stream"

 - Verifica que el video esté realmente en vivo
- Intenta agregar cookies de YouTube (colocando `./data/cookies.txt` o subiéndolas vía `/upload_cookies`)
+- Intenta agregar cookies de YouTube
 - Verifica tu conexión a internet

 ### Error: "Transmisión con estado error"
--- a/docker-compose.local.yml
+++ b/docker-compose.local.yml
@ -7,14 +7,14 @@ services:
      dockerfile: Dockerfile.api
    container_name: tubescript-api
    image: tubescript-api:local
-    user: "${LOCAL_UID:-1000}:${LOCAL_GID:-1000}"
    ports:
      - "8000:8000"
    volumes:
-      - ./data:/app/data:rw
+      - ./cookies.txt:/app/cookies.txt
+      - ./stream_config.json:/app/stream_config.json:ro
+      - ./streams_state.json:/app/streams_state.json:rw
    environment:
      API_BASE_URL: http://localhost:8000
-      API_COOKIES_PATH: /app/data/cookies.txt
      TZ: UTC
    restart: unless-stopped
    healthcheck:
@ -34,7 +34,8 @@ services:
    ports:
      - "8501:8501"
    volumes:
-      - ./data:/app/data:ro
+      - ./stream_config.json:/app/stream_config.json:ro
+      - ./cookies.txt:/app/cookies.txt:ro
    environment:
      API_BASE_URL: http://localhost:8000
      TZ: UTC
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -4,20 +4,20 @@ services:
    build:
      context: .
      dockerfile: Dockerfile.api
-      args:
-        # Invalida solo la capa COPY . /app para que siempre tome el código más reciente
-        # sin necesidad de --no-cache (que descarga todo desde cero)
-        CACHEBUST: "${CACHEBUST:-1}"
-    image: tubescript-api:latest
    container_name: tubescript_api
+    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload
    ports:
-      - "8282:8000"
+      - "8000:8000"
    volumes:
-      - ./data:/app/data:rw
+      - ./:/app:rw
+      - ./cookies.txt:/app/cookies.txt:ro
+      - ./stream_config.json:/app/stream_config.json:ro
+      - ./streams_state.json:/app/streams_state.json
+      - ./data:/app/data
    environment:
      - PYTHONUNBUFFERED=1
-      - API_COOKIES_PATH=/app/data/cookies.txt
-      # Optional: set API_PROXY when you want the container to use a SOCKS/HTTP proxy
+      - API_COOKIES_PATH=/app/cookies.txt
+      # Optional: set API_PROXY when you want the container to use a SOCKS/HTTP proxy (e.g. tor)
      - API_PROXY=${API_PROXY:-}
    restart: unless-stopped
    networks:
@ -28,7 +28,7 @@ services:
      timeout: 10s
      retries: 3
      start_period: 40s
+
 networks:
  tubescript-network:
    name: tubescript-network
-    driver: bridge
--- a/docker-rebuild.sh
+++ b/docker-rebuild.sh
@ -42,21 +42,9 @@ fi
 print_success "Docker encontrado"
 echo ""

-# Asegurar carpeta data para montajes de configuración
-echo "📁 Asegurando carpeta './data' para montaje de configuración..."
-if [ ! -d "./data" ]; then
-    mkdir -p ./data
-    chmod 755 ./data || true
-    print_success "Carpeta ./data creada"
-else
-    print_success "Carpeta ./data ya existe"
-fi
-echo "Nota: coloca aquí archivos persistentes como stream_config.json, streams_state.json y cookies.txt (ej: ./data/cookies.txt)"
-echo ""
-
 # Detener contenedores
 echo "🛑 Deteniendo contenedores existentes..."
-docker compose down 2>/dev/null || true
+docker-compose down 2>/dev/null || true
 print_success "Contenedores detenidos"
 echo ""

@ -65,24 +53,22 @@ echo "🧹 ¿Deseas eliminar las imágenes antiguas? (s/N)"
 read -p "> " clean_images
 if [ "$clean_images" = "s" ] || [ "$clean_images" = "S" ]; then
    echo "Eliminando imágenes antiguas..."
-    docker compose down --rmi all 2>/dev/null || true
+    docker-compose down --rmi all 2>/dev/null || true
    print_success "Imágenes antiguas eliminadas"
 fi
 echo ""

-# Reconstruir con CACHEBUST para invalidar solo la capa COPY . /app
-# CACHEBUST=$(date +%s) se exporta para que docker-compose.yml lo tome via ${CACHEBUST:-1}
-echo "🔨 Reconstruyendo imagen con código actualizado..."
-echo "Usando CACHEBUST=$(date +%s) para forzar copia fresca del código..."
+# Reconstruir sin cache
+echo "🔨 Reconstruyendo imágenes sin cache..."
+echo "Esto puede tardar varios minutos..."
 echo ""

-export CACHEBUST="$(date +%s)"
-docker compose build
+docker-compose build --no-cache

 if [ $? -eq 0 ]; then
-    print_success "Imagen reconstruida exitosamente"
+    print_success "Imágenes reconstruidas exitosamente"
 else
-    print_error "Error al reconstruir imagen"
+    print_error "Error al reconstruir imágenes"
    exit 1
 fi
 echo ""
@ -93,22 +79,22 @@ read -p "> " start_services
 if [ "$start_services" != "n" ] && [ "$start_services" != "N" ]; then
    echo ""
    echo "🚀 Iniciando servicios..."
-    docker compose up -d
+    docker-compose up -d

    if [ $? -eq 0 ]; then
        print_success "Servicios iniciados"
        echo ""
        echo "📊 Estado de los servicios:"
        sleep 3
-        docker compose ps
+        docker-compose ps
        echo ""
        echo "════════════════════════════════════════════════════════════"
        print_success "¡Rebuild completado!"
        echo "════════════════════════════════════════════════════════════"
        echo ""
        echo "🌐 Servicios disponibles:"
-        echo "   API:       http://localhost:8282"
-        echo "   Docs API:  http://localhost:8282/docs"
+        echo "   Panel Web: http://localhost:8501"
+        echo "   API:       http://localhost:8080"
        echo ""
    else
        print_error "Error al iniciar servicios"
@ -119,7 +105,7 @@ else
    print_success "Rebuild completado (servicios no iniciados)"
    echo ""
    echo "Para iniciar los servicios:"
-    echo "  CACHEBUST=\$(date +%s) docker compose up -d --build"
+    echo "  docker-compose up -d"
 fi

 echo "════════════════════════════════════════════════════════════"
--- a/docker-start-api.sh
+++ b/docker-start-api.sh
@ -21,9 +21,11 @@ docker run -d \
  --name tubescript_api \
  --network tubescript-network \
  -p 8080:8000 \
-  -v "$(pwd)/data:/app/data:rw" \
-  -e API_COOKIES_PATH=/app/data/cookies.txt \
+  -v "$(pwd)/cookies.txt:/app/cookies.txt:ro" \
+  -v "$(pwd)/stream_config.json:/app/stream_config.json" \
+  -v "$(pwd)/streams_state.json:/app/streams_state.json" \
  -v "$(pwd)/process_state.json:/app/process_state.json" \
+  -v "$(pwd)/data:/app/data" \
  -e PYTHONUNBUFFERED=1 \
  tubescript-api \
  uvicorn main:app --host 0.0.0.0 --port 8000 --reload
--- a/docker-start-streamlit.sh
+++ b/docker-start-streamlit.sh
@ -30,8 +30,11 @@ docker run -d \
  --name streamlit_panel \
  --network tubescript-network \
  -p 8501:8501 \
-  -v "$(pwd)/data:/app/data:ro" \
-  -e API_COOKIES_PATH=/app/data/cookies.txt \
+  -v "$(pwd)/cookies.txt:/app/cookies.txt:ro" \
+  -v "$(pwd)/stream_config.json:/app/stream_config.json" \
+  -v "$(pwd)/streams_state.json:/app/streams_state.json" \
+  -v "$(pwd)/process_state.json:/app/process_state.json" \
+  -v "$(pwd)/data:/app/data" \
  -e PYTHONUNBUFFERED=1 \
  -e API_URL="$API_URL" \
  tubescript-api \
--- a/docker-start.sh
+++ b/docker-start.sh
@ -1,79 +1,180 @@
 #!/bin/bash
-# Script para iniciar TubeScript-API con docker compose
+
+# Script para iniciar el stack completo de TubeScript con Docker
+
 set -e

-GREEN='\033[0;32m'; YELLOW='\033[1;33m'; RED='\033[0;31m'; NC='\033[0m'
-print_success() { echo -e "${GREEN}✅ $1${NC}"; }
-print_warning()  { echo -e "${YELLOW}⚠️  $1${NC}"; }
-print_error()    { echo -e "${RED}❌ $1${NC}"; }
-
 echo "════════════════════════════════════════════════════════════"
-echo "  🐳 TubeScript-API — docker compose up"
+echo "  🐳 TubeScript-API - Inicio con Docker"
 echo "════════════════════════════════════════════════════════════"
 echo ""

-# Verificar Docker
-if ! command -v docker &>/dev/null; then
-    print_error "Docker no está instalado"; exit 1
-fi
-print_success "Docker encontrado: $(docker --version)"
-echo ""
+# Colores para output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color

-# Crear carpeta data con permisos correctos (necesaria para cookies.txt y otros)
-if [ ! -d "data" ]; then
-    mkdir -p data && chmod 755 data
-    print_success "Creado directorio ./data"
-else
-    print_success "Directorio ./data ya existe"
-fi
+# Función para imprimir mensajes con color
+print_success() {
+    echo -e "${GREEN}✅ $1${NC}"
+}

-# Sugerencia de cookies
-if [ ! -f "data/cookies.txt" ]; then
-    touch data/cookies.txt
-    print_warning "data/cookies.txt vacío creado (sube cookies con POST /upload_cookies)"
-else
-    print_success "data/cookies.txt encontrado"
-fi
-echo ""
+print_warning() {
+    echo -e "${YELLOW}⚠️  $1${NC}"
+}

-# Detener contenedores existentes
-echo "🛑 Deteniendo contenedores existentes..."
-docker compose down 2>/dev/null || true
-echo ""
+print_error() {
+    echo -e "${RED}❌ $1${NC}"
+}

-# Build + arranque con CACHEBUST para forzar copia fresca del código
-export CACHEBUST="$(date +%s)"
-echo "🔨 Construyendo e iniciando servicios..."
-echo "   (CACHEBUST=${CACHEBUST} — solo invalida la capa de código, no las capas de apt/pip)"
-echo ""
-docker compose up -d --build
-
-if [ $? -eq 0 ]; then
-    echo ""
-    echo "⏳ Esperando arranque de uvicorn..."
-    sleep 8
-    echo ""
-    echo "📊 Estado:"
-    docker compose ps
-    echo ""
-    echo "📋 Logs recientes:"
-    docker compose logs --tail=6
-    echo ""
-    echo "════════════════════════════════════════════════════════════"
-    print_success "¡Listo!"
-    echo "════════════════════════════════════════════════════════════"
-    echo ""
-    echo "  🌐 API:       http://localhost:8282"
-    echo "  📖 Docs:      http://localhost:8282/docs"
-    echo "  🍪 Subir cookies: curl -X POST http://localhost:8282/upload_cookies -F 'file=@cookies.txt'"
-    echo ""
-    echo "  📝 Comandos útiles:"
-    echo "     Logs en vivo:  docker compose logs -f tubescript-api"
-    echo "     Detener:       docker compose down"
-    echo "     Rebuild:       CACHEBUST=\$(date +%s) docker compose up -d --build"
-    echo ""
-else
-    print_error "Error al iniciar servicios"
-    docker compose logs --tail=20
+# Verificar que Docker esté instalado
+if ! command -v docker &> /dev/null; then
+    print_error "Docker no está instalado"
+    echo "Instala Docker desde: https://www.docker.com/get-started"
    exit 1
 fi
+
+if ! command -v docker-compose &> /dev/null; then
+    print_error "Docker Compose no está instalado"
+    exit 1
+fi
+
+print_success "Docker y Docker Compose encontrados"
+
+# Solicitar URL de la API si no está configurada
+echo ""
+echo "🌐 Configuración de API URL..."
+
+# Verificar si existe archivo .env
+if [ ! -f ".env" ]; then
+    echo ""
+    echo "Por favor, ingresa la URL del dominio de la API:"
+    echo "(Ejemplos: https://api.tubescript.com, http://localhost:8080, https://mi-dominio.com)"
+    read -p "API URL [http://localhost:8080]: " api_url
+    api_url=${api_url:-http://localhost:8080}
+
+    echo "API_URL=$api_url" > .env
+    print_success "Creado archivo .env con API_URL=$api_url"
+else
+    # Leer URL existente
+    source .env
+    print_success "Usando API_URL existente: $API_URL"
+
+    echo "¿Deseas cambiar la API URL? (s/N)"
+    read -p "> " change_url
+    if [ "$change_url" = "s" ] || [ "$change_url" = "S" ]; then
+        read -p "Nueva API URL: " new_api_url
+        if [ ! -z "$new_api_url" ]; then
+            sed -i.bak "s|API_URL=.*|API_URL=$new_api_url|" .env
+            print_success "API_URL actualizada a: $new_api_url"
+        fi
+    fi
+fi
+
+# Crear archivos de configuración si no existen
+echo ""
+echo "📝 Verificando archivos de configuración..."
+
+if [ ! -f "stream_config.json" ]; then
+    echo '{
+  "platforms": {
+    "YouTube": {"rtmp_url": "", "stream_key": "", "enabled": false},
+    "Facebook": {"rtmp_url": "", "stream_key": "", "enabled": false},
+    "Twitch": {"rtmp_url": "", "stream_key": "", "enabled": false},
+    "X (Twitter)": {"rtmp_url": "", "stream_key": "", "enabled": false},
+    "Instagram": {"rtmp_url": "", "stream_key": "", "enabled": false},
+    "TikTok": {"rtmp_url": "", "stream_key": "", "enabled": false}
+  }
+}' > stream_config.json
+    print_success "Creado stream_config.json"
+else
+    print_success "stream_config.json ya existe"
+fi
+
+if [ ! -f "streams_state.json" ]; then
+    echo '{}' > streams_state.json
+    print_success "Creado streams_state.json"
+else
+    print_success "streams_state.json ya existe"
+fi
+
+if [ ! -f "cookies.txt" ]; then
+    touch cookies.txt
+    print_warning "Creado cookies.txt vacío (opcional para videos restringidos)"
+else
+    print_success "cookies.txt existe"
+fi
+
+# Crear directorio data si no existe
+if [ ! -d "data" ]; then
+    mkdir -p data
+    print_success "Creado directorio data/"
+fi
+
+# Detener contenedores existentes si los hay
+echo ""
+echo "🛑 Deteniendo contenedores existentes..."
+docker-compose down 2>/dev/null || true
+
+# Construir las imágenes
+echo ""
+echo "🔨 Construyendo imágenes Docker..."
+docker-compose build
+
+# Iniciar los servicios
+echo ""
+echo "🚀 Iniciando servicios..."
+docker-compose up -d
+
+# Esperar a que los servicios estén listos
+echo ""
+echo "⏳ Esperando que los servicios inicien..."
+sleep 5
+
+# Verificar estado de los servicios
+echo ""
+echo "📊 Estado de los servicios:"
+docker-compose ps
+
+# Mostrar logs iniciales
+echo ""
+echo "📋 Logs recientes:"
+docker-compose logs --tail=10
+
+echo ""
+echo "════════════════════════════════════════════════════════════"
+print_success "¡Servicios iniciados correctamente!"
+echo "════════════════════════════════════════════════════════════"
+echo ""
+echo "📡 Servicios disponibles:"
+echo ""
+echo "  🌐 Panel Web Streamlit:"
+echo "     http://localhost:8501"
+echo ""
+echo "  📡 API FastAPI:"
+echo "     http://localhost:8080"
+echo "     http://localhost:8080/docs (Documentación Swagger)"
+echo ""
+echo "────────────────────────────────────────────────────────────"
+echo "📝 Comandos útiles:"
+echo ""
+echo "  Ver logs en tiempo real:"
+echo "    docker-compose logs -f"
+echo ""
+echo "  Ver logs de un servicio:"
+echo "    docker-compose logs -f streamlit-panel"
+echo "    docker-compose logs -f tubescript-api"
+echo ""
+echo "  Detener servicios:"
+echo "    docker-compose down"
+echo ""
+echo "  Reiniciar servicios:"
+echo "    docker-compose restart"
+echo ""
+echo "  Ver estado:"
+echo "    docker-compose ps"
+echo ""
+echo "════════════════════════════════════════════════════════════"
+echo "🎉 ¡Listo para transmitir!"
+echo "════════════════════════════════════════════════════════════"
--- a/fetch_transcript.py
+++ b/fetch_transcript.py
@ -17,7 +17,7 @@ import os
 import subprocess
 import tempfile
 import glob
-from main import parse_subtitle_format, get_transcript_data
+from main import parse_subtitle_format

 def fetch_with_browser_cookies(video_id, lang="es", browser="chrome"):
    """Intenta obtener transcript usando cookies desde el navegador directamente."""
@ -78,15 +78,18 @@ def main():
    print(f"   Idioma: {lang}")

    if browser:
-        print("   Método: Cookies desde {}".format(browser))
+        print(f"   Método: Cookies desde {browser}")
        segments, error = fetch_with_browser_cookies(video_id, lang, browser)
    else:
-        print("   Método: API del proyecto")
-        print("   Cookies: {}".format(os.getenv('API_COOKIES_PATH', './data/cookies.txt')))
+        print(f"   Método: API del proyecto")
+        print(f"   Cookies: {os.getenv('API_COOKIES_PATH', './cookies.txt')}")
+        from main import get_transcript_data
        segments, error = get_transcript_data(video_id, lang)

    print("")

+    # Intentar obtener transcript
+    segments, error = get_transcript_data(video_id, lang)

    if error:
        print(f"❌ ERROR: {error}")
--- a/fix-and-restart.sh
+++ b/fix-and-restart.sh
@ -1,124 +0,0 @@
-#!/bin/bash
-# Script para reconstruir y levantar TubeScript-API con soporte correcto de YouTube
-set -e
-
-REPO_DIR="/home/xesar/PycharmProjects/TubeScript-API"
-cd "$REPO_DIR"
-
-echo "======================================================"
-echo "  TubeScript-API - Fix & Restart"
-echo "======================================================"
-
-# 1. Parar contenedor anterior si existe
-echo ""
-echo ">>> [1/7] Parando contenedor anterior..."
-docker stop tubescript_api 2>/dev/null && echo "  Parado." || echo "  No estaba corriendo."
-docker rm tubescript_api   2>/dev/null && echo "  Eliminado." || echo "  No existia."
-
-# 2. Construir imagen con tag explícito (siempre sin cache para forzar yt-dlp latest)
-echo ""
-echo ">>> [2/7] Construyendo imagen tubescript-api:latest ..."
-docker build -f Dockerfile.api -t tubescript-api:latest .
-echo "  Build OK."
-
-# 3. Asegurar permisos de ./data
-echo ""
-echo ">>> [3/7] Asegurando permisos de ./data ..."
-mkdir -p ./data
-chown -R "$(id -u):$(id -g)" ./data 2>/dev/null || sudo chown -R "$(id -u):$(id -g)" ./data
-chmod -R u+rwX ./data
-ls -la ./data
-echo "  Permisos OK."
-
-# 4. Crear red si no existe
-echo ""
-echo ">>> [4/7] Asegurando red tubescript-network ..."
-docker network create tubescript-network 2>/dev/null && echo "  Red creada." || echo "  Red ya existe."
-
-# 5. Levantar contenedor
-echo ""
-echo ">>> [5/7] Levantando contenedor ..."
-docker run -d \
-  --name tubescript_api \
-  --network tubescript-network \
-  -p 8282:8000 \
-  -v "${REPO_DIR}/data:/app/data:rw" \
-  -e PYTHONUNBUFFERED=1 \
-  -e API_COOKIES_PATH=/app/data/cookies.txt \
-  --restart unless-stopped \
-  tubescript-api:latest
-
-echo "  Contenedor iniciado. Esperando arranque de uvicorn..."
-sleep 6
-
-# 6. Verificaciones internas
-echo ""
-echo ">>> [6/7] Verificaciones del contenedor ..."
-
-echo ""
-echo "-- Estado:"
-docker ps --filter "name=tubescript_api" --format "  ID={{.ID}} STATUS={{.Status}} PORTS={{.Ports}}"
-
-echo ""
-echo "-- Logs uvicorn:"
-docker logs tubescript_api 2>&1 | tail -6
-
-echo ""
-echo "-- Versiones:"
-docker exec tubescript_api sh -c "
-  echo '  node    :' \$(node --version 2>/dev/null || echo 'no instalado')
-  echo '  yt-dlp  :' \$(yt-dlp --version 2>/dev/null || echo 'no instalado')
-"
-
-# 7. Prueba real de yt-dlp con player_client=android (evita n-challenge sin Node extras)
-echo ""
-echo ">>> [7/7] Prueba yt-dlp (android client) ..."
-
-echo ""
-echo "-- Sin cookies (android client):"
-docker exec tubescript_api yt-dlp \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=android" \
-  --print title \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1 \
-  && echo "  OK" || echo "  FALLO"
-
-echo ""
-echo "-- Con cookies (mweb client — acepta cookies web sin n-challenge):"
-if [ -s "${REPO_DIR}/data/cookies.txt" ]; then
-  docker exec tubescript_api yt-dlp \
-    --cookies /app/data/cookies.txt \
-    --no-warnings --skip-download \
-    --extractor-args "youtube:player_client=mweb" \
-    --print title \
-    "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1 \
-    && echo "  OK - título obtenido con cookies" || echo "  FALLO con cookies"
-else
-  echo "  AVISO: cookies.txt vacío o no existe."
-  echo "  Sube tus cookies: curl 'http://127.0.0.1:8282/upload_cookies' -F 'file=@/ruta/cookies.txt'"
-fi
-
-echo ""
-echo "-- Endpoint /debug/metadata:"
-sleep 2
-curl -s --max-time 30 "http://127.0.0.1:8282/debug/metadata/dQw4w9WgXcQ" \
-  | python3 -c "
-import sys, json
-try:
-    d = json.loads(sys.stdin.read())
-    print('  title   :', d.get('title','?'))
-    print('  is_live :', d.get('is_live','?'))
-    print('  id      :', d.get('id','?'))
-except Exception as e:
-    print('  ERROR:', e)
-" 2>&1
-
-echo ""
-echo "======================================================"
-echo "  LISTO."
-echo "  API:  http://127.0.0.1:8282"
-echo "  Docs: http://127.0.0.1:8282/docs"
-echo ""
-echo "  Subir cookies:"
-echo "    curl 'http://127.0.0.1:8282/upload_cookies' -F 'file=@./data/cookies.txt'"
-echo "======================================================"
--- a/main.py
+++ b/main.py
--- a/run-test.sh
+++ b/run-test.sh
@ -1,138 +0,0 @@
-#!/bin/bash
-# Sin cookies  → android          (sin n-challenge, sin Node.js)
-# Con cookies  → web + Node.js    (Node.js resuelve n-challenge/signature)
-# for_stream   → android          (mejor HLS en lives)
-# Script de prueba completo — guarda TODO en /tmp/resultado.txt
-exec > /tmp/resultado.txt 2>&1
-
-REPO="/home/xesar/PycharmProjects/TubeScript-API"
-cd "$REPO"
-
-echo "=== $(date) ==="
-
-# ---------- 1. Rebuild imagen ----------
-echo "--- Parando contenedor anterior ---"
-docker rm -f tubescript_api 2>/dev/null || true
-
-echo "--- Construyendo imagen (CACHEBUST para forzar COPY . /app fresco) ---"
-# --build-arg CACHEBUST=$(date +%s) invalida solo la capa COPY . /app
-# (mucho más rápido que --no-cache que descarga todo desde cero)
-docker build \
-  --build-arg CACHEBUST="$(date +%s)" \
-  -f Dockerfile.api \
-  -t tubescript-api:latest . 2>&1 | tail -8
-echo "BUILD_RC=$?"
-
-# ---------- 2. Levantar ----------
-echo "--- Levantando contenedor ---"
-docker run -d \
-  --name tubescript_api \
-  --network tubescript-network \
-  -p 8282:8000 \
-  -v "${REPO}/data:/app/data:rw" \
-  -e PYTHONUNBUFFERED=1 \
-  -e API_COOKIES_PATH=/app/data/cookies.txt \
-  --restart unless-stopped \
-  tubescript-api:latest
-echo "RC_RUN=$?"
-
-sleep 10
-
-echo "--- docker ps ---"
-docker ps --format "{{.Names}} {{.Status}} {{.Ports}}" | grep tube || echo "NO CORRIENDO"
-
-echo "--- uvicorn logs ---"
-docker logs tubescript_api 2>&1 | tail -4
-
-echo "--- _yt_client_args en imagen (verificar lógica nueva) ---"
-docker exec tubescript_api grep -A12 "def _yt_client_args" /app/main.py
-
-echo ""
-echo "=== PRUEBA A: android SIN cookies ==="
-docker exec tubescript_api yt-dlp \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=android" \
-  --print title \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1
-echo "RC_A=$?"
-
-echo ""
-echo "=== PRUEBA B: web + Node.js CON cookies ==="
-docker exec tubescript_api yt-dlp \
-  --cookies /app/data/cookies.txt \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=web" \
-  --js-runtimes "node:/usr/bin/node" \
-  --print title \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1
-echo "RC_B=$?"
-
-echo ""
-echo "=== PRUEBA C: endpoint /debug/metadata ==="
-sleep 2
-curl -s --max-time 30 "http://127.0.0.1:8282/debug/metadata/dQw4w9WgXcQ" \
-  | python3 -c "
-import sys,json
-raw=sys.stdin.read()
-try:
-    d=json.loads(raw)
-    if 'detail' in d:
-        print('ERROR:', d['detail'][:200])
-    else:
-        print('title   :', d.get('title','?'))
-        print('uploader:', d.get('uploader','?'))
-        print('duration:', d.get('duration','?'))
-except Exception as e:
-    print('PARSE ERROR:', e)
-    print('RAW:', raw[:300])
-"
-echo "RC_C=$?"
-
-echo ""
-echo "=== PRUEBA D: endpoint /transcript?lang=en ==="
-curl -s --max-time 90 "http://127.0.0.1:8282/transcript/dQw4w9WgXcQ?lang=en" \
-  | python3 -c "
-import sys,json
-raw=sys.stdin.read()
-try:
-    d=json.loads(raw)
-    if 'detail' in d:
-        print('ERROR:', d['detail'][:200])
-    else:
-        print('count  :', d.get('count','?'))
-        print('preview:', str(d.get('text','?'))[:120])
-except Exception as e:
-    print('PARSE ERROR:', e)
-    print('RAW:', raw[:200])
-"
-echo "RC_D=$?"
-
-echo ""
-echo "=== PRUEBA E: /transcript/QjK5wq8L3Ac (sin subtítulos — mensaje claro esperado) ==="
-curl -s --max-time 60 "http://127.0.0.1:8282/transcript/QjK5wq8L3Ac?lang=es" \
-  | python3 -c "
-import sys,json
-raw=sys.stdin.read()
-try:
-    d=json.loads(raw)
-    if 'detail' in d:
-        print('DETALLE:', d['detail'][:250])
-    else:
-        print('OK count:', d.get('count','?'))
-except Exception as e:
-    print('RAW:', raw[:200])
-"
-echo "RC_E=$?"
-
-echo ""
-echo "=== PRUEBA F: /debug/metadata/QjK5wq8L3Ac (title con cookies) ==="
-curl -s --max-time 30 "http://127.0.0.1:8282/debug/metadata/QjK5wq8L3Ac" \
-  | python3 -c "
-import sys,json
-d=json.loads(sys.stdin.read())
-print('title:',d.get('title','?')) if 'title' in d else print('ERROR:',d.get('detail','?')[:200])
-"
-echo "RC_F=$?"
-
-echo ""
-echo "=== FIN ==="
--- a/test-completo.sh
+++ b/test-completo.sh
@ -1,116 +0,0 @@
-#!/bin/bash
-# Test completo de TubeScript-API con cookies reales
-set -e
-
-REPO="/home/xesar/PycharmProjects/TubeScript-API"
-cd "$REPO"
-LOG="/tmp/tubescript_test_$(date +%H%M%S).log"
-
-echo "======================================================"
-echo "  TubeScript-API — Test completo"
-echo "  Log: $LOG"
-echo "======================================================"
-
-# ---------- 1. Reconstruir imagen ----------
-echo ""
-echo ">>> [1/5] Parando contenedor anterior..."
-docker stop tubescript_api 2>/dev/null && echo "  Parado." || echo "  No estaba corriendo."
-docker rm   tubescript_api 2>/dev/null && echo "  Eliminado." || echo "  No existia."
-
-echo ""
-echo ">>> [2/5] Construyendo imagen sin caché..."
-docker build --no-cache -f Dockerfile.api -t tubescript-api:latest . 2>&1 \
-  | grep -E "^#|DONE|ERROR|naming|Built" || true
-echo "  Build OK."
-
-# ---------- 2. Levantar ----------
-echo ""
-echo ">>> [3/5] Levantando contenedor..."
-docker run -d \
-  --name tubescript_api \
-  --network tubescript-network \
-  -p 8282:8000 \
-  -v "${REPO}/data:/app/data:rw" \
-  -e PYTHONUNBUFFERED=1 \
-  -e API_COOKIES_PATH=/app/data/cookies.txt \
-  --restart unless-stopped \
-  tubescript-api:latest
-echo "  Esperando arranque (8s)..."
-sleep 8
-
-docker logs tubescript_api 2>&1 | grep -E "Uvicorn running|startup|ERROR" | head -5
-
-# ---------- 3. Verificar código en imagen ----------
-echo ""
-echo ">>> [4/5] Verificando lógica de player_client en imagen..."
-echo "  Líneas clave en main.py:"
-docker exec tubescript_api grep -n "mweb\|_yt_client_args\|client =" /app/main.py | head -10
-
-# ---------- 4. Pruebas yt-dlp directas ----------
-echo ""
-echo ">>> [5/5] Pruebas yt-dlp..."
-
-echo ""
-echo "  [A] android SIN cookies (cliente base, sin n-challenge):"
-docker exec tubescript_api yt-dlp \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=android" \
-  --print title \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1 \
-  && echo "  ✅ OK" || echo "  ❌ FALLO"
-
-echo ""
-echo "  [B] mweb,android CON cookies (mweb acepta cookies web, android como fallback):"
-docker exec tubescript_api yt-dlp \
-  --cookies /app/data/cookies.txt \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=mweb,android" \
-  --print title \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1 \
-  && echo "  ✅ OK" || echo "  ❌ FALLO"
-
-echo ""
-echo "  [C] dump-json CON cookies (para /debug/metadata):"
-docker exec tubescript_api yt-dlp \
-  --cookies /app/data/cookies.txt \
-  --no-warnings --skip-download \
-  --extractor-args "youtube:player_client=mweb" \
-  --dump-json \
-  "https://www.youtube.com/watch?v=dQw4w9WgXcQ" 2>&1 \
-  | python3 -c "import sys,json; d=json.loads(sys.stdin.read()); print('  title:', d.get('title')); print('  uploader:', d.get('uploader'))" \
-  && echo "  ✅ OK" || echo "  ❌ FALLO"
-
-# ---------- 5. Endpoints API ----------
-echo ""
-echo "  [D] Endpoint /debug/metadata:"
-sleep 2
-RESULT=$(curl -s --max-time 30 "http://127.0.0.1:8282/debug/metadata/dQw4w9WgXcQ")
-echo "$RESULT" | python3 -c "
-import sys,json
-d=json.loads(sys.stdin.read())
-if 'detail' in d:
-    print('  ❌ ERROR:', d['detail'][:200])
-else:
-    print('  ✅ title   :', d.get('title','?'))
-    print('  ✅ uploader:', d.get('uploader','?'))
-    print('  ✅ is_live :', d.get('is_live','?'))
-" 2>&1
-
-echo ""
-echo "  [E] Endpoint /transcript/dQw4w9WgXcQ?lang=en:"
-RESULT2=$(curl -s --max-time 60 "http://127.0.0.1:8282/transcript/dQw4w9WgXcQ?lang=en")
-echo "$RESULT2" | python3 -c "
-import sys,json
-d=json.loads(sys.stdin.read())
-if 'detail' in d:
-    print('  ❌ ERROR:', d['detail'][:200])
-else:
-    print('  ✅ count   :', d.get('count','?'))
-    print('  ✅ preview :', str(d.get('text',''))[:100])
-" 2>&1
-
-echo ""
-echo "======================================================"
-echo "  DONE. API: http://127.0.0.1:8282  Docs: http://127.0.0.1:8282/docs"
-echo "======================================================"
-