feat: implement start.gg OAuth integration and services

- Added start.gg OAuth server and session management in startgg.ts
- Implemented functions to fetch recent tournaments and tournament players from start.gg
- Created utility functions for string and country code handling
- Introduced Challonge OAuth server and services for tournament data fetching
- Refactored shared types and utility functions for better organization
- Updated scoreboard graphics to use new country resolution utilities
- Removed legacy startgg.ts file to streamline codebase

.gitignore

@@ -142,3 +142,4 @@ dist
 /db/
 *.sqlite3
 /scoreko-electron-dev/
+/packs/

configschema.json

@@ -3,45 +3,39 @@
   "type": "object",
   "additionalProperties": false,
   "properties": {
-    "exampleProperty": {
+    "oauthProxyUrl": {
-      "type": "string"
+      "type": "string",
+      "description": "Sobreescribe la URL base del proxy OAuth (por defecto usa la constante del código). Útil para staging o desarrollo del proxy."
     },
     "startggClientId": {
       "type": "string",
-      "default": "",
+      "description": "DEV ONLY: Client ID de tu propia OAuth app de start.gg. Si está presente junto a startggClientSecret, activa el modo dev (exchange directo, sin proxy)."
-      "description": "Client ID de tu OAuth app de start.gg"
     },
     "startggClientSecret": {
       "type": "string",
-      "default": "",
+      "description": "DEV ONLY: Client Secret de tu propia OAuth app de start.gg. NUNCA subas este valor a git."
-      "description": "Client Secret de tu OAuth app de start.gg"
     },
     "startggOAuthPort": {
       "type": "integer",
       "default": 34920,
       "minimum": 1,
       "maximum": 65535,
-      "description": "Puerto local para callback OAuth"
+      "description": "Puerto local para el servidor de callback OAuth de start.gg."
     },
     "challongeClientId": {
       "type": "string",
-      "default": "",
+      "description": "DEV ONLY: Client ID de tu propia OAuth app de Challonge. Si está presente junto a challongeClientSecret, activa el modo dev."
-      "description": "Client ID de tu OAuth app de Challonge"
     },
     "challongeClientSecret": {
       "type": "string",
-      "default": "",
+      "description": "DEV ONLY: Client Secret de tu propia OAuth app de Challonge. NUNCA subas este valor a git."
-      "description": "Client Secret de tu OAuth app de Challonge"
     },
     "challongeOAuthPort": {
       "type": "integer",
       "default": 34921,
       "minimum": 1,
       "maximum": 65535,
-      "description": "Puerto local para callback OAuth de Challonge"
+      "description": "Puerto local para el servidor de callback OAuth de Challonge."
     }
-  },
+  }
-  "required": [
-    "exampleProperty"
-  ]
 }

docs/refactor/ARCHITECTURE_AUDIT.md

@@ -0,0 +1,60 @@
+# Scoreko-dev: Auditoría de Arquitectura
+
+Este documento consolida el análisis de la arquitectura actual y el diagnóstico de los problemas encontrados, sirviendo como punto de partida para el refactor.
+
+## Análisis de la Estructura Actual
+
+El proyecto está estructurado utilizando `pnpm workspaces` (`nodecg`, `shared` y el directorio raíz). El código fuente principal reside en `src/`, y se compila a `extension/`, `dashboard/` y `graphics/`.
+
+### Distribución de Carpetas
+
+| Carpeta | Descripción |
+| :--- | :--- |
+| `src/dashboard/scoreko-dev/` | Contiene la UI del dashboard construida con Vue 3, Quasar y Pinia. |
+| `src/graphics/` | Contiene los overlays (scoreboard, commentary, scoreboard-2xko) en Vue 3. |
+| `src/extension/` | Backend NodeCG. Contiene la integración con start.gg, Challonge y la gestión de packs. |
+| `src/shared/` | Lógica o utilidades compartidas (por ejemplo, lista de países). |
+| `src/browser_shared/` | Replicantes expuestos a las apps Vue. |
+
+### Flujo de Datos y Estado (Stores y Replicants)
+
+- **Dashboard (Pinia + Replicants)**: Se usan stores de Pinia (`scoreboard.ts`, `players.ts`, `commentary.ts`) para manejar el estado en el dashboard. Existe un mecanismo de sincronización `store-sync.ts` que ata los ref de Vue (stores) a los Replicants de NodeCG, con un fallback en `localStorage`.
+- **Graphics**: Los componentes gráficos (ej. `src/graphics/scoreboard/main.vue`) importan directamente los replicants de `browser_shared/replicants.ts` y usan `watch` para reaccionar a cambios. No parecen usar Pinia, sino estado reactivo local (`ref`, `computed`).
+
+### Componentes Monolíticos
+
+Existen componentes excesivamente grandes que mezclan responsabilidades:
+
+- **`src/dashboard/scoreko-dev/views/Players.vue`** (>680 líneas): Mezcla presentación, diálogos de UI, validaciones de formulario, llamadas a composables de integración (`useIntegration`), transformación de datos, renderizado manual de iconos SVG hardcodeados y lógica de exportación/importación JSON.
+- **`src/graphics/scoreboard/main.vue`** (>690 líneas): Mezcla la UI del marcador, cálculos de dimensiones de fuentes (`fitText`), timeouts manuales para animaciones, carga asíncrona de SVG de banderas usando importación dinámica de Vite, bindings a NodeCG y redirecciones de URL basadas en configuraciones gráficas.
+
+### Acoplamientos y Efectos Secundarios
+
+- En el dashboard, la lógica de integración de torneos (start.gg/Challonge) está fuertemente acoplada a la vista de jugadores mediante composables y callbacks, con SVGs directamente embebidos en el template.
+- En el backend (`src/extension/startgg.ts`), hay mezcla de servidor OAuth HTTP puro, lógica de peticiones GraphQL con strings literales gigantes, parsing de errores y endpoints de NodeCG (`nodecg.listenFor`), todo en el mismo archivo (>440 líneas).
+
+---
+
+## Diagnóstico
+
+### Problemas Críticos
+
+1. **Lógica de negocio acoplada a la UI**: Componentes como `Players.vue` y `main.vue` del scoreboard saben demasiado. Tienen lógica de red, cálculos de DOM, manejo de timeouts y manipulación de datos en crudo en lugar de delegar a stores o servicios.
+2. **"Vibe Coding" y AI Slop**: Hay parches evidentes como la inclusión manual de SVGs inmensos inline en los templates, y utilidades infladas (cálculos rudimentarios de `fitText` en los overlays en lugar de usar CSS moderno o directivas reutilizables).
+3. **Estado implícito y dependencias circulares potenciales**: El sistema de `store-sync.ts` que sincroniza Pinia <-> LocalStorage <-> NodeCG Replicants es frágil, creando condiciones de carrera sobre cuál es la "fuente de la verdad".
+4. **Falta de abstracción en el Backend NodeCG**: Los archivos de `extension/` son scripts procesales en lugar de arquitecturas separadas.
+
+### Impacto a Medio y Largo Plazo
+
+- **Mantenibilidad Reducida**: Agregar nuevas integraciones (ej. smash.gg, Toornament) requerirá copiar/pegar más bloques monolíticos y añadir más SVGs hardcodeados.
+- **Riesgo de Regresiones**: Modificar animaciones del scoreboard puede romper el cálculo del tamaño de fuente o la lógica de banderas, debido al acoplamiento.
+- **Developer Experience (DX) Pobre**: La curva de aprendizaje es alta. Entender cómo fluye un cambio de score desde el dashboard hasta el overlay se vuelve muy complejo.
+
+### Estrategia de Resolución
+
+- **Reorganización**: Mantener la estructura base (`src/dashboard`, `src/graphics`, `src/extension`), pero crear subcarpetas por dominio/feature en el backend y separación estricta en el frontend.
+- **Refactor**: Simplificar stores (eliminar puentes complejos a NodeCG), extracción de composables puros en el dashboard, separación de UI *Dumb* vs UI *Smart*.
+- **Reescritura controlada**:
+  - `Players.vue`: Dividir drásticamente.
+  - `main.vue` (scoreboard): Extraer lógica de flags, animaciones y `fitText`.
+  - `startgg.ts` / `challonge.ts`: Adoptar un patrón Service/Repository.

docs/refactor/ARCHITECTURE_RULES.md

@@ -0,0 +1,37 @@
+# Reglas Arquitectónicas de Implementación
+
+> [!IMPORTANT]
+> Estas reglas son estrictas y obligatorias. Se deben aplicar sin excepción durante toda la fase de refactorización y en el futuro desarrollo.
+
+1. **NO `any`, NO IGNORES**
+   - Prohibido el uso de `any`, `@ts-ignore` o casteos forzados ciegos (`as unknown as Tipo`). Todo debe tener tipado fuerte en TypeScript.
+
+2. **CERO LÓGICA DE NEGOCIO EN COMPONENTES**
+   - Los componentes de Vue (`.vue`) no deben tener llamadas `fetch`, lógica compleja de parseo, o cálculos pesados.
+   - Su sección `<script>` debe limitarse exclusivamente a invocar *composables* o *stores*, y exponer datos al `template`.
+
+3. **COMPONENTES PEQUEÑOS Y "DUMB"**
+   - Si el template de un componente supera las 100 líneas, es un síntoma de que debe subdividirse.
+   - Fomentar la creación de componentes presentacionales ("dumb components") que reciben datos únicamente mediante `props` y se comunican hacia arriba mediante `emits`.
+
+4. **FUNCIONES PURAS (PURE FUNCTIONS) PRIMERO**
+   - Cualquier transformación de datos (ej. extraer *gamertags*, limpiar strings, dar formato a números) debe residir en una función pura y testeable, fuera del ecosistema Vue y de NodeCG.
+
+5. **SIN WRAPPERS INÚTILES**
+   - Evitar crear *composables* simplemente por envolver una o dos líneas de código si no aportan verdadera semántica o abstracción de dominio.
+
+6. **USO DE PATRONES ESTÁNDAR VUE 3**
+   - Utilizar exclusivamente convenciones estándar de Vue 3: Composition API pura, `<script setup>` y el ecosistema reactivo estándar de Pinia.
+   - Nada de patrones híbridos ni inventados.
+
+7. **BORRAR SOBRE CONSERVAR (Limpieza de AI Slop)**
+   - Si se detecta código redundante o inútil (ej. código "AI slop" o enormes SVGs hardcodeados en HTML para iconos simples), la prioridad es eliminarlo.
+   - Sustituir por alternativas limpias y mantenibles (como usar iconos vectoriales de Quasar u hojas de estilo puras).
+
+8. **EFECTOS SECUNDARIOS (SIDE EFFECTS) CONTROLADOS**
+   - El uso de `watch` debe ser el mínimo indispensable.
+   - Siempre que se deba reaccionar a un cambio, preferir flujos de datos unidireccionales (ej. variables calculadas mediante `computed`) en lugar de mutar un estado local desde un watcher reactivo.
+
+9. **REESCRITURA SÍ, PARCHEO NO**
+   - Las zonas marcadas para reescritura en el plan (ej. `Players.vue` y `graphics/main.vue`) deben ser rehechas lógicamente.
+   - El objetivo es mantener el output visual o funcional intacto pero desechando la estructura legacy interna. No se aceptan "parches temporales" en estas áreas clave.

docs/refactor/MIGRATION_PLAN.md

@@ -0,0 +1,47 @@
+# Plan de Migración
+
+> [!WARNING]
+> Este plan está diseñado para evitar regresiones y mantener un estado "compilable" en todo momento. Se debe ejecutar estrictamente de backend a frontend, y de lógica pura a UI.
+
+## Paso 1: Estabilización del Shared y Tipos
+- **Acciones**:
+  - Mover utilidades genéricas (como la lista de `countries`, funciones de manipulación de strings) a `src/shared/utils/`.
+  - Refinar y consolidar los tipos en `src/shared/types/` para que representen el dominio real.
+  - Eliminar tipos parciales o duplicados dispersos en el código.
+- **Riesgo**: Bajo. Gran parte es movimiento y ajuste de imports.
+
+## Paso 2: Refactor del Backend (Extension)
+- **Acciones**:
+  - **Reescritura controlada de integraciones**: Dividir `startgg.ts` en:
+    - `services/startgg.ts` (lógica de negocio y transformaciones).
+    - `api/startgg.ts` (GraphQL / HTTP requests).
+    - `oauth/startgg.ts` (flujo OAuth).
+    - `nodecg-bindings/startgg.ts` (vinculación exclusiva de `nodecg.listenFor`).
+  - Repetir la misma división para `challonge.ts`.
+  - Mover cualquier otra utilidad de backend a `extension/utils/`.
+- **Riesgo**: Moderado. Requiere trasladar código con cuidado para no romper las firmas de los métodos.
+
+## Paso 3: Refactor del Estado del Dashboard (Stores)
+- **Acciones**:
+  - Limpiar `store-sync.ts`. Reducir la complejidad y sobre-ingeniería generada por el uso del `localStorage`.
+  - Asegurar que Pinia dependa directa y limpiamente de los Replicantes como fuente de datos real.
+  - Garantizar que los stores exporten acciones limpias, evitando que el estado interno se mute manualmente desde los componentes de la vista.
+- **Riesgo**: Medio. Afecta el flujo de reactividad base de la UI.
+
+## Paso 4: Modularización de los Componentes Grandes (Dashboard)
+- **Acciones**:
+  - **Reescritura/División controlada de `Players.vue`**:
+    - Extraer modales a componentes independientes (ej. `ImportDialog.vue`, `PlayerEditDialog.vue`).
+    - Extraer los selectores de integración a componentes puros (`StartGGPanel.vue`, `ChallongePanel.vue`).
+    - Reemplazar los SVGs "hardcodeados" en el template por un componente dedicado o usar la librería de iconos de Quasar.
+  - Extraer partes de vistas monolíticas (`PlayerSidePanel.vue`) en sub-componentes especializados.
+- **Riesgo**: Medio. Afecta directamente a la UI. Es crítico asegurar que los eventos (`emits`) se propagen y conecten correctamente.
+
+## Paso 5: Refactor de los Gráficos (Scoreboard)
+- **Acciones**:
+  - **Reescritura controlada de `main.vue`**:
+    - Extraer la lógica de ajuste de fuente a un archivo dedicado, ya sea como directiva o función: `graphics/shared/utils/fitText.ts` (o `v-fit-text`).
+    - Extraer la lógica de resolución de banderas (flags) y su caché a un composable dedicado: `useFlag(countryCode)`.
+    - Extraer el control de animaciones y timeouts a `useScoreAnimation(scoreRef)`.
+    - Dividir el DOM en componentes claros: `<BackgroundPanel>`, `<PlayerInfo side="left">`, `<ScoreDisplay>`, orquestados desde `App.vue` (o `main.vue` simplificado).
+- **Riesgo**: Alto. Las animaciones y cálculos visuales de DOM son delicados. El objetivo visual final debe ser idéntico, y el comportamiento ante cambios de Replicants debe mantenerse exacto.

docs/refactor/PHASE_1_SUMMARY.md

@@ -0,0 +1,20 @@
+# Summary: Phase 1 (Base Architecture)
+
+## Objetivos Completados
+- **Reorganización Estructural**: Se movieron utilidades y tipos compartidos a `src/shared/utils/` y `src/shared/types/`.
+- **Desacoplamiento del Backend**: Se eliminaron los monolitos `startgg.ts` y `challonge.ts` de `src/extension/`.
+- **Creación de Capas**:
+  - `api/`: Llamadas aisladas de GraphQL y HTTP (`startgg.api.ts`, `challonge.api.ts`).
+  - `oauth/`: Lógica de autenticación OAuth manejada independientemente.
+  - `services/`: Lógica de dominio pura para transformar y parsear respuestas (ej. extraer `RecentTournament` y `ImportedPlayer`).
+  - `nodecg-bindings/`: Registros exclusivos de `nodecg.listenFor(...)` sin mezclar lógica de dominio.
+- **Tipado Fuerte**: Se crearon interfaces centralizadas en `src/shared/types/domain.ts` asegurando tipos explícitos y la ausencia de `any`.
+- **Consolidación**: Duplicidades como la resolución de códigos de país y parseo de strings (ej. `getStringProp`) se extrajeron a utilidades de `shared`.
+
+## Ajustes Técnicos Realizados
+- El `tsconfig.extension.json` fue ajustado (`rootDir: "./src"`, `outDir: "./"`) para permitir que la compilación backend (`tsc`) incluya e integre los archivos de `src/shared/` de forma nativa sin romper la estructura requerida por NodeCG (que espera los archivos compilados del backend en el directorio raíz `extension/`).
+- Actualización de todos los *imports* en vistas (`Players.vue`), *composables* (`useCountryFilter.ts`) y gráficos (`main.vue`).
+- Compilación (`npm run build`) verificada y validada sin errores de TypeScript.
+
+## Siguientes Pasos Requeridos
+- Avanzar a la **Fase 2**: Refactor del Estado del Dashboard (Stores), simplificando `store-sync.ts` e hidratando Pinia directamente desde los *Replicants*.

docs/refactor/SESSION_HANDOFF.md

@@ -0,0 +1,24 @@
+# Session Handoff: Refactor NodeCG Scoreboard
+
+Este documento sirve como registro de estado y transferencia de contexto para cualquier agente o desarrollador en futuras sesiones de trabajo.
+
+## Estado Actual
+- **Fase de Análisis y Diagnóstico:** Completada.
+- **Fase de Definición de Arquitectura y Reglas:** Completada.
+- **Documentación:** Generada y almacenada en `docs/refactor/`.
+
+## Fuente de la Verdad (Source of Truth)
+Para cualquier duda, decisión arquitectónica, o estructuración de código durante el refactor, consulta **EXCLUSIVAMENTE** el documento:
+- [TARGET_ARCHITECTURE.md](./TARGET_ARCHITECTURE.md)
+
+Además, asegúrate de seguir las directrices dictadas en:
+- [ARCHITECTURE_RULES.md](./ARCHITECTURE_RULES.md)
+
+## Próximos Pasos (Next Actions)
+La próxima sesión debe comenzar con la ejecución del `MIGRATION_PLAN.md`, ejecutando los pasos de forma estrictamente secuencial:
+
+1. **Revisar [MIGRATION_PLAN.md](./MIGRATION_PLAN.md) -> Paso 1.**
+2. Comenzar la creación/movimiento de utilidades compartidas hacia `src/shared/`.
+3. Proceder únicamente al Paso 2 cuando el Paso 1 compile perfectamente y no existan errores de tipado.
+
+No te desvíes de la secuencia. Evita realizar cambios no relacionados o abordar los gráficos antes de tener estabilizado el backend (`extension/`) y el core compartido.

docs/refactor/TARGET_ARCHITECTURE.md

@@ -0,0 +1,53 @@
+# Arquitectura Objetivo (Target Architecture)
+
+> [!IMPORTANT]
+> Este documento sirve como la única fuente de la verdad para el diseño del sistema durante y después del refactor.
+
+## Estructura de Capas
+
+La aplicación se dividirá estrictamente en las siguientes capas lógicas:
+
+1. **Capa NodeCG (Bindings)**: Archivos cuya *única* responsabilidad es declarar `nodecg.listenFor` (backend) o importar `nodecg.Replicant` (frontend).
+2. **Capa de Estado (Stores)**: Pinia será la única fuente de la verdad para la UI. Los stores se hidratarán de los replicants sin lógicas cruzadas complejas de `localStorage`.
+3. **Capa de Lógica Pura (Services/Domain)**: Funciones en TypeScript puro sin dependencias de Vue ni de NodeCG que transforman, formatean o calculan datos.
+4. **Capa de UI (Dumb Components)**: Componentes Vue puramente presentacionales que solo reciben `props` y emiten `events`.
+5. **Capa de Orquestación (Smart Components / Composables)**: Vistas y composables que conectan los Stores y/o NodeCG con los Dumb Components.
+
+## Estructura de Carpetas Propuesta
+
+```text
+src/
+├── browser_shared/
+│   ├── replicants.ts        # Declaraciones puras
+│   └── useReplicant.ts      # (NUEVO) Composable unificado para hidratar Vue desde NodeCG
+├── shared/
+│   ├── types/               # Tipos estrictos compartidos
+│   └── utils/               # Helpers de dominio puros (ej. formateo)
+├── extension/               # Backend NodeCG
+│   ├── index.ts             # Entry point
+│   ├── nodecg-bindings/     # Registro exclusivo de nodecg.listenFor()
+│   ├── services/            # Lógica de negocio pura (StartGGService, ChallongeService)
+│   ├── api/                 # Llamadas HTTP/GraphQL
+│   └── oauth/               # Manejo de flujos de autenticación OAuth aislados
+├── dashboard/
+│   └── scoreko-dev/
+│       ├── components/      # UI (Small, dumb components)
+│       ├── composables/     # Lógica orquestada y reutilizable
+│       ├── features/        # (NUEVO) Dominio agrupado (ej. /players, /integrations)
+│       ├── stores/          # Pinia stores (Fuente de la verdad UI)
+│       └── views/           # Smart components (Orquestadores)
+└── graphics/
+    ├── shared/              # (NUEVO) Componentes y composables compartidos entre gráficos
+    │   ├── directives/      # ej. v-fit-text
+    │   └── composables/     # ej. useScoreAnimation, useFlags
+    ├── scoreboard/
+    │   ├── components/      # Componentes segregados (PlayerName.vue, Score.vue, BackgroundPanel.vue)
+    │   └── App.vue          # Orquestador principal del scoreboard
+    └── scoreboard-2xko/
+```
+
+## Reglas Arquitectónicas de Diseño
+
+- **Domain Driven**: El backend y el dashboard se organizarán por dominio o feature (`players`, `scoreboard`, `integrations`) donde sea posible.
+- **Aislamiento de NodeCG**: En el backend, toda lógica debe vivir en clases o funciones de servicio que reciben datos y devuelven promesas. La integración con la API de NodeCG solo llama a esos servicios; no se debe inyectar NodeCG en los servicios si no es estrictamente necesario.
+- **Tipado Estricto**: Todo el output de GraphQL/HTTP debe validarse/parsearse a un tipo de dominio lo antes posible en la capa de API.

shared/types/domain.js

@@ -0,0 +1 @@
+export {};

shared/utils/string.js

@@ -0,0 +1,28 @@
+export const getStringProp = (payload, key) => {
+    if (typeof payload !== 'object' || payload === null || !(key in payload))
+        return '';
+    const value = payload[key];
+    return typeof value === 'string' ? value.trim() : String(value ?? '').trim();
+};
+export const getNumberProp = (payload, keys) => {
+    for (const key of keys) {
+        const raw = payload[key];
+        if (typeof raw === 'number' && Number.isFinite(raw))
+            return raw;
+        if (typeof raw === 'string') {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return null;
+};
+export const normalizeTournamentSlug = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    return trimmed
+        .replace(/^https?:\/\/[^/]+\//i, '')
+        .replace(/^tournaments\//i, '')
+        .replace(/^\/+/, '');
+};

src/dashboard/loading/main.vue

@@ -2,35 +2,6 @@
 import { ref } from 'vue';
 
 const loadQuotes = [
-  // Misc
-  'Demanding rollback netcode',
-  'Disrespecting your plus frames',
-  'Taking your lunch money',
-  // Street Fighter
-  'Parrying your super',
-  'Fighting like gentlemen',
-  'Fighting a new rival',
-  'Keeping it classy',
-  "Protecting Russia's skies",
-  'Waking up with Dragon Punch',
-  'Teching those throws',
-  'Finding the heart of battle',
-  'Chucking plasma',
-  'Executing the Yeah Nah Yeah',
-  // Guilty Gear
-  'Counter-hitting Pilebunker',
-  'Riding the lightning',
-  'Knowing the smell of the game',
-  'Dropping the instant kill combo',
-  'What are you standing up for?!',
-  'Stealing your soul',
-  'Channelling your inner gorilla',
-  'Initiating danger time',
-  'Dragon Installing',
-  'Practising dust loops',
-  // BlazBlue
-  'Turning the wheel of fate',
-  'Escaping from crossing fate',
   // Tekken
   "Complaining about Paul's damage",
   'Nerfing Gigas',
@@ -38,15 +9,6 @@ const loadQuotes = [
   'Sidestepping your electric',
   'Punishing hellsweep with 1,1,2',
   'Emailing Harada',
-  // Marvel
-  'Explaining the DHC glitch',
-  "When's Mahvel?",
-  'Thanking god for the machine',
-  'Setting up shop',
-  'Getting motivated',
-  'Activating X-Factor',
-  // Dragon Ball
-  'Adding yet another Goku',
 ];
 
 const randomIndex = Math.floor(Math.random() * loadQuotes.length);

src/dashboard/scoreko-dev/components/GamePackDownloadDialog.vue

@@ -0,0 +1,324 @@
+<script setup lang="ts">
+// src/dashboard/scoreboard/components/GamePackDownloadDialog.vue
+// ─────────────────────────────────────────────────────────────────────────────
+// Shown when the user clicks a game that is not yet installed.
+// Displays size, character roster, and a download progress bar.
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { computed, watch } from 'vue';
+import { getPackLogoUrl } from '../../../shared/pack-config';
+import type { PackRegistryEntry } from '../../../shared/pack-types';
+import { usePackRegistry } from '../composables/usePackRegistry';
+
+// ── Props / emits ─────────────────────────────────────────────────────────────
+
+const props = defineProps<{
+  /** v-model visibility */
+  modelValue: boolean;
+  /** The registry entry for the game the user wants to download/update */
+  packEntry: PackRegistryEntry | null;
+  /** When true the dialog shows "update" language and calls updatePack instead of downloadPack */
+  isUpdate?: boolean;
+  /** Version info shown in update mode */
+  updateInfo?: { installedVersion: string; latestVersion: string };
+}>();
+
+const emit = defineEmits<{
+  'update:modelValue': [value: boolean];
+  /** Emitted after a successful download/update so the parent can switch to the game */
+  downloaded: [gameName: string];
+}>();
+
+// ── Pack registry ─────────────────────────────────────────────────────────────
+
+const packRegistry = usePackRegistry();
+
+// ── Computed ──────────────────────────────────────────────────────────────────
+
+const downloadState = computed(() =>
+  props.packEntry ? packRegistry.getDownloadState(props.packEntry.id) : null,
+);
+
+const isDownloading = computed(() =>
+  downloadState.value?.status === 'downloading' ||
+  downloadState.value?.status === 'fetching-manifest',
+);
+
+const isDone = computed(() => downloadState.value?.status === 'done');
+const isError = computed(() => downloadState.value?.status === 'error');
+
+const progress = computed(() => downloadState.value?.progress ?? 0);
+
+// Pre-install: show logo directly from Gitea (pack not on disk yet).
+// Update mode: pack is installed, serve from local /packs/ route.
+const logoSrc = computed(() => {
+  if (!props.packEntry) return '';
+  if (props.isUpdate) return packRegistry.getLocalLogoUrl(props.packEntry.id);
+  return getPackLogoUrl(props.packEntry.id);
+});
+
+// Close automatically once download completes and emit so parent sets the game
+watch(isDone, (done) => {
+  if (done && props.packEntry) {
+    emit('downloaded', props.packEntry.name);
+    emit('update:modelValue', false);
+  }
+});
+
+// ── Actions ───────────────────────────────────────────────────────────────────
+
+const startDownload = () => {
+  if (!props.packEntry) return;
+  if (props.isUpdate) {
+    packRegistry.updatePack(props.packEntry.id);
+  } else {
+    packRegistry.downloadPack(props.packEntry.id);
+  }
+};
+
+const close = () => emit('update:modelValue', false);
+</script>
+
+<template>
+  <QDialog
+    :model-value="modelValue"
+    persistent
+    @update:model-value="emit('update:modelValue', $event)"
+  >
+    <QCard
+      v-if="packEntry"
+      class="pack-download-dialog"
+    >
+      <!-- ── Header ─────────────────────────────────────────────────────── -->
+      <QCardSection class="pack-download-dialog__header">
+        <div class="pack-download-dialog__title-row">
+          <div>
+            <div class="text-h6 text-weight-bold">
+              {{ packEntry.name }}
+            </div>
+            <div class="text-caption text-grey-5">
+              <template v-if="isUpdate && updateInfo">
+                Bundled v{{ updateInfo.installedVersion }} →
+                <span class="text-positive">v{{ updateInfo.latestVersion }}</span>
+                · {{ packEntry.characterCount }} personajes
+              </template>
+              <template v-else>
+                v{{ packEntry.version }} · {{ packEntry.characterCount }} personajes ·
+                {{ packRegistry.formatBytes(packEntry.totalSizeBytes) }}
+              </template>
+            </div>
+          </div>
+          <QBtn
+            v-if="!isDownloading"
+            flat
+            round
+            dense
+            icon="close"
+            @click="close"
+          />
+        </div>
+
+        <!-- Banner: logo del juego con gradiente de fallback -->
+        <div
+          class="pack-download-dialog__banner"
+          :style="{
+            background: `linear-gradient(135deg, ${packEntry.palette.start}, ${packEntry.palette.end})`,
+          }"
+        >
+          <img
+            v-if="logoSrc"
+            :src="logoSrc"
+            class="pack-download-dialog__logo"
+            alt=""
+            @error="($event.target as HTMLImageElement).style.display = 'none'"
+          />
+          <QIcon
+            :name="isUpdate ? 'upgrade' : 'sports_esports'"
+            size="40px"
+            color="white"
+            class="pack-download-dialog__banner-icon"
+          />
+        </div>
+
+        <!-- Version info shown only in update mode -->
+        <div
+          v-if="isUpdate && updateInfo"
+          class="pack-download-dialog__version-badge"
+        >
+          <span class="text-grey-5">v{{ updateInfo.installedVersion }}</span>
+          <QIcon name="arrow_forward" size="14px" color="grey-5" />
+          <span class="text-positive text-weight-bold">v{{ updateInfo.latestVersion }}</span>
+        </div>
+      </QCardSection>
+
+      <QSeparator />
+
+      <!-- ── Progress / error ───────────────────────────────────────────── -->
+      <QCardSection
+        v-if="isDownloading || isDone || isError"
+        class="pack-download-dialog__progress-section"
+      >
+        <div
+          v-if="isError"
+          class="pack-download-dialog__error"
+        >
+          <QIcon
+            name="error"
+            color="negative"
+            size="20px"
+          />
+          <span>{{ downloadState?.error ?? 'Error desconocido' }}</span>
+        </div>
+
+        <template v-else>
+          <div class="pack-download-dialog__progress-label">
+            <span>{{ isDownloading ? 'Descargando…' : '¡Listo!' }}</span>
+            <span>{{ progress }}%</span>
+          </div>
+          <QLinearProgress
+            :value="progress / 100"
+            :color="isDone ? 'positive' : 'primary'"
+            rounded
+            size="8px"
+          />
+        </template>
+      </QCardSection>
+
+      <!-- ── Character list ─────────────────────────────────────────────── -->
+      <QCardSection class="pack-download-dialog__char-section">
+        <div class="text-caption text-grey-5 q-mb-sm">
+          Personajes incluidos
+        </div>
+        <!-- We only have the count in the registry entry; the full list lives
+             in the manifest. Show a placeholder grid until the registry has
+             a characters array (future enhancement: include it in registry.json). -->
+        <div class="pack-download-dialog__char-count">
+          <QIcon
+            name="sports_martial_arts"
+            size="16px"
+          />
+          {{ packEntry.characterCount }} personajes en este pack
+        </div>
+      </QCardSection>
+
+      <QSeparator />
+
+      <!-- ── Actions ────────────────────────────────────────────────────── -->
+      <QCardActions
+        align="right"
+        class="q-pa-md"
+      >
+        <QBtn
+          v-if="!isDownloading"
+          flat
+          label="Cancelar"
+          color="grey-5"
+          @click="close"
+        />
+        <QBtn
+          v-if="!isDownloading && !isDone"
+          unelevated
+          :label="isError ? 'Reintentar' : isUpdate ? 'Actualizar pack' : 'Descargar pack'"
+          :color="isUpdate ? 'positive' : 'primary'"
+          :icon="isUpdate ? 'upgrade' : 'download'"
+          @click="startDownload"
+        />
+        <QBtn
+          v-if="isDownloading"
+          flat
+          :label="isUpdate ? 'Actualizando…' : 'Descargando…'"
+          :color="isUpdate ? 'positive' : 'primary'"
+          loading
+          disable
+        />
+      </QCardActions>
+    </QCard>
+  </QDialog>
+</template>
+
+<style scoped>
+.pack-download-dialog {
+  width: 420px;
+  max-width: 95vw;
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+.pack-download-dialog__header {
+  padding-bottom: 0;
+}
+
+.pack-download-dialog__title-row {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin-bottom: 14px;
+}
+
+.pack-download-dialog__banner {
+  position: relative;
+  height: 88px;
+  border-radius: 10px;
+  margin-bottom: 4px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+}
+
+.pack-download-dialog__logo {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  border-radius: 10px;
+}
+
+.pack-download-dialog__banner-icon {
+  position: relative; /* above the logo */
+  opacity: 0.25;
+}
+
+.pack-download-dialog__progress-section {
+  padding-top: 12px;
+  padding-bottom: 12px;
+}
+
+.pack-download-dialog__progress-label {
+  display: flex;
+  justify-content: space-between;
+  font-size: 13px;
+  margin-bottom: 6px;
+  color: rgba(255, 255, 255, 0.75);
+}
+
+.pack-download-dialog__error {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--q-negative);
+  font-size: 13px;
+}
+
+.pack-download-dialog__char-section {
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+
+.pack-download-dialog__char-count {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 14px;
+  color: rgba(255, 255, 255, 0.85);
+}
+
+.pack-download-dialog__version-badge {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 13px;
+  margin-top: 8px;
+}
+</style>

src/dashboard/scoreko-dev/components/PlayerSidePanel.vue

@@ -1,9 +1,9 @@
 <script setup lang="ts">
 import { computed, inject } from 'vue';
-import { useScoreboardStore } from '../stores/scoreboard';
-import { usePlayerSide } from '../composables/usePlayerSide';
 import { CHARACTER_GAME_KEY } from '../composables/useCharacterGame';
+import { usePlayerSide } from '../composables/usePlayerSide';
 import { t } from '../i18n';
+import { useScoreboardStore } from '../stores/scoreboard';
 
 // ---------------------------------------------------------------------------
 // Props
@@ -140,6 +140,19 @@ const sideImageLabel = computed(() => t(isLeft.value ? 'scoreboardLeftImage' : '
             <template #prepend>
               <QIcon name="sports_martial_arts" />
             </template>
+            <template #option="scope">
+              <QItem v-bind="scope.itemProps">
+                <QItemSection>
+                  <QItemLabel class="scoreboard-preview__character-option">
+                    {{ scope.opt.label }}
+                    <span
+                      v-if="scope.opt.dlc"
+                      class="scoreboard-preview__dlc-badge"
+                    >DLC</span>
+                  </QItemLabel>
+                </QItemSection>
+              </QItem>
+            </template>
           </QSelect>
         </div>
 
@@ -372,6 +385,19 @@ const sideImageLabel = computed(() => t(isLeft.value ? 'scoreboardLeftImage' : '
             <template #prepend>
               <QIcon name="sports_martial_arts" />
             </template>
+            <template #option="scope">
+              <QItem v-bind="scope.itemProps">
+                <QItemSection>
+                  <QItemLabel class="scoreboard-preview__character-option">
+                    {{ scope.opt.label }}
+                    <span
+                      v-if="scope.opt.dlc"
+                      class="scoreboard-preview__dlc-badge"
+                    >DLC</span>
+                  </QItemLabel>
+                </QItemSection>
+              </QItem>
+            </template>
           </QSelect>
         </div>
       </template>
@@ -481,6 +507,27 @@ const sideImageLabel = computed(() => t(isLeft.value ? 'scoreboardLeftImage' : '
   color: rgba(255, 255, 255, 0.92);
 }
 
+.scoreboard-preview__character-option {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.scoreboard-preview__dlc-badge {
+  display: inline-flex;
+  align-items: center;
+  padding: 1px 5px;
+  border-radius: 3px;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.05em;
+  line-height: 14px;
+  background: rgba(139, 92, 246, 0.2);
+  color: #a78bfa;
+  border: 1px solid rgba(139, 92, 246, 0.45);
+  flex-shrink: 0;
+}
+
 @media (max-width: 900px) {
   .scoreboard-preview__image-wrap {
     width: min(100%, 280px);

src/dashboard/scoreko-dev/components/ScoreCenterPanel.vue

@@ -1,11 +1,36 @@
 <script setup lang="ts">
-import { inject } from 'vue';
+import { inject, onMounted, onUnmounted, ref } from 'vue';
-import { useScoreboardStore } from '../stores/scoreboard';
 import { CHARACTER_GAME_KEY } from '../composables/useCharacterGame';
+import { usePackRegistry } from '../composables/usePackRegistry';
 import { t } from '../i18n';
+import { useScoreboardStore } from '../stores/scoreboard';
+import GamePackDownloadDialog from './GamePackDownloadDialog.vue';
 
 const scoreboardStore = useScoreboardStore();
-const { gameInput, fightingGameOptions, onGameFilter } = inject(CHARACTER_GAME_KEY)!;
+const packRegistry = usePackRegistry();
+
+const {
+  gameInput,
+  fightingGameOptions,
+  onGameFilter,
+  handleGameSelect,
+  pendingDownloadEntry,
+  showDownloadDialog,
+} = inject(CHARACTER_GAME_KEY)!;
+
+// Refresca el catálogo al montar y luego cada 15 segundos automáticamente.
+// Si Gitea no está disponible se usa la caché persistida del replicante.
+onMounted(() => {
+  packRegistry.fetchRegistry();
+});
+
+const refreshInterval = setInterval(() => {
+  packRegistry.fetchRegistry();
+}, 15_000);
+
+onUnmounted(() => {
+  clearInterval(refreshInterval);
+});
 
 const adjustLeftScore = (delta: number) => {
   scoreboardStore.leftScore = Math.max(0, scoreboardStore.leftScore + delta);
@@ -14,12 +39,33 @@ const adjustLeftScore = (delta: number) => {
 const adjustRightScore = (delta: number) => {
   scoreboardStore.rightScore = Math.max(0, scoreboardStore.rightScore + delta);
 };
+
+/** Tras una descarga exitosa, activa el juego en el store. */
+const onPackDownloaded = (gameName: string) => {
+  scoreboardStore.scoreboard.game = gameName;
+};
+
+// ── Estado del diálogo de actualización ───────────────────────────────────────
+const pendingUpdateEntry = ref<import('../../../shared/pack-types').PackRegistryEntry | null>(null);
+const pendingUpdateInfo  = ref<{ installedVersion: string; latestVersion: string } | undefined>(undefined);
+const showUpdateDialog   = ref(false);
+
+const openUpdateDialog = (opt: import('../../../shared/pack-types').GameSelectOption, event: Event) => {
+  event.stopPropagation(); // evitar que el QItem cambie la selección
+  pendingUpdateEntry.value = opt.registryEntry;
+  pendingUpdateInfo.value  = opt.updateInfo;
+  showUpdateDialog.value   = true;
+};
 </script>
 
 <template>
   <div class="scoreboard-preview__center">
+    <!--
+      v-model → :model-value + @update:model-value para interceptar la
+      selección de juegos no instalados antes de escribir en el store.
+    -->
     <QSelect
-      v-model="scoreboardStore.scoreboard.game"
+      :model-value="scoreboardStore.scoreboard.game"
       v-model:input-value="gameInput"
       :options="fightingGameOptions"
       :label="t('scoreboardLabelGame')"
@@ -32,10 +78,59 @@ const adjustRightScore = (delta: number) => {
       fill-input
       class="scoreboard-preview__field scoreboard-preview__game-field"
       @filter="onGameFilter"
+      @update:model-value="handleGameSelect"
     >
       <template #prepend>
         <QIcon name="sports_esports" />
       </template>
+
+      <!-- Slot personalizado: muestra iconos de descarga o actualización según el estado -->
+      <template #option="scope">
+        <QItem
+          v-bind="scope.itemProps"
+          :class="{ 'pack-option--unavailable': !scope.opt.available }"
+        >
+          <QItemSection>
+            <QItemLabel>{{ scope.opt.label }}</QItemLabel>
+          </QItemSection>
+
+          <!-- Icono de actualización disponible (pack instalado, versión nueva en repo) -->
+          <QItemSection
+            v-if="scope.opt.available && scope.opt.updateInfo"
+            side
+          >
+            <QBtn
+              flat
+              round
+              dense
+              size="xs"
+              icon="upgrade"
+              color="positive"
+              @click="openUpdateDialog(scope.opt, $event)"
+            >
+              <QTooltip>
+                Actualización disponible:
+                v{{ scope.opt.updateInfo.installedVersion }} →
+                v{{ scope.opt.updateInfo.latestVersion }}
+              </QTooltip>
+            </QBtn>
+          </QItemSection>
+
+          <!-- Icono de descarga (pack no instalado) -->
+          <QItemSection
+            v-else-if="!scope.opt.available"
+            side
+          >
+            <QIcon
+              name="download"
+              size="16px"
+              color="grey-5"
+            >
+              <QTooltip>Pack no instalado — haz clic para descargarlo</QTooltip>
+            </QIcon>
+          </QItemSection>
+        </QItem>
+      </template>
     </QSelect>
 
     <div class="scoreboard-preview__score-controls">
@@ -101,8 +196,25 @@ const adjustRightScore = (delta: number) => {
         class="scoreboard-preview__action-btn"
         @click="scoreboardStore.resetScores"
       />
+
     </div>
   </div>
+
+  <!-- Dialog de descarga — se abre automáticamente al seleccionar un juego no instalado -->
+  <GamePackDownloadDialog
+    v-model="showDownloadDialog"
+    :pack-entry="pendingDownloadEntry"
+    @downloaded="onPackDownloaded"
+  />
+
+  <!-- Dialog de actualización — se abre al hacer clic en el icono de upgrade -->
+  <GamePackDownloadDialog
+    v-model="showUpdateDialog"
+    :pack-entry="pendingUpdateEntry"
+    :is-update="true"
+    :update-info="pendingUpdateInfo"
+    @downloaded="onPackDownloaded"
+  />
 </template>
 
 <style scoped>
@@ -188,4 +300,13 @@ const adjustRightScore = (delta: number) => {
 .scoreboard-preview__field :deep(.q-field__label) {
   color: rgba(255, 255, 255, 0.92);
 }
+
+/* Atenúa visualmente los juegos no instalados en el desplegable */
+.pack-option--unavailable {
+  opacity: 0.6;
+}
+
+.pack-option--unavailable:hover {
+  opacity: 1;
+}
 </style>

src/dashboard/scoreko-dev/composables/useCharacterGame.ts

@@ -1,56 +1,96 @@
+// src/dashboard/scoreboard/composables/useCharacterGame.ts
+// ─────────────────────────────────────────────────────────────────────────────
+// Manages game selection and character state for both PlayerSidePanels.
+// Must be called ONCE in ScoreboardPanel and provided via CHARACTER_GAME_KEY.
+//
+// Changes from original:
+//   - fightingGameOptions is now driven by the pack registry (allGameOptions)
+//     rather than a static hardcoded list. It falls back to bundled names
+//     while the registry loads.
+//   - Game selection is intercepted: selecting an unavailable game triggers
+//     the download dialog instead of updating the store.
+//   - pendingDownloadEntry / showDownloadDialog are exposed for ScoreCenterPanel.
+// ─────────────────────────────────────────────────────────────────────────────
+
 import { computed, ref, watch, type InjectionKey, type Ref } from 'vue';
-import { getCharactersByGame, getDefaultCharactersByGame } from '../../../shared/fighting-characters';
+import { getCharactersByGame, getDefaultCharactersByGame, installedPacksRevision } from '../../../shared/fighting-characters';
+import type { GameSelectOption, PackRegistryEntry } from '../../../shared/pack-types';
 import { useScoreboardStore } from '../stores/scoreboard';
+import { usePackRegistry } from './usePackRegistry';
 
-// ---------------------------------------------------------------------------
+// ── Types ─────────────────────────────────────────────────────────────────────
-// Constants
-// ---------------------------------------------------------------------------
-
-export const ALL_FIGHTING_GAME_OPTIONS = [
-  '2XKO',
-  'Mortal Kombat 1',
-  'Street Fighter 6',
-  'TEKKEN 8',
-  'Guilty Gear -Strive-',
-  'THE KING OF FIGHTERS XV',
-].map((game) => ({ label: game, value: game }));
 
 export type CharacterOption = ReturnType<typeof getCharactersByGame>[number];
-
-// ---------------------------------------------------------------------------
-// Injection key (type-safe provide/inject)
-// ---------------------------------------------------------------------------
-
 export type CharacterGameContext = ReturnType<typeof useCharacterGame>;
 export const CHARACTER_GAME_KEY: InjectionKey<CharacterGameContext> = Symbol('characterGame');
 
-// ---------------------------------------------------------------------------
+// ── Composable ────────────────────────────────────────────────────────────────
-// Composable
-// ---------------------------------------------------------------------------
 
-/**
- * Manages game selection and character state for both sides.
- * Must be called ONCE in the parent (ScoreboardPanel) and provided via
- * CHARACTER_GAME_KEY so both PlayerSidePanel instances share the same state.
- */
 export function useCharacterGame() {
   const scoreboardStore = useScoreboardStore();
+  const packRegistry = usePackRegistry();
+
+  // ── Game selector state ───────────────────────────────────────────────────
 
-  // Game selector
   const gameInput = ref('');
-  const fightingGameOptions = ref(ALL_FIGHTING_GAME_OPTIONS);
 
-  // Per-side character state
+  /**
-  const characterOptions = computed(() => getCharactersByGame(scoreboardStore.scoreboard.game));
+   * Game options surfaced to the QSelect.
+   * Populated from the pack registry when available; falls back to bundled games.
+   * GameSelectOption includes an `available` flag used to show the download icon.
+   */
+  const fightingGameOptions = ref<GameSelectOption[]>([]);
+
+  // Keep fightingGameOptions in sync when the registry updates
+  watch(
+    packRegistry.allGameOptions,
+    (options) => {
+      fightingGameOptions.value = options;
+    },
+  );
+
+  // ── Download dialog state ─────────────────────────────────────────────────
+
+  /** Set when the user selects a game that isn't installed yet. */
+  const pendingDownloadEntry = ref<PackRegistryEntry | null>(null);
+  const showDownloadDialog = ref(false);
+
+  /**
+   * Intercepting setter for the game selector.
+   * If the selected game is not available, opens the download dialog instead
+   * of writing to the store.
+   */
+  const handleGameSelect = (gameName: string) => {
+    if (!gameName) {
+      scoreboardStore.scoreboard.game = '';
+      return;
+    }
+    if (!packRegistry.isGameAvailable(gameName)) {
+      const entry = fightingGameOptions.value.find((o) => o.value === gameName)?.registryEntry ?? null;
+      pendingDownloadEntry.value = entry;
+      showDownloadDialog.value = true;
+      // Do NOT update the store — the game isn't installed
+      return;
+    }
+    scoreboardStore.scoreboard.game = gameName;
+  };
+
+  // ── Character state ───────────────────────────────────────────────────────
+
+  const characterOptions = computed(() => {
+    // Subscribing to installedPacksRevision forces Vue to re-evaluate this
+    // computed whenever a pack is registered/unregistered at runtime, even
+    // though scoreboardStore.scoreboard.game itself hasn't changed.
+    void installedPacksRevision.value;
+    return getCharactersByGame(scoreboardStore.scoreboard.game);
+  });
   const leftCharacterOptions = ref<CharacterOption[]>([]);
   const rightCharacterOptions = ref<CharacterOption[]>([]);
   const leftCharacterInput = ref('');
   const rightCharacterInput = ref('');
 
-  // Remembers selected characters per game so swapping games restores them
   const charactersByGame = ref<Record<string, { leftCharacter: string; rightCharacter: string }>>({});
 
-  // Character images for preview
   const leftCharacterImage = computed(() => {
     const match = characterOptions.value.find(
       (o) => o.value === scoreboardStore.scoreboard.leftCharacter,
@@ -65,20 +105,21 @@ export function useCharacterGame() {
     return match?.image ?? '';
   });
 
-  // ---------------------------------------------------------------------------
+  // ── Filter handlers ───────────────────────────────────────────────────────
-  // Filter handlers
-  // ---------------------------------------------------------------------------
 
   const onGameFilter = (value: string, update: (fn: () => void) => void) => {
     update(() => {
       const needle = value.toLowerCase().trim();
       fightingGameOptions.value = needle
-        ? ALL_FIGHTING_GAME_OPTIONS.filter((g) => g.label.toLowerCase().includes(needle))
+        ? packRegistry.allGameOptions.value.filter((g) =>
-        : ALL_FIGHTING_GAME_OPTIONS;
+            g.label.toLowerCase().includes(needle),
+          )
+        : packRegistry.allGameOptions.value;
     });
   };
 
-  const makeCharacterFilter = (target: Ref<CharacterOption[]>) =>
+  const makeCharacterFilter =
+    (target: Ref<CharacterOption[]>) =>
     (value: string, update: (fn: () => void) => void) => {
       update(() => {
         const needle = value.toLowerCase().trim();
@@ -91,16 +132,14 @@ export function useCharacterGame() {
   const onLeftCharacterFilter = makeCharacterFilter(leftCharacterOptions);
   const onRightCharacterFilter = makeCharacterFilter(rightCharacterOptions);
 
-  // ---------------------------------------------------------------------------
+  // ── Watchers ──────────────────────────────────────────────────────────────
-  // Watchers
-  // ---------------------------------------------------------------------------
 
-  // Keep gameInput display value in sync
+  // Keep gameInput display value in sync with the store
   watch(
     () => scoreboardStore.scoreboard.game,
     (value) => {
-      const match = ALL_FIGHTING_GAME_OPTIONS.find((o) => o.value === value);
+      const match = fightingGameOptions.value.find((o) => o.value === value);
-      gameInput.value = match?.label ?? '';
+      gameInput.value = match?.label ?? value;
     },
     { immediate: true },
   );
@@ -117,6 +156,13 @@ export function useCharacterGame() {
       }
 
       const options = getCharactersByGame(newGame);
+
+      // If the game is set but has no options yet, the pack is still loading
+      // (installed pack whose registerInstalledPack() hasn't run yet).
+      // Bail out — the installedPacksRevision watcher below will restore state
+      // once the pack becomes available.
+      if (newGame && options.length === 0) return;
+
       leftCharacterOptions.value = options;
       rightCharacterOptions.value = options;
       const allowed = new Set(options.map((o) => o.value));
@@ -129,7 +175,6 @@ export function useCharacterGame() {
       if (!allowed.has(nextLeft)) nextLeft = '';
       if (!allowed.has(nextRight)) nextRight = '';
 
-      // Apply defaults only when neither side had a character yet
       if ((!nextLeft || !nextRight) && (!curLeft || !curRight)) {
         const defaults = getDefaultCharactersByGame(newGame);
         if (defaults) {
@@ -155,7 +200,6 @@ export function useCharacterGame() {
     { immediate: true },
   );
 
-  // Keep left character display input and charactersByGame cache in sync
   watch(
     () => scoreboardStore.scoreboard.leftCharacter,
     (value) => {
@@ -172,7 +216,6 @@ export function useCharacterGame() {
     { immediate: true },
   );
 
-  // Keep right character display input and charactersByGame cache in sync
   watch(
     () => scoreboardStore.scoreboard.rightCharacter,
     (value) => {
@@ -189,16 +232,55 @@ export function useCharacterGame() {
     { immediate: true },
   );
 
+  // When an installed pack becomes available (e.g. after page refresh while
+  // the pack loads asynchronously), re-validate and restore the characters
+  // that are already in the store but couldn't be confirmed before.
+  watch(installedPacksRevision, () => {
+    const game = scoreboardStore.scoreboard.game;
+    if (!game) return;
+
+    const options = getCharactersByGame(game);
+    if (options.length === 0) return;
+
+    const allowed = new Set(options.map((o) => o.value));
+    leftCharacterOptions.value = options;
+    rightCharacterOptions.value = options;
+
+    const { leftCharacter, rightCharacter } = scoreboardStore.scoreboard;
+
+    if (leftCharacter && allowed.has(leftCharacter)) {
+      leftCharacterInput.value = options.find((o) => o.value === leftCharacter)?.label ?? '';
+    } else if (leftCharacter && !allowed.has(leftCharacter)) {
+      scoreboardStore.scoreboard.leftCharacter = '';
+      leftCharacterInput.value = '';
+    }
+
+    if (rightCharacter && allowed.has(rightCharacter)) {
+      rightCharacterInput.value = options.find((o) => o.value === rightCharacter)?.label ?? '';
+    } else if (rightCharacter && !allowed.has(rightCharacter)) {
+      scoreboardStore.scoreboard.rightCharacter = '';
+      rightCharacterInput.value = '';
+    }
+  });
+
+  // ── Return ────────────────────────────────────────────────────────────────
+
   return {
+    // Game selector
     gameInput,
     fightingGameOptions,
+    onGameFilter,
+    handleGameSelect,
+    // Download dialog
+    pendingDownloadEntry,
+    showDownloadDialog,
+    // Character state
     leftCharacterOptions,
     rightCharacterOptions,
     leftCharacterInput,
     rightCharacterInput,
     leftCharacterImage,
     rightCharacterImage,
-    onGameFilter,
     onLeftCharacterFilter,
     onRightCharacterFilter,
   };

src/dashboard/scoreko-dev/composables/useCountryFilter.ts

@@ -1,5 +1,5 @@
 import { computed, ref, watch } from 'vue';
-import { getCountryLabel, getCountryOptions } from '../../../shared/countries';
+import { getCountryLabel, getCountryOptions } from '../../../shared/utils/countries';
 import { locale } from '../i18n';
 
 /**

src/dashboard/scoreko-dev/composables/useIntegration.ts

@@ -0,0 +1,444 @@
+import { computed, onBeforeUnmount, onMounted, reactive, ref, watch } from 'vue';
+
+// ─── Tipos ─────────────────────────────────────────────────────────────────────
+
+export interface IntegrationTournament {
+  id: string | number;
+  name: string;
+  slug: string;
+  startAt: number | null;
+  endAt: number | null;
+}
+
+export interface IntegrationPlayer {
+  id: string;
+  gamertag: string;
+  name: string;
+  team: string;
+  country: string;
+  twitter: string;
+}
+
+export interface TemporaryPlayerMeta {
+  expiresAt: number;
+  tournamentSlug: string;
+}
+
+export type TemporaryPlayersMap = Record<string, TemporaryPlayerMeta>;
+
+interface TournamentOption {
+  label: string;
+  value: string;
+  caption: string;
+}
+
+interface OAuthSessionResponse {
+  sessionId: string;
+  authUrl: string;
+}
+
+interface OAuthStatusResponse {
+  status: 'pending' | 'completed' | 'error' | 'expired';
+  token?: string;
+  error?: string;
+}
+
+export interface PlayersStore {
+  upsertPlayer: (id: string, data: Omit<IntegrationPlayer, 'id'>) => void;
+  removePlayer: (id: string) => void;
+}
+
+export interface UseIntegrationOptions {
+  /** Prefijo de los mensajes NodeCG, p.ej. 'startgg' | 'challonge' */
+  messagePrefix: string;
+  /** Nombre legible del proveedor para mensajes de error */
+  providerLabel: string;
+  /** Clave de localStorage para el token */
+  tokenStorageKey: string;
+  /** Clave de localStorage para los jugadores temporales */
+  tempPlayersStorageKey: string;
+  /** Segundos que duran los jugadores temporales si el torneo no tiene endAt */
+  tempFallbackDurationSeconds: number;
+  /** Mensaje de error personalizado cuando la API devuelve 401 */
+  on401Message?: string;
+  /** Store de jugadores */
+  playersStore: PlayersStore;
+}
+
+// ─── Utilidad para mensajes NodeCG ─────────────────────────────────────────────
+
+const sendNodeCGMessage = <T>(messageName: string, payload: unknown): Promise<T> =>
+  new Promise((resolve, reject) => {
+    nodecg.sendMessage(messageName, payload, (error: unknown, response: unknown) => {
+      if (error) {
+        reject(new Error(String(error)));
+        return;
+      }
+      resolve(response as T);
+    });
+  });
+
+// ─── Composable ────────────────────────────────────────────────────────────────
+
+export function useIntegration(options: UseIntegrationOptions) {
+  const {
+    messagePrefix,
+    providerLabel,
+    tokenStorageKey,
+    tempPlayersStorageKey,
+    tempFallbackDurationSeconds,
+    on401Message,
+    playersStore,
+  } = options;
+
+  // ── Token ───────────────────────────────────────────────────────────────────
+  const token = ref(localStorage.getItem(tokenStorageKey) ?? '');
+  const hasValidatedToken = ref(false);
+
+  watch(token, (value) => {
+    localStorage.setItem(tokenStorageKey, value);
+    hasValidatedToken.value = false;
+    if (!value.trim()) {
+      recentTournaments.value = [];
+      selectedTournamentSlug.value = '';
+      tournamentInput.value = '';
+      tournamentsError.value = '';
+    }
+  });
+
+  // ── Lista de torneos ────────────────────────────────────────────────────────
+  const recentTournaments = ref<IntegrationTournament[]>([]);
+  const loadingTournaments = ref(false);
+  const tournamentsError = ref('');
+  const selectedTournamentSlug = ref('');
+  const tournamentInput = ref('');
+
+  const tournamentOptions = computed<TournamentOption[]>(() =>
+    recentTournaments.value.map((t) => ({
+      label: t.name,
+      value: t.slug,
+      caption: t.slug,
+    })),
+  );
+
+  const filteredTournamentOptions = ref<TournamentOption[]>(tournamentOptions.value);
+
+  watch(tournamentOptions, (value) => {
+    filteredTournamentOptions.value = value;
+    if (
+      selectedTournamentSlug.value &&
+      !recentTournaments.value.some((t) => t.slug === selectedTournamentSlug.value)
+    ) {
+      selectedTournamentSlug.value = '';
+      tournamentInput.value = '';
+    }
+  });
+
+  const filterTournaments = (value: string, update: (cb: () => void) => void) => {
+    update(() => {
+      const needle = value.toLowerCase().trim();
+      filteredTournamentOptions.value = needle
+        ? tournamentOptions.value.filter(
+          (o) =>
+            o.label.toLowerCase().includes(needle) ||
+            o.caption.toLowerCase().includes(needle),
+        )
+        : tournamentOptions.value;
+    });
+  };
+
+  const selectedTournamentOption = computed<IntegrationTournament | null>(
+    () => recentTournaments.value.find((t) => t.slug === selectedTournamentSlug.value) ?? null,
+  );
+
+  const canImportSelectedTournament = computed(() => Boolean(selectedTournamentOption.value));
+  const hasTokenConfigured = computed(() => Boolean(token.value.trim()));
+
+  const loadRecentTournaments = async () => {
+    const currentToken = token.value.trim();
+    if (!currentToken) {
+      tournamentsError.value = `Add your ${providerLabel} token to load tournaments.`;
+      recentTournaments.value = [];
+      return;
+    }
+
+    tournamentsError.value = '';
+    loadingTournaments.value = true;
+    try {
+      const tournaments = await sendNodeCGMessage<IntegrationTournament[]>(
+        `${messagePrefix}:fetchRecentTournaments`,
+        { token: currentToken },
+      );
+      hasValidatedToken.value = true;
+      recentTournaments.value = tournaments;
+      if (!tournaments.length) {
+        tournamentsError.value = 'There are no recent tournaments for this account.';
+      }
+    } catch (error) {
+      hasValidatedToken.value = false;
+      const message = error instanceof Error ? error.message : 'Could not load tournaments.';
+      tournamentsError.value =
+        on401Message && message.includes('401') ? on401Message : message;
+      recentTournaments.value = [];
+    } finally {
+      loadingTournaments.value = false;
+    }
+  };
+
+  // ── Importación de jugadores ────────────────────────────────────────────────
+  const players = ref<IntegrationPlayer[]>([]);
+  const selectedPlayerIds = ref<string[]>([]);
+  const importDialogOpen = ref(false);
+  const importDialogError = ref('');
+  const loadingPlayers = ref(false);
+  const importingTournament = ref<IntegrationTournament | null>(null);
+
+  const openImportDialog = async (tournament: IntegrationTournament): Promise<void> => {
+    importingTournament.value = tournament;
+    importDialogOpen.value = true;
+    importDialogError.value = '';
+    loadingPlayers.value = true;
+    selectedPlayerIds.value = [];
+    selectedTournamentSlug.value = tournament.slug;
+    tournamentInput.value = tournament.name;
+    players.value = [];
+
+    try {
+      const importedPlayers = await sendNodeCGMessage<IntegrationPlayer[]>(
+        `${messagePrefix}:fetchTournamentPlayers`,
+        { token: token.value.trim(), slug: tournament.slug },
+      );
+      players.value = importedPlayers;
+      selectedPlayerIds.value = importedPlayers.map((p) => p.id);
+    } catch (error) {
+      importDialogError.value =
+        error instanceof Error ? error.message : 'Could not load players';
+      importDialogOpen.value = false;
+    } finally {
+      loadingPlayers.value = false;
+    }
+  };
+
+  const openSelectedTournamentImportDialog = () => {
+    if (selectedTournamentOption.value) {
+      void openImportDialog(selectedTournamentOption.value);
+    }
+  };
+
+  const toggleAllPlayers = () => {
+    selectedPlayerIds.value =
+      selectedPlayerIds.value.length === players.value.length
+        ? []
+        : players.value.map((p) => p.id);
+  };
+
+  const importSelectedPlayers = () => {
+    const selected = players.value.filter((p) => selectedPlayerIds.value.includes(p.id));
+    const tournament = importingTournament.value;
+    const fallbackEndAt =
+      (tournament?.startAt ?? Math.floor(Date.now() / 1000)) + tempFallbackDurationSeconds;
+    const expiresAt = tournament?.endAt ?? fallbackEndAt;
+    const nextMeta = { ...temporaryPlayers.value };
+
+    for (const player of selected) {
+      playersStore.upsertPlayer(player.id, {
+        gamertag: player.gamertag,
+        name: player.name,
+        team: player.team,
+        country: player.country,
+        twitter: player.twitter,
+      });
+      if (tournament) {
+        nextMeta[player.id] = { expiresAt, tournamentSlug: tournament.slug };
+      }
+    }
+
+    temporaryPlayers.value = nextMeta;
+    persistTemporaryPlayers();
+    importDialogOpen.value = false;
+  };
+
+  // ── Jugadores temporales ────────────────────────────────────────────────────
+  const loadTemporaryPlayers = (): TemporaryPlayersMap => {
+    try {
+      const raw = localStorage.getItem(tempPlayersStorageKey);
+      if (!raw) return {};
+      const parsed = JSON.parse(raw) as unknown;
+      if (typeof parsed !== 'object' || parsed === null) return {};
+
+      const result: TemporaryPlayersMap = {};
+      Object.entries(parsed as Record<string, unknown>).forEach(([playerId, value]) => {
+        if (!playerId || typeof value !== 'object' || value === null) return;
+        const candidate = value as Record<string, unknown>;
+        const expiresAt = Number(candidate.expiresAt);
+        const tournamentSlug = String(candidate.tournamentSlug ?? '').trim();
+        if (!Number.isFinite(expiresAt) || expiresAt <= 0 || !tournamentSlug) return;
+        result[playerId] = { expiresAt, tournamentSlug };
+      });
+
+      return result;
+    } catch {
+      return {};
+    }
+  };
+
+  const temporaryPlayers = ref<TemporaryPlayersMap>({});
+
+  const persistTemporaryPlayers = () => {
+    localStorage.setItem(tempPlayersStorageKey, JSON.stringify(temporaryPlayers.value));
+  };
+
+  /**
+   * Elimina del store y del mapa los jugadores temporales cuyo expiresAt
+   * ha pasado. Se llama periódicamente en onMounted.
+   */
+  const cleanupExpiredTemporaryPlayers = () => {
+    const now = Math.floor(Date.now() / 1000);
+    const expiredIds = Object.entries(temporaryPlayers.value)
+      .filter(([, meta]) => meta.expiresAt <= now)
+      .map(([id]) => id);
+
+    if (!expiredIds.length) return;
+
+    const nextMeta = { ...temporaryPlayers.value };
+    for (const id of expiredIds) {
+      playersStore.removePlayer(id);
+      delete nextMeta[id];
+    }
+    temporaryPlayers.value = nextMeta;
+    persistTemporaryPlayers();
+  };
+
+  // ── OAuth ───────────────────────────────────────────────────────────────────
+  const oauthLoading = ref(false);
+  const oauthSessionId = ref('');
+  let oauthPollingTimer: ReturnType<typeof setInterval> | null = null;
+
+  const stopPolling = () => {
+    if (oauthPollingTimer) {
+      clearInterval(oauthPollingTimer);
+      oauthPollingTimer = null;
+    }
+  };
+
+  const checkOAuthStatus = async () => {
+    if (!oauthSessionId.value) return;
+
+    try {
+      const status = await sendNodeCGMessage<OAuthStatusResponse>(
+        `${messagePrefix}:getOAuthSessionStatus`,
+        { sessionId: oauthSessionId.value },
+      );
+
+      if (status.status === 'completed' && status.token) {
+        token.value = status.token;
+        oauthLoading.value = false;
+        stopPolling();
+        oauthSessionId.value = '';
+        tournamentsError.value = '';
+        await loadRecentTournaments();
+        return;
+      }
+
+      if (status.status === 'error' || status.status === 'expired') {
+        oauthLoading.value = false;
+        stopPolling();
+        oauthSessionId.value = '';
+        tournamentsError.value =
+          status.error ?? `Could not complete OAuth login with ${providerLabel}.`;
+      }
+    } catch (error) {
+      oauthLoading.value = false;
+      stopPolling();
+      oauthSessionId.value = '';
+      tournamentsError.value =
+        error instanceof Error ? error.message : 'Could not verify OAuth status.';
+    }
+  };
+
+  const connectWithOAuth = async () => {
+    oauthLoading.value = true;
+    tournamentsError.value = '';
+    stopPolling();
+
+    try {
+      const session = await sendNodeCGMessage<OAuthSessionResponse>(
+        `${messagePrefix}:createOAuthSession`,
+        {},
+      );
+      oauthSessionId.value = session.sessionId;
+      window.open(session.authUrl, '_blank', 'noopener,noreferrer');
+
+      oauthPollingTimer = setInterval(() => {
+        void checkOAuthStatus();
+      }, 1500);
+    } catch (error) {
+      oauthLoading.value = false;
+      tournamentsError.value =
+        error instanceof Error ? error.message : `Could not start OAuth with ${providerLabel}.`;
+    }
+  };
+
+  // ── Ciclo de vida ───────────────────────────────────────────────────────────
+  let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+  onMounted(() => {
+    temporaryPlayers.value = loadTemporaryPlayers();
+    cleanupExpiredTemporaryPlayers();
+    cleanupTimer = setInterval(cleanupExpiredTemporaryPlayers, 60 * 1000);
+
+    if (token.value.trim()) {
+      void loadRecentTournaments();
+    }
+  });
+
+  onBeforeUnmount(() => {
+    stopPolling();
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+    }
+  });
+
+  // ── Retorno como reactive para auto-unwrap en templates ─────────────────────
+  return reactive({
+    // Token
+    token,
+    hasTokenConfigured,
+    hasValidatedToken,
+
+    // Torneos
+    recentTournaments,
+    loadingTournaments,
+    tournamentsError,
+    selectedTournamentSlug,
+    tournamentInput,
+    tournamentOptions,
+    filteredTournamentOptions,
+    selectedTournamentOption,
+    canImportSelectedTournament,
+    filterTournaments,
+    loadRecentTournaments,
+
+    // Importación
+    players,
+    selectedPlayerIds,
+    importDialogOpen,
+    importDialogError,
+    loadingPlayers,
+    importingTournament,
+    openImportDialog,
+    openSelectedTournamentImportDialog,
+    importSelectedPlayers,
+    toggleAllPlayers,
+
+    // Jugadores temporales
+    temporaryPlayers,
+
+    // OAuth
+    oauthLoading,
+    connectWithOAuth,
+  });
+}
+
+export type IntegrationHandle = ReturnType<typeof useIntegration>;

src/dashboard/scoreko-dev/composables/usePackRegistry.ts

@@ -0,0 +1,266 @@
+// src/dashboard/scoreboard/composables/usePackRegistry.ts
+// ─────────────────────────────────────────────────────────────────────────────
+// Singleton composable. The first caller sets up NodeCG replicant listeners;
+// subsequent calls return the same reactive state. This avoids duplicate event
+// listeners when multiple components call usePackRegistry().
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { computed, ref, type ComputedRef, type InjectionKey } from 'vue';
+import {
+  registerInstalledPack,
+  unregisterInstalledPack,
+} from '../../../shared/fighting-characters';
+import { BUNDLE_NAME } from '../../../shared/pack-config';
+import type {
+  GameSelectOption,
+  PackDownloadState,
+  PackManifest,
+  PackRegistry
+} from '../../../shared/pack-types';
+
+// ── NodeCG global type declarations ──────────────────────────────────────────
+// NodeCG injects these into the browser window via its bundle script.
+
+declare const NodeCG: {
+  Replicant: <T>(
+    name: string,
+    bundleName: string,
+    opts?: { defaultValue?: T },
+  ) => {
+    value: T;
+    on(event: 'change', handler: (newVal: T, oldVal?: T) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+  };
+  waitForReplicants: (...reps: unknown[]) => Promise<void>;
+};
+
+declare const nodecg: {
+  sendMessage(name: string, data?: unknown): void;
+  sendMessage(
+    name: string,
+    data: unknown,
+    cb: (err: Error | null, result?: unknown) => void,
+  ): void;
+};
+
+// ── Module-level singleton state ──────────────────────────────────────────────
+
+let initialized = false;
+
+const registry = ref<PackRegistry | null>(null);
+const installedPackIds = ref<string[]>([]);
+const downloadStates = ref<Record<string, PackDownloadState>>({});
+const availableUpdates = ref<Record<string, { installedVersion: string; latestVersion: string }>>({});
+
+// Tracks which installed pack manifests have been loaded into fighting-characters.ts
+const loadedManifestIds = new Set<string>();
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
+/**
+ * Asks the NodeCG extension to read the local manifest.json for an installed
+ * pack and registers the characters in fighting-characters.ts.
+ */
+const loadInstalledManifest = (packId: string): void => {
+  if (loadedManifestIds.has(packId)) return;
+
+  nodecg.sendMessage('readLocalManifest', packId, (err, result) => {
+    if (err) {
+      console.error(`[usePackRegistry] Failed to load manifest for "${packId}":`, err);
+      return;
+    }
+    const manifest = result as PackManifest;
+    registerInstalledPack(manifest);
+    loadedManifestIds.add(packId);
+  });
+};
+
+// ── Replicant setup (runs once) ───────────────────────────────────────────────
+
+const initReplicants = (): void => {
+  if (initialized) return;
+  initialized = true;
+
+  const registryRep = NodeCG.Replicant<PackRegistry | null>('packRegistry', BUNDLE_NAME, {
+    defaultValue: null,
+  });
+  const installedRep = NodeCG.Replicant<string[]>('installedPacks', BUNDLE_NAME, {
+    defaultValue: [],
+  });
+  const statesRep = NodeCG.Replicant<Record<string, PackDownloadState>>('downloadStates', BUNDLE_NAME, {
+    defaultValue: {},
+  });
+
+  const updatesRep = NodeCG.Replicant<Record<string, { installedVersion: string; latestVersion: string }>>('availableUpdates', BUNDLE_NAME, {
+    defaultValue: {},
+  });
+
+  NodeCG.waitForReplicants(registryRep, installedRep, statesRep, updatesRep).then(() => {
+    // Hydrate initial values
+    registry.value = registryRep.value;
+    installedPackIds.value = installedRep.value ?? [];
+    downloadStates.value = statesRep.value ?? {};
+    availableUpdates.value = updatesRep.value ?? {};
+
+    // Load manifests for all installed packs
+    for (const id of installedPackIds.value) {
+      loadInstalledManifest(id);
+    }
+
+    // Subscribe to changes
+    registryRep.on('change', (val) => {
+      registry.value = val;
+    });
+
+    installedRep.on('change', (newVal, oldVal) => {
+      const next = newVal ?? [];
+      const prev = oldVal ?? [];
+      installedPackIds.value = next;
+
+      // Load manifests for newly installed packs
+      const added = next.filter((id) => !prev.includes(id));
+      for (const id of added) {
+        loadInstalledManifest(id);
+      }
+
+      // Unregister packs that were removed
+      const removed = prev.filter((id) => !next.includes(id));
+      for (const id of removed) {
+        const gameName = getGameNameById(id);
+        unregisterInstalledPack(gameName);
+        loadedManifestIds.delete(id);
+      }
+    });
+
+    statesRep.on('change', (val) => {
+      downloadStates.value = val ?? {};
+    });
+
+    updatesRep.on('change', (val) => {
+      availableUpdates.value = val ?? {};
+    });
+  });
+};
+
+/**
+ * Given a pack ID (e.g. "street-fighter-6"), returns the matching game name
+ * from the current registry, or an empty string if the registry isn't loaded.
+ */
+const getGameNameById = (packId: string): string =>
+  registry.value?.packs.find((p) => p.id === packId)?.name ?? '';
+
+// ── Public composable ─────────────────────────────────────────────────────────
+
+export interface PackRegistryContext {
+  /** Full registry fetched from Gitea (null until first fetch). */
+  registry: typeof registry;
+  /** IDs of packs installed on disk (bundled packs are NOT in this list). */
+  installedPackIds: typeof installedPackIds;
+  /** Per-pack download state. */
+  downloadStates: typeof downloadStates;
+  /** Checks if a game is available (bundled OR installed). */
+  isGameAvailable: (gameName: string) => boolean;
+  /** Returns the download state for a pack, or a default idle state. */
+  getDownloadState: (packId: string) => PackDownloadState;
+  /** All games from the registry, enriched with availability info. */
+  allGameOptions: ReturnType<typeof buildAllGameOptions>;
+  /** Tells the extension to fetch the latest registry.json from Gitea. */
+  fetchRegistry: () => void;
+  /** Tells the extension to download and install a pack. */
+  downloadPack: (packId: string) => void;
+  /** Tells the extension to uninstall a pack and delete its files. */
+  uninstallPack: (packId: string) => void;
+  /** Tells the extension to download and apply an update for an installed pack. */
+  updatePack: (packId: string) => void;
+  /** Map of packId → version info for packs that have a newer version available. */
+  availableUpdates: typeof availableUpdates;
+  /** Total number of packs with available updates. */
+  updateCount: ComputedRef<number>;
+  /** Human-readable file size. */
+  formatBytes: typeof formatBytes;
+  /** Returns the URL for the pack's logo served by NodeCG (installed packs only). */
+  getLocalLogoUrl: (packId: string) => string;
+}
+
+export const PACK_REGISTRY_KEY: InjectionKey<PackRegistryContext> = Symbol('packRegistry');
+
+const buildAllGameOptions = () =>
+  computed<GameSelectOption[]>(() => {
+    // Registry not loaded yet — return empty list
+    if (!registry.value) return [];
+
+    return registry.value.packs.map((entry) => ({
+      label: entry.name,
+      value: entry.name,
+      available: installedPackIds.value.includes(entry.id),
+      registryEntry: entry,
+      updateInfo: availableUpdates.value[entry.id],
+    }));
+  });
+
+export function usePackRegistry(): PackRegistryContext {
+  initReplicants();
+
+  const allGameOptions = buildAllGameOptions();
+
+  const isGameAvailable = (gameName: string): boolean => {
+    const entry = registry.value?.packs.find((p) => p.name === gameName);
+    if (!entry) return false;
+    return installedPackIds.value.includes(entry.id);
+  };
+
+  const getDownloadState = (packId: string): PackDownloadState =>
+    downloadStates.value[packId] ?? { status: 'idle', progress: 0 };
+
+  const getLocalLogoUrl = (packId: string): string =>
+    `/packs/${packId}/logo.png`;
+
+  const fetchRegistry = (): void => {
+    nodecg.sendMessage('fetchPackRegistry', undefined, (err) => {
+      if (err) console.error('[usePackRegistry] fetchPackRegistry failed:', err);
+    });
+  };
+
+  const downloadPack = (packId: string): void => {
+    nodecg.sendMessage('downloadPack', packId, (err) => {
+      if (err) console.error(`[usePackRegistry] downloadPack "${packId}" failed:`, err);
+    });
+  };
+
+  const uninstallPack = (packId: string): void => {
+    nodecg.sendMessage('uninstallPack', packId, (err) => {
+      if (err) console.error(`[usePackRegistry] uninstallPack "${packId}" failed:`, err);
+    });
+  };
+
+  const updatePack = (packId: string): void => {
+    nodecg.sendMessage('updatePack', packId, (err) => {
+      if (err) console.error(`[usePackRegistry] updatePack "${packId}" failed:`, err);
+    });
+  };
+
+  const updateCount = computed(() => Object.keys(availableUpdates.value).length);
+
+  return {
+    registry,
+    installedPackIds,
+    downloadStates,
+    isGameAvailable,
+    getDownloadState,
+    allGameOptions,
+    fetchRegistry,
+    downloadPack,
+    uninstallPack,
+    updatePack,
+    availableUpdates,
+    updateCount,
+    formatBytes,
+    getLocalLogoUrl,
+  };
+}

src/dashboard/scoreko-dev/i18n.ts

@@ -24,6 +24,14 @@ type Translations = {
   settingsShortcutRightDecrementHint: string;
   settingsShortcutReset: string;
   settingsShortcutRecordingHint: string;
+  settingsShortcutConflictWarning: string;
+  settingsShortcutStartRecording: string;
+  settingsShortcutStopRecording: string;
+  settingsShortcutResetSingle: string;
+  settingsIntegrationsTitle: string;
+  settingsIntegrationsDescription: string;
+  settingsDisconnect: string;
+  settingsNotConnected: string;
   languageEnglish: string;
   languageSpanish: string;
   scoreboardUnassigned: string;
@@ -53,6 +61,8 @@ type Translations = {
   aboutElectronNote: string;
   aboutUnknownReleaseError: string;
   aboutGitHubStatusError: string;
+  aboutChangelog: string;
+  aboutTechStackTitle: string;
   graphicsTitle: string;
   graphicsDescription: string;
   graphicsNoConfigured: string;
@@ -61,10 +71,16 @@ type Translations = {
   graphicsScoreboard: string;
   graphicsCommentary: string;
   graphicsSkinLabel: string;
+  graphicsCopied: string;
+  graphicsOpenBrowser: string;
   commentaryTitle: string;
   commentaryCommentator1: string;
   commentaryCommentator2: string;
   commentaryTwitterText: string;
+  commentaryTwitterMaxLength: string;
+  commentaryTwitterInvalidChars: string;
+  commentarySwap: string;
+  commentaryClear: string;
   bracketTitle: string;
   bracketStage: string;
   bracketSide: string;
@@ -85,18 +101,8 @@ type Translations = {
   playersSearchPlaceholder: string;
   playersImport: string;
   playersExport: string;
-  commentaryTwitterMaxLength: string;
+  playersConnectInSettings: string;
-  commentaryTwitterInvalidChars: string;
+  playersConnectInSettingsSuffix: string;
-  commentarySwap: string;
-  commentaryClear: string;
-  aboutChangelog : string;
-  aboutTechStackTitle : string;
-  settingsShortcutConflictWarning : string;
-  settingsShortcutStartRecording: string;
-  settingsShortcutStopRecording: string;
-  settingsShortcutResetSingle: string;
-  graphicsCopied : string;
-  graphicsOpenBrowser : string;
 };
 
 const STORAGE_KEY = 'scoreko-dev.language';
@@ -108,28 +114,42 @@ const messages: Record<Locale, Translations> = {
     menuGraphics: 'Graphics',
     menuSettings: 'Settings',
     menuAbout: 'About',
+
+    // ── Settings ────────────────────────────────────────────────────────────
     settingsTitle: 'Settings',
-    settingsDescription: 'Dashboard and bundle configuration.',
+    settingsDescription: 'Dashboard and bundle settings.',
     settingsLanguageLabel: 'Language',
     settingsLanguageHint: 'Choose the dashboard language.',
     settingsShortcutTitle: 'Keyboard shortcuts',
-    settingsShortcutDescription: 'Configure quick keys to update the score for each side.',
+    settingsShortcutDescription: 'Configure keyboard shortcuts to update each side’s score.',
     settingsShortcutLeftIncrementLabel: 'P1 score +1',
-    settingsShortcutLeftIncrementHint: 'Increases left player score by one.',
+    settingsShortcutLeftIncrementHint: 'Increases the left player’s score by one.',
     settingsShortcutLeftDecrementLabel: 'P1 score -1',
-    settingsShortcutLeftDecrementHint: 'Decreases left player score by one.',
+    settingsShortcutLeftDecrementHint: 'Decreases the left player’s score by one.',
     settingsShortcutRightIncrementLabel: 'P2 score +1',
-    settingsShortcutRightIncrementHint: 'Increases right player score by one.',
+    settingsShortcutRightIncrementHint: 'Increases the right player’s score by one.',
     settingsShortcutRightDecrementLabel: 'P2 score -1',
-    settingsShortcutRightDecrementHint: 'Decreases right player score by one.',
+    settingsShortcutRightDecrementHint: 'Decreases the right player’s score by one.',
     settingsShortcutReset: 'Reset shortcuts',
-    settingsShortcutRecordingHint: 'Press the desired shortcut now (example: Alt+1).',
+    settingsShortcutRecordingHint: 'Press the desired shortcut now (for example: Alt+1).',
+    settingsShortcutConflictWarning: 'This shortcut is already assigned to another action.',
+    settingsShortcutStartRecording: 'Start recording shortcut',
+    settingsShortcutStopRecording: 'Stop recording shortcut',
+    settingsShortcutResetSingle: 'Reset this shortcut',
+    settingsIntegrationsTitle: 'Integrations',
+    settingsIntegrationsDescription: 'Connect your tournament platform accounts to import players directly from brackets.',
+    settingsDisconnect: 'Disconnect',
+    settingsNotConnected: 'Not connected',
+
+    // ── Language ─────────────────────────────────────────────────────────────
     languageEnglish: 'English',
     languageSpanish: 'Spanish',
+
+    // ── Scoreboard ───────────────────────────────────────────────────────────
     scoreboardUnassigned: '(Unassigned)',
     scoreboardLeft: 'Left',
     scoreboardRight: 'Right',
-    scoreboardPreview: 'preview',
+    scoreboardPreview: 'Preview',
     scoreboardLeftImage: 'Left image',
     scoreboardRightImage: 'Right image',
     scoreboardLabelCharacter: 'Character',
@@ -137,11 +157,13 @@ const messages: Record<Locale, Translations> = {
     scoreboardLabelTeam: 'Team',
     scoreboardLabelCountry: 'Country',
     scoreboardLabelGame: 'Game',
+
+    // ── About ────────────────────────────────────────────────────────────────
     aboutTitle: 'About',
     aboutVersion: 'Version',
-    aboutDescription: 'Dashboard for producing fighting game overlays using NodeCG, Vue, and Quasar.',
+    aboutDescription: 'Dashboard for producing fighting game overlays with NodeCG, Vue, and Quasar.',
-    aboutFrameworkNodeCG: 'Framework NodeCG',
+    aboutFrameworkNodeCG: 'NodeCG framework',
-    aboutCollaboratorsTitle: 'Collaborators and acknowledgments',
+    aboutCollaboratorsTitle: 'Contributors and acknowledgments',
     aboutUpdateSystemTitle: 'Update system (GitHub Releases)',
     aboutUpdateSystemDescription: 'This check fetches the latest release from the repository and compares it with the current version.',
     aboutCheckUpdates: 'Check for updates',
@@ -150,33 +172,49 @@ const messages: Record<Locale, Translations> = {
     aboutUpdateAvailable: 'A newer version is available.',
     aboutUpToDate: 'Your version is up to date with the latest release.',
     aboutViewRelease: 'View release',
-    aboutElectronNote: 'Note for Electron: this panel only implements detection and notification. For real automatic desktop updates, you need to integrate autoUpdater into Electron\'s main process and publish signed artifacts per platform.',
+    aboutElectronNote: 'Note for Electron: this panel only implements detection and notification. For real automatic desktop updates, you need to integrate autoUpdater into Electron’s main process and publish signed artifacts per platform.',
     aboutUnknownReleaseError: 'Unknown error while checking releases.',
     aboutGitHubStatusError: 'GitHub responded with status',
+    aboutChangelog: 'Changelog',
+    aboutTechStackTitle: 'Tech stack',
+
+    // ── Graphics ─────────────────────────────────────────────────────────────
     graphicsTitle: 'Graphics',
-    graphicsDescription: 'Bundle graphics controls and status.',
+    graphicsDescription: 'Controls and status for bundle graphics.',
     graphicsNoConfigured: 'There are no graphics configured in this bundle.',
     graphicsCopyUrl: 'Copy URL',
     graphicsDragObs: 'Drag into OBS',
     graphicsScoreboard: 'Scoreboard',
-    graphicsCommentary: 'Commentary',
+    graphicsCommentary: 'Commentators',
-    graphicsSkinLabel: 'Skin',
+    graphicsSkinLabel: 'Theme',
-    commentaryTitle: 'Commentary',
+    graphicsCopied: 'URL copied to clipboard',
+    graphicsOpenBrowser: 'Open in browser',
+
+    // ── Commentary ───────────────────────────────────────────────────────────
+    commentaryTitle: 'Commentators',
     commentaryCommentator1: 'Commentator #1',
     commentaryCommentator2: 'Commentator #2',
-    commentaryTwitterText: '@Twitter / Text',
+    commentaryTwitterText: 'Twitter / Text',
+    commentaryTwitterMaxLength: 'Twitter character limit exceeded',
+    commentaryTwitterInvalidChars: 'Invalid characters in Twitter text',
+    commentarySwap: 'Swap commentators',
+    commentaryClear: 'Clear commentators',
+
+    // ── Bracket ──────────────────────────────────────────────────────────────
     bracketTitle: 'Bracket',
     bracketStage: 'Stage',
     bracketSide: 'Bracket side',
     bracketCustomProgress: 'Custom progress',
     bracketPreview: 'Preview',
+
+    // ── Players ──────────────────────────────────────────────────────────────
     playersLabelTeam: 'Team',
     playersLabelCountry: 'Country',
     playersLabelActions: 'Actions',
-    playersStartggHelp: 'Connect via OAuth (recommended) or paste your personal token to load tournaments you created or administrate. If you see "Client authentication failed", verify your config uses the Client ID/Secret from a start.gg OAuth App.',
+    playersStartggHelp: 'Connect via OAuth (recommended) or paste your personal token to load tournaments you created or manage.',
     playersConnectStartgg: 'Connect with start.gg',
     playersConnected: 'Connected',
-    playersUsePersonalApi: 'Use personal API',
+    playersUsePersonalApi: 'Use personal token',
     playersTournament: 'Tournament',
     playersImportPlayers: 'Import players',
     playersChallongeHelp: 'Connect with OAuth or paste your personal token to load your Challonge tournaments and import participants.',
@@ -185,43 +223,48 @@ const messages: Record<Locale, Translations> = {
     playersSearchPlaceholder: 'Search...',
     playersImport: 'Import',
     playersExport: 'Export',
-    commentaryTwitterMaxLength: 'Twitter character limit exceeded',
+    playersConnectInSettings: 'Connect your account in',
-    commentaryTwitterInvalidChars: 'Invalid characters in Twitter text',
+    playersConnectInSettingsSuffix: 'to import players from tournaments.',
-    commentarySwap: 'Swap commentators',
-    commentaryClear: 'Clear commentary',
-    aboutChangelog: 'Changelog',
-    aboutTechStackTitle: 'Tech stack',
-    settingsShortcutConflictWarning: 'This shortcut is already assigned to',
-    settingsShortcutStartRecording: 'Start recording shortcut',
-    settingsShortcutStopRecording: 'Stop recording shortcut',
-    settingsShortcutResetSingle: 'Reset single player score shortcut',
-    graphicsCopied: 'URL copied to clipboard',
-    graphicsOpenBrowser: 'Open in browser',
   },
+
   es: {
     menuDashboard: 'Panel',
     menuPlayers: 'Jugadores',
     menuGraphics: 'Gráficos',
     menuSettings: 'Configuración',
     menuAbout: 'Acerca de',
+
+    // ── Settings ────────────────────────────────────────────────────────────
     settingsTitle: 'Configuración',
-    settingsDescription: 'Configuración del dashboard y del bundle.',
+    settingsDescription: 'Configuración del panel y del bundle.',
     settingsLanguageLabel: 'Idioma',
     settingsLanguageHint: 'Selecciona el idioma del dashboard.',
     settingsShortcutTitle: 'Atajos de teclado',
-    settingsShortcutDescription: 'Configura teclas rápidas para actualizar el score de cada lado.',
+    settingsShortcutDescription: 'Configura atajos para actualizar el marcador de cada lado.',
-    settingsShortcutLeftIncrementLabel: 'Score P1 +1',
+    settingsShortcutLeftIncrementLabel: 'Marcador P1 +1',
-    settingsShortcutLeftIncrementHint: 'Incrementa en uno el score del jugador izquierdo.',
+    settingsShortcutLeftIncrementHint: 'Incrementa en uno el marcador del jugador izquierdo.',
-    settingsShortcutLeftDecrementLabel: 'Score P1 -1',
+    settingsShortcutLeftDecrementLabel: 'Marcador P1 -1',
-    settingsShortcutLeftDecrementHint: 'Reduce en uno el score del jugador izquierdo.',
+    settingsShortcutLeftDecrementHint: 'Reduce en uno el marcador del jugador izquierdo.',
-    settingsShortcutRightIncrementLabel: 'Score P2 +1',
+    settingsShortcutRightIncrementLabel: 'Marcador P2 +1',
-    settingsShortcutRightIncrementHint: 'Incrementa en uno el score del jugador derecho.',
+    settingsShortcutRightIncrementHint: 'Incrementa en uno el marcador del jugador derecho.',
-    settingsShortcutRightDecrementLabel: 'Score P2 -1',
+    settingsShortcutRightDecrementLabel: 'Marcador P2 -1',
-    settingsShortcutRightDecrementHint: 'Reduce en uno el score del jugador derecho.',
+    settingsShortcutRightDecrementHint: 'Reduce en uno el marcador del jugador derecho.',
     settingsShortcutReset: 'Restablecer atajos',
     settingsShortcutRecordingHint: 'Pulsa ahora el atajo deseado (ejemplo: Alt+1).',
+    settingsShortcutConflictWarning: 'Este atajo ya está asignado a otra acción.',
+    settingsShortcutStartRecording: 'Iniciar grabación de atajo',
+    settingsShortcutStopRecording: 'Detener grabación de atajo',
+    settingsShortcutResetSingle: 'Restablecer este atajo',
+    settingsIntegrationsTitle: 'Integraciones',
+    settingsIntegrationsDescription: 'Conecta tus cuentas de plataformas de torneos para importar jugadores directamente desde los brackets.',
+    settingsDisconnect: 'Desconectar',
+    settingsNotConnected: 'No conectado',
+
+    // ── Language ─────────────────────────────────────────────────────────────
     languageEnglish: 'Inglés',
-    languageSpanish: 'Castellano',
+    languageSpanish: 'Español',
+
+    // ── Scoreboard ───────────────────────────────────────────────────────────
     scoreboardUnassigned: '(Sin asignar)',
     scoreboardLeft: 'Izquierda',
     scoreboardRight: 'Derecha',
@@ -233,43 +276,61 @@ const messages: Record<Locale, Translations> = {
     scoreboardLabelTeam: 'Equipo',
     scoreboardLabelCountry: 'País',
     scoreboardLabelGame: 'Juego',
+
+    // ── About ────────────────────────────────────────────────────────────────
     aboutTitle: 'Acerca de',
     aboutVersion: 'Versión',
-    aboutDescription: 'Dashboard para producir overlays de juegos de lucha usando NodeCG, Vue y Quasar.',
+    aboutDescription: 'Panel para producir overlays de juegos de lucha usando NodeCG, Vue y Quasar.',
     aboutFrameworkNodeCG: 'Framework NodeCG',
     aboutCollaboratorsTitle: 'Colaboradores y agradecimientos',
     aboutUpdateSystemTitle: 'Sistema de actualizaciones (GitHub Releases)',
-    aboutUpdateSystemDescription: 'Esta comprobación obtiene la última release del repositorio y la compara con la versión actual.',
+    aboutUpdateSystemDescription: 'Esta comprobación obtiene la última versión publicada del repositorio y la compara con la versión actual.',
     aboutCheckUpdates: 'Buscar actualizaciones',
-    aboutLatestRelease: 'Última release',
+    aboutLatestRelease: 'Última versión',
     aboutPublished: 'Publicado',
     aboutUpdateAvailable: 'Hay una versión más nueva disponible.',
-    aboutUpToDate: 'Tu versión está actualizada con la última release.',
+    aboutUpToDate: 'Tu versión está actualizada con la última versión.',
-    aboutViewRelease: 'Ver release',
+    aboutViewRelease: 'Ver versión',
     aboutElectronNote: 'Nota para Electron: este panel solo implementa detección y notificación. Para actualizaciones automáticas reales de escritorio, debes integrar autoUpdater en el proceso principal de Electron y publicar artefactos firmados por plataforma.',
     aboutUnknownReleaseError: 'Error desconocido al consultar releases.',
     aboutGitHubStatusError: 'GitHub respondió con estado',
+    aboutChangelog: 'Registro de cambios',
+    aboutTechStackTitle: 'Stack tecnológico',
+
+    // ── Graphics ─────────────────────────────────────────────────────────────
     graphicsTitle: 'Gráficos',
     graphicsDescription: 'Controles y estado de los gráficos del bundle.',
     graphicsNoConfigured: 'No hay gráficos configurados en este bundle.',
     graphicsCopyUrl: 'Copiar URL',
     graphicsDragObs: 'Arrastrar a OBS',
-    graphicsScoreboard: 'Scoreboard',
+    graphicsScoreboard: 'Marcador',
-    graphicsCommentary: 'Comentario',
+    graphicsCommentary: 'Comentaristas',
-    graphicsSkinLabel: 'Skin',
+    graphicsSkinLabel: 'Tema',
-    commentaryTitle: 'Comentario',
+    graphicsCopied: 'URL copiada al portapapeles',
+    graphicsOpenBrowser: 'Abrir en el navegador',
+
+    // ── Commentary ───────────────────────────────────────────────────────────
+    commentaryTitle: 'Comentaristas',
     commentaryCommentator1: 'Comentarista #1',
     commentaryCommentator2: 'Comentarista #2',
     commentaryTwitterText: '@Twitter / Texto',
-    bracketTitle: 'Bracket',
+    commentaryTwitterMaxLength: 'Se excedió el límite de caracteres de Twitter',
+    commentaryTwitterInvalidChars: 'Caracteres inválidos en el texto de Twitter',
+    commentarySwap: 'Intercambiar comentaristas',
+    commentaryClear: 'Limpiar comentaristas',
+
+    // ── Bracket ──────────────────────────────────────────────────────────────
+    bracketTitle: 'Llave',
     bracketStage: 'Etapa',
-    bracketSide: 'Lado del bracket',
+    bracketSide: 'Lado de la llave',
     bracketCustomProgress: 'Progreso personalizado',
     bracketPreview: 'Vista previa',
+
+    // ── Players ──────────────────────────────────────────────────────────────
     playersLabelTeam: 'Equipo',
     playersLabelCountry: 'País',
     playersLabelActions: 'Acciones',
-    playersStartggHelp: 'Conéctate por OAuth (recomendado) o pega tu token personal para cargar torneos que creaste o administras. Si ves "Client authentication failed", revisa que tu configuración use el Client ID/Secret de una app OAuth de start.gg.',
+    playersStartggHelp: 'Conéctate por OAuth (recomendado) o pega tu token personal para cargar torneos que creaste o administras.',
     playersConnectStartgg: 'Conectar con start.gg',
     playersConnected: 'Conectado',
     playersUsePersonalApi: 'Usar API personal',
@@ -281,28 +342,15 @@ const messages: Record<Locale, Translations> = {
     playersSearchPlaceholder: 'Buscar...',
     playersImport: 'Importar',
     playersExport: 'Exportar',
-    commentaryTwitterMaxLength: 'Se excedió el límite de caracteres de Twitter',
+    playersConnectInSettings: 'Conecta tu cuenta en',
-    commentaryTwitterInvalidChars: 'Caracteres inválidos en el texto de Twitter',
+    playersConnectInSettingsSuffix: 'para importar jugadores desde torneos.',
-    commentarySwap: 'Intercambiar comentaristas',
-    commentaryClear: 'Limpiar comentario',
-    aboutChangelog: 'Changelog',
-    aboutTechStackTitle: 'Tech stack',
-    settingsShortcutConflictWarning: 'This shortcut is already assigned to',
-    settingsShortcutStartRecording: 'Start recording shortcut',
-    settingsShortcutStopRecording: 'Stop recording shortcut',
-    settingsShortcutResetSingle: 'Reset single player score shortcut',
-    graphicsCopied: 'URL copiada al portapapeles',
-    graphicsOpenBrowser: 'Abrir en el navegador',
   },
 };
 
 const normalizeLocale = (value: unknown): Locale => (value === 'es' ? 'es' : 'en');
 
 const getStoredLocale = (): Locale => {
-  if (typeof window === 'undefined') {
+  if (typeof window === 'undefined') return 'en';
-    return 'en';
-  }
-
   return normalizeLocale(localStorage.getItem(STORAGE_KEY));
 };
 
@@ -310,7 +358,6 @@ export const locale = ref<Locale>(getStoredLocale());
 
 export const setLocale = (value: Locale) => {
   locale.value = normalizeLocale(value);
-
   if (typeof window !== 'undefined') {
     localStorage.setItem(STORAGE_KEY, locale.value);
   }

src/dashboard/scoreko-dev/main.vue

@@ -1,67 +1,87 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted } from 'vue';
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
 import { t } from './i18n';
 import { useScoreboardStore } from './stores/scoreboard';
 import { isShortcutMatch, useShortcutSettingsStore } from './stores/shortcut-settings';
 
-const menuItems = computed(() => [
+// ── Sidebar collapse ──────────────────────────────────────────────────────────
-  { label: t('menuDashboard'), to: '/', icon: 'dashboard' },
+const LS_KEY = 'sidebar_collapsed';
-  { label: t('menuPlayers'), to: '/players', icon: 'groups' },
+const isCollapsed = ref(localStorage.getItem(LS_KEY) === 'true');
-  { label: t('menuGraphics'), to: '/graphics', icon: 'collections' },
+const drawerWidth = computed(() => (isCollapsed.value ? 60 : 220));
+watch(isCollapsed, (val) => localStorage.setItem(LS_KEY, String(val)));
+const toggleCollapse = () => { isCollapsed.value = !isCollapsed.value; };
+
+// ── Version ───────────────────────────────────────────────────────────────────
+const appVersion = import.meta.env.PACKAGE_VERSION as string | undefined;
+
+// ── Logo ──────────────────────────────────────────────────────────────────────
+const logoUrl = new URL('./image.png', import.meta.url).href;
+
+// ── Menu groups ───────────────────────────────────────────────────────────────
+const mainItems = computed(() => [
+  { label: t('menuDashboard'), to: '/',         icon: 'dashboard'   },
+  { label: t('menuPlayers'),   to: '/players',  icon: 'groups'      },
+  { label: t('menuGraphics'),  to: '/graphics', icon: 'collections' },
+]);
+const configItems = computed(() => [
   { label: t('menuSettings'), to: '/settings', icon: 'settings' },
-  { label: t('menuAbout'), to: '/about', icon: 'info' },
+  { label: t('menuAbout'),    to: '/about',    icon: 'info'     },
 ]);
 
-const logoUrl = new URL('./image.png', import.meta.url).href;
+// ── Online / Offline ──────────────────────────────────────────────────────────
-const scoreboardStore = useScoreboardStore();
+const isOnline = ref(navigator.onLine);
+
+const checkOnline = async () => {
+  try {
+    await fetch('https://www.google.com/favicon.ico', {
+      method: 'HEAD',
+      mode: 'no-cors',
+      cache: 'no-store',
+    });
+    isOnline.value = true;
+  } catch {
+    isOnline.value = false;
+  }
+};
+
+const onNetworkOnline  = () => { isOnline.value = true;  };
+const onNetworkOffline = () => { isOnline.value = false; };
+let pingInterval: ReturnType<typeof setInterval> | null = null;
+
+// ── Keyboard shortcuts ────────────────────────────────────────────────────────
+const scoreboardStore       = useScoreboardStore();
 const shortcutSettingsStore = useShortcutSettingsStore();
 
 const isEditableTarget = (target: EventTarget | null): boolean => {
-  if (!(target instanceof HTMLElement)) {
+  if (!(target instanceof HTMLElement)) return false;
-    return false;
+  return (
-  }
+    target.isContentEditable ||
-
+    ['INPUT', 'TEXTAREA', 'SELECT'].includes(target.tagName) ||
-  return target.isContentEditable
+    Boolean(target.closest('[contenteditable="true"]'))
-    || ['INPUT', 'TEXTAREA', 'SELECT'].includes(target.tagName)
+  );
-    || Boolean(target.closest('[contenteditable="true"]'));
 };
 
 const onShortcutPress = (event: KeyboardEvent) => {
-  if (isEditableTarget(event.target) || document.body.dataset.shortcutRecording === 'true') {
+  if (isEditableTarget(event.target) || document.body.dataset.shortcutRecording === 'true') return;
-    return;
-  }
-
   const { shortcuts } = shortcutSettingsStore;
-  if (isShortcutMatch(event, shortcuts.leftIncrement)) {
+  if (isShortcutMatch(event, shortcuts.leftIncrement))  { scoreboardStore.leftScore += 1; event.preventDefault(); return; }
-    scoreboardStore.leftScore += 1;
+  if (isShortcutMatch(event, shortcuts.leftDecrement))  { scoreboardStore.leftScore = Math.max(0, scoreboardStore.leftScore - 1); event.preventDefault(); return; }
-    event.preventDefault();
+  if (isShortcutMatch(event, shortcuts.rightIncrement)) { scoreboardStore.rightScore += 1; event.preventDefault(); return; }
-    return;
+  if (isShortcutMatch(event, shortcuts.rightDecrement)) { scoreboardStore.rightScore = Math.max(0, scoreboardStore.rightScore - 1); event.preventDefault(); }
-  }
-
-  if (isShortcutMatch(event, shortcuts.leftDecrement)) {
-    scoreboardStore.leftScore = Math.max(0, scoreboardStore.leftScore - 1);
-    event.preventDefault();
-    return;
-  }
-
-  if (isShortcutMatch(event, shortcuts.rightIncrement)) {
-    scoreboardStore.rightScore += 1;
-    event.preventDefault();
-    return;
-  }
-
-  if (isShortcutMatch(event, shortcuts.rightDecrement)) {
-    scoreboardStore.rightScore = Math.max(0, scoreboardStore.rightScore - 1);
-    event.preventDefault();
-  }
 };
 
 onMounted(() => {
   window.addEventListener('keydown', onShortcutPress);
+  window.addEventListener('online',  onNetworkOnline);
+  window.addEventListener('offline', onNetworkOffline);
+  pingInterval = setInterval(checkOnline, 15_000);
 });
 
 onUnmounted(() => {
   window.removeEventListener('keydown', onShortcutPress);
+  window.removeEventListener('online',  onNetworkOnline);
+  window.removeEventListener('offline', onNetworkOffline);
+  if (pingInterval) clearInterval(pingInterval);
 });
 </script>
 
@@ -71,49 +91,117 @@ onUnmounted(() => {
       show-if-above
       side="left"
       bordered
-      :width="220"
+      :width="drawerWidth"
       class="sidebar-drawer"
     >
-      <div class="sidebar-header q-pa-md">
+      <!-- ── Header ─────────────────────────────────────────── -->
-        <div class="row items-center no-wrap">
+      <div class="sidebar-header" :class="{ 'is-collapsed': isCollapsed }">
-          <img
+        <img :src="logoUrl" alt="Logo" class="sidebar-logo">
-            :src="logoUrl"
+
-            alt="Logo"
+        <Transition name="slide-fade">
-            class="sidebar-logo"
+          <div v-if="!isCollapsed" class="sidebar-title">
-          >
+            <span class="title-text">Scoreko-dev</span>
-          <div class="q-ml-sm">
+            <span v-if="appVersion" class="title-version">v{{ appVersion }}</span>
-            <div class="text-subtitle1 text-weight-bold">
-              Scoreko-dev
-            </div>
-            <div class="text-caption">
-              <span class="by-label">by</span> <a
-                class="by-link"
-                href="https://github.com/Pandipipas"
-                target="_blank"
-                rel="noopener"
-              >Pandipipas</a>
-            </div>
           </div>
-        </div>
+        </Transition>
+
+        <!-- Chevron — siempre visible, arriba a la derecha -->
+        <QBtn
+          flat
+          round
+          dense
+          size="sm"
+          :icon="isCollapsed ? 'chevron_right' : 'chevron_left'"
+          class="collapse-btn"
+          @click="toggleCollapse"
+        />
       </div>
-      <QSeparator class="q-mb-sm" />
+
-      <QList>
+      <QSeparator />
+
+      <!-- ── Sección MAIN ───────────────────────────────────── -->
+      <div class="section-sep" :class="{ 'is-collapsed': isCollapsed }">
+        <span v-if="!isCollapsed" class="section-label">MAIN</span>
+      </div>
+
+      <QList padding>
         <QItem
-          v-for="item in menuItems"
+          v-for="item in mainItems"
           :key="item.to"
           clickable
           :to="item.to"
           exact
           active-class="sidebar-item-active"
+          :class="{ 'nav-item-collapsed': isCollapsed }"
         >
           <QItemSection avatar>
-            <QIcon :name="item.icon" />
+            <QIcon :name="item.icon" size="sm" />
           </QItemSection>
-          <QItemSection>
+          <QItemSection v-if="!isCollapsed">
             <QItemLabel>{{ item.label }}</QItemLabel>
           </QItemSection>
+          <QTooltip
+            v-if="isCollapsed"
+            anchor="center right"
+            self="center left"
+            :offset="[10, 0]"
+          >
+            {{ item.label }}
+          </QTooltip>
         </QItem>
       </QList>
+
+      <!-- ── Sección CONFIG ─────────────────────────────────── -->
+      <div class="section-sep" :class="{ 'is-collapsed': isCollapsed }">
+        <span v-if="!isCollapsed" class="section-label">CONFIG</span>
+      </div>
+
+      <QList padding>
+        <QItem
+          v-for="item in configItems"
+          :key="item.to"
+          clickable
+          :to="item.to"
+          exact
+          active-class="sidebar-item-active"
+          :class="{ 'nav-item-collapsed': isCollapsed }"
+        >
+          <QItemSection avatar>
+            <QIcon :name="item.icon" size="sm" />
+          </QItemSection>
+          <QItemSection v-if="!isCollapsed">
+            <QItemLabel>{{ item.label }}</QItemLabel>
+          </QItemSection>
+          <QTooltip
+            v-if="isCollapsed"
+            anchor="center right"
+            self="center left"
+            :offset="[10, 0]"
+          >
+            {{ item.label }}
+          </QTooltip>
+        </QItem>
+      </QList>
+
+      <!-- ── Footer: Online / Offline ──────────────────────── -->
+      <div class="sidebar-footer" :class="{ 'is-collapsed': isCollapsed }">
+        <div class="online-row">
+          <span class="online-dot" :class="isOnline ? 'dot-online' : 'dot-offline'" />
+          <Transition name="slide-fade">
+            <span v-if="!isCollapsed" class="online-label">
+              {{ isOnline ? 'Online' : 'Offline' }}
+            </span>
+          </Transition>
+          <QTooltip
+            v-if="isCollapsed"
+            anchor="center right"
+            self="center left"
+            :offset="[10, 0]"
+          >
+            {{ isOnline ? 'Online' : 'Offline' }}
+          </QTooltip>
+        </div>
+      </div>
     </QDrawer>
 
     <QPageContainer>
@@ -123,28 +211,176 @@ onUnmounted(() => {
 </template>
 
 <style scoped>
+/* ── Drawer shell ─────────────────────────────────────────────────────────── */
+.sidebar-drawer :deep(.q-drawer__content) {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  overflow: hidden;
+}
+
+/* ── Header ───────────────────────────────────────────────────────────────── */
 .sidebar-header {
-  min-height: 72px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 14px 12px 14px 14px;
+  min-height: 64px;
+  position: relative;
+  flex-shrink: 0;
+  transition: padding 0.25s ease;
+}
+.sidebar-header.is-collapsed {
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 10px 4px;
 }
 
 .sidebar-logo {
-  width: 40px;
+  width: 36px;
-  height: 40px;
+  height: 36px;
   object-fit: contain;
+  flex-shrink: 0;
 }
 
-.by-label {
+.sidebar-title {
-  font-size: 0.75rem;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  flex: 1;
+}
+.title-text {
+  font-size: 0.875rem;
+  font-weight: 700;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.title-version {
+  font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+  font-size: 0.65rem;
+  letter-spacing: 0.05em;
+  opacity: 0.45;
+  margin-top: 1px;
 }
 
-.by-link {
+/* ── Collapse button ──────────────────────────────────────────────────────── */
-  font-size: 0.75rem;
+.collapse-btn {
-  color: #f50a64;
+  flex-shrink: 0;
-  text-decoration: none;
+  opacity: 0.4;
+  transition: opacity 0.2s ease, transform 0.25s ease;
+}
+.collapse-btn:hover {
+  opacity: 1;
+}
+/* en modo expandido queda al extremo derecho */
+.sidebar-header:not(.is-collapsed) .collapse-btn {
+  margin-left: auto;
 }
 
-.by-link:hover {
+/* ── Section separators ───────────────────────────────────────────────────── */
-  text-decoration: underline;
+.section-sep {
+  display: flex;
+  align-items: center;
+  padding: 10px 14px 2px;
+  min-height: 28px;
+  transition: padding 0.2s ease, min-height 0.2s ease;
+}
+.section-sep.is-collapsed {
+  padding: 6px 12px 2px;
+  min-height: 0;
+}
+.section-sep.is-collapsed::after {
+  content: '';
+  display: block;
+  width: 100%;
+  height: 1px;
+  background: currentColor;
+  opacity: 0.12;
 }
 
+.section-label {
+  font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+  opacity: 0.38;
+}
+
+/* ── Nav items (collapsed centrado) ──────────────────────────────────────── */
+.nav-item-collapsed {
+  justify-content: center;
+  padding-left: 0;
+  padding-right: 0;
+}
+.nav-item-collapsed :deep(.q-item__section--avatar) {
+  min-width: unset;
+  padding-right: 0;
+}
+
+/* ── Footer ───────────────────────────────────────────────────────────────── */
+.sidebar-footer {
+  margin-top: auto;
+  padding: 10px 14px;
+  border-top: 1px solid rgba(128, 128, 128, 0.15);
+  flex-shrink: 0;
+  transition: padding 0.25s ease;
+}
+.sidebar-footer.is-collapsed {
+  padding: 10px 0;
+  display: flex;
+  justify-content: center;
+}
+
+.online-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  position: relative;
+}
+
+/* ── Online dot ───────────────────────────────────────────────────────────── */
+.online-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  display: inline-block;
+}
+.dot-online {
+  background: #22c55e;
+  animation: pulse-green 2s ease-in-out infinite;
+}
+.dot-offline {
+  background: #ef4444;
+}
+
+.online-label {
+  font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+  font-size: 0.7rem;
+  letter-spacing: 0.04em;
+  opacity: 0.6;
+  white-space: nowrap;
+}
+
+/* ── Transitions ──────────────────────────────────────────────────────────── */
+.slide-fade-enter-active,
+.slide-fade-leave-active {
+  transition: opacity 0.2s ease, transform 0.2s ease;
+}
+.slide-fade-enter-from,
+.slide-fade-leave-to {
+  opacity: 0;
+  transform: translateX(-6px);
+}
+
+/* ── Pulse animation ──────────────────────────────────────────────────────── */
+@keyframes pulse-green {
+  0%   { box-shadow: 0 0 0 0   rgba(34, 197, 94, 0.55); }
+  70%  { box-shadow: 0 0 0 6px rgba(34, 197, 94, 0);    }
+  100% { box-shadow: 0 0 0 0   rgba(34, 197, 94, 0);    }
+}
 </style>

src/dashboard/scoreko-dev/views/Settings.vue

@@ -1,8 +1,11 @@
 <script setup lang="ts">
 import { useHead } from '@unhead/vue';
-import { computed, onBeforeUnmount, ref } from 'vue';
+import { useQuasar } from 'quasar';
+import { computed, onBeforeUnmount, ref, watch } from 'vue';
+import { useIntegration } from '../composables/useIntegration';
 import type { Locale } from '../i18n';
 import { locale, setLocale, t } from '../i18n';
+import { usePlayersStore } from '../stores/players';
 import {
   eventToShortcut,
   type ShortcutAction,
@@ -13,6 +16,8 @@ defineOptions({ name: 'SettingsView' });
 
 useHead(() => ({ title: t('settingsTitle') }));
 
+// ─── Idioma ────────────────────────────────────────────────────────────────────
+
 const languageOptions = computed(() => [
   { label: t('languageSpanish'), value: 'es' as const },
   { label: t('languageEnglish'), value: 'en' as const },
@@ -20,15 +25,13 @@ const languageOptions = computed(() => [
 
 const selectedLanguage = computed<Locale>({
   get: () => locale.value,
-  set: (value) => {
+  set: (value) => { setLocale(value); },
-    setLocale(value);
-  },
 });
 
+// ─── Atajos de teclado ─────────────────────────────────────────────────────────
+
 const shortcutSettingsStore = useShortcutSettingsStore();
 const recordingAction = ref<ShortcutAction | null>(null);
-
-// Ref para detectar clicks fuera del contenedor de atajos
 const shortcutsContainerRef = ref<HTMLElement | null>(null);
 
 const shortcutFields = computed<{ action: ShortcutAction; label: string; hint: string }[]>(() => [
@@ -38,7 +41,6 @@ const shortcutFields = computed<{ action: ShortcutAction; label: string; hint: s
   { action: 'rightDecrement', label: t('settingsShortcutRightDecrementLabel'), hint: t('settingsShortcutRightDecrementHint') },
 ]);
 
-// Detecta atajos duplicados entre acciones
 const conflictingActions = computed(() => {
   const seen = new Map<string, ShortcutAction>();
   const conflicts = new Set<ShortcutAction>();
@@ -62,43 +64,24 @@ const stopRecording = () => {
 
 const onRecordKeydown = (event: KeyboardEvent) => {
   if (!recordingAction.value) return;
-
+  if (event.key === 'Escape') { event.preventDefault(); stopRecording(); return; }
-  // Escape cancela la grabación sin asignar ningún atajo
-  if (event.key === 'Escape') {
-    event.preventDefault();
-    stopRecording();
-    return;
-  }
-
   const shortcut = eventToShortcut(event);
   if (!shortcut) return;
-
   event.preventDefault();
   shortcutSettingsStore.setShortcut(recordingAction.value, shortcut);
   stopRecording();
 };
 
-// Click fuera del área de atajos también cancela la grabación
 const onDocumentMousedown = (event: MouseEvent) => {
-  if (
+  if (recordingAction.value && shortcutsContainerRef.value && !shortcutsContainerRef.value.contains(event.target as Node)) {
-    recordingAction.value &&
-    shortcutsContainerRef.value &&
-    !shortcutsContainerRef.value.contains(event.target as Node)
-  ) {
     stopRecording();
   }
 };
 
 const startRecording = (action: ShortcutAction) => {
-  if (recordingAction.value === action) {
+  if (recordingAction.value === action) { stopRecording(); return; }
-    stopRecording();
-    return;
-  }
-
   recordingAction.value = action;
-  if (typeof document !== 'undefined') {
+  if (typeof document !== 'undefined') document.body.dataset.shortcutRecording = 'true';
-    document.body.dataset.shortcutRecording = 'true';
-  }
 };
 
 if (typeof window !== 'undefined') {
@@ -113,6 +96,79 @@ onBeforeUnmount(() => {
   }
   stopRecording();
 });
+
+// ─── Integraciones ─────────────────────────────────────────────────────────────
+
+const STARTGG_TOKEN_STORAGE_KEY = 'scoreko-dev.startgg-token';
+const CHALLONGE_TOKEN_STORAGE_KEY = 'scoreko-dev.challonge-token';
+const STARTGG_TEMP_PLAYERS_STORAGE_KEY = 'scoreko-dev.startgg-temp-players';
+const CHALLONGE_TEMP_PLAYERS_STORAGE_KEY = 'scoreko-dev.challonge-temp-players';
+const TEMP_FALLBACK_DURATION_SECONDS = 12 * 60 * 60;
+
+const playersStore = usePlayersStore();
+const $q = useQuasar();
+
+const startgg = useIntegration({
+  messagePrefix: 'startgg',
+  providerLabel: 'start.gg',
+  tokenStorageKey: STARTGG_TOKEN_STORAGE_KEY,
+  tempPlayersStorageKey: STARTGG_TEMP_PLAYERS_STORAGE_KEY,
+  tempFallbackDurationSeconds: TEMP_FALLBACK_DURATION_SECONDS,
+  playersStore,
+});
+
+const challonge = useIntegration({
+  messagePrefix: 'challonge',
+  providerLabel: 'Challonge',
+  tokenStorageKey: CHALLONGE_TOKEN_STORAGE_KEY,
+  tempPlayersStorageKey: CHALLONGE_TEMP_PLAYERS_STORAGE_KEY,
+  tempFallbackDurationSeconds: TEMP_FALLBACK_DURATION_SECONDS,
+  on401Message:
+    'Challonge rejected the token (401 Unauthorized). Re-connect OAuth so it grants scopes (me, tournaments:read, participants:read) or paste a valid personal API token.',
+  playersStore,
+});
+
+// ─── Diálogos de token manual ──────────────────────────────────────────────────
+
+const isStartggManualDialogOpen = ref(false);
+const startggManualDraft = ref('');
+
+const openStartggManualDialog = () => {
+  startggManualDraft.value = startgg.token;
+  isStartggManualDialogOpen.value = true;
+};
+
+const saveStartggManualToken = () => {
+  startgg.token = startggManualDraft.value.trim();
+  isStartggManualDialogOpen.value = false;
+  $q.notify({ type: 'positive', message: startgg.token ? 'start.gg token saved.' : 'start.gg token removed.' });
+};
+
+const isChallongeManualDialogOpen = ref(false);
+const challongeManualDraft = ref('');
+
+const openChallongeManualDialog = () => {
+  challongeManualDraft.value = challonge.token;
+  isChallongeManualDialogOpen.value = true;
+};
+
+const saveChallongeManualToken = () => {
+  challonge.token = challongeManualDraft.value.trim();
+  isChallongeManualDialogOpen.value = false;
+  $q.notify({ type: 'positive', message: challonge.token ? 'Challonge token saved.' : 'Challonge token removed.' });
+};
+
+// Label de estado de Challonge
+const challongeConnectionLabel = computed(() =>
+  challonge.hasValidatedToken ? t('playersConnected') : 'Token set',
+);
+
+watch(() => startgg.importDialogError, (msg) => {
+  if (msg) $q.notify({ type: 'negative', message: msg });
+});
+watch(() => challonge.importDialogError, (msg) => {
+  if (msg) $q.notify({ type: 'negative', message: msg });
+});
 </script>
 
 <template>
@@ -126,134 +182,324 @@ onBeforeUnmount(() => {
       </div>
     </div>
 
-    <QCard
+    <div class="column q-gutter-lg settings-layout">
-      flat
-      bordered
-      class="settings-card"
-    >
-      <!-- Language -->
-      <QCardSection class="q-pa-lg">
-        <!--
-          Label movido al propio QSelect (más idiomático en Quasar con outlined).
-          Se elimina el text-overline redundante de encima.
-        -->
-        <QSelect
-          v-model="selectedLanguage"
-          emit-value
-          map-options
-          :options="languageOptions"
-          :label="t('settingsLanguageLabel')"
-          outlined
-          dense
-        />
 
-        <div class="text-caption text-grey-6 q-mt-sm">
+      <!-- ── Idioma ──────────────────────────────────────────────────────────── -->
-          {{ t('settingsLanguageHint') }}
+      <QCard flat bordered class="settings-card">
-        </div>
+        <QCardSection class="q-pa-lg">
-      </QCardSection>
+          <div class="text-overline text-grey-6 q-mb-md">{{ t('settingsLanguageLabel') }}</div>
-
+          <QSelect
-      <QSeparator />
+            v-model="selectedLanguage"
-
+            emit-value
-      <!-- Shortcuts -->
+            map-options
-      <QCardSection class="q-pa-lg">
+            :options="languageOptions"
-        <div class="row items-center justify-between q-mb-xs">
+            :label="t('settingsLanguageLabel')"
-          <div class="text-overline text-grey-6">
-            {{ t('settingsShortcutTitle') }}
-          </div>
-          <QBtn
-            round
-            dense
-            flat
-            color="primary"
-            icon="restart_alt"
-            :aria-label="t('settingsShortcutReset')"
-            @click="shortcutSettingsStore.resetShortcuts"
-          >
-            <QTooltip>{{ t('settingsShortcutReset') }}</QTooltip>
-          </QBtn>
-        </div>
-
-        <div class="text-caption text-grey-6 q-mb-lg">
-          {{ t('settingsShortcutDescription') }}
-        </div>
-
-        <!-- Aviso de conflicto: se muestra si dos acciones comparten el mismo atajo -->
-        <QBanner
-          v-if="conflictingActions.size > 0"
-          class="bg-warning text-white q-mb-md"
-          rounded
-          dense
-        >
-          <template #avatar>
-            <QIcon name="warning" color="white" />
-          </template>
-          {{ t('settingsShortcutConflictWarning') }}
-        </QBanner>
-
-        <!--
-          ref="shortcutsContainerRef" permite detectar clicks fuera
-          de esta área para cancelar la grabación automáticamente.
-        -->
-        <div
-          ref="shortcutsContainerRef"
-          class="column q-gutter-md"
-        >
-          <QInput
-            v-for="field in shortcutFields"
-            :key="field.action"
-            :model-value="shortcutSettingsStore.shortcuts[field.action]"
-            :hint="recordingAction === field.action ? t('settingsShortcutRecordingHint') : field.hint"
-            :color="
-              recordingAction === field.action
-                ? 'negative'
-                : conflictingActions.has(field.action)
-                  ? 'warning'
-                  : 'primary'
-            "
-            readonly
             outlined
             dense
-            bottom-slots
+            style="max-width: 280px"
-            :label="field.label"
+          />
-          >
+          <div class="text-caption text-grey-6 q-mt-sm">
-            <template #append>
+            {{ t('settingsLanguageHint') }}
-              <!-- Botón grabar / detener -->
+          </div>
-              <QBtn
+        </QCardSection>
-                flat
+      </QCard>
-                round
-                dense
-                :icon="recordingAction === field.action ? 'stop_circle' : 'keyboard'"
-                :color="recordingAction === field.action ? 'negative' : 'primary'"
-                :aria-label="
-                  recordingAction === field.action
-                    ? t('settingsShortcutStopRecording')
-                    : t('settingsShortcutStartRecording')
-                "
-                @click="startRecording(field.action)"
-              />
 
-              <!-- Botón reset individual por atajo -->
+      <!-- ── Integraciones ───────────────────────────────────────────────────── -->
-              <QBtn
+      <QCard flat bordered class="settings-card">
-                flat
+        <QCardSection class="q-pa-lg">
-                round
+          <div class="text-overline text-grey-6 q-mb-xs">{{ t('settingsIntegrationsTitle') || 'Integrations' }}</div>
-                dense
+          <div class="text-caption text-grey-6 q-mb-lg">
-                icon="restart_alt"
+            {{ t('settingsIntegrationsDescription') || 'Connect your tournament platform accounts to import players directly from brackets.' }}
-                color="grey-5"
+          </div>
-                :aria-label="t('settingsShortcutResetSingle')"
+
-                @click="shortcutSettingsStore.resetShortcut(field.action)"
+          <div class="column q-gutter-md">
-              >
+
-                <QTooltip>{{ t('settingsShortcutResetSingle') }}</QTooltip>
+            <!-- start.gg -->
-              </QBtn>
+            <div class="integration-row">
+              <div class="integration-row__logo">
+                <svg style="width: 28px; height: 28px;" viewBox="0 0 40 40" fill="none" aria-hidden="true">
+                  <path d="M1.25 20h7.5A1.25 1.25 0 0 0 10 18.75v-7.5A1.25 1.25 0 0 1 11.25 10h27.5A1.25 1.25 0 0 0 40 8.75V1.25A1.25 1.25 0 0 0 38.75 0H10A10 10 0 0 0 0 10v8.75A1.25 1.25 0 0 0 1.25 20Z" fill="#3f80ff" />
+                  <path d="M38.75 20h-7.5A1.25 1.25 0 0 0 30 21.25v7.5A1.25 1.25 0 0 1 28.75 30H1.25A1.25 1.25 0 0 0 0 31.25v7.5A1.25 1.25 0 0 0 1.25 40H30A10 10 0 0 0 40 30V21.25A1.25 1.25 0 0 0 38.75 20Z" fill="#ff2768" />
+                </svg>
+              </div>
+              <div class="integration-row__info">
+                <div class="text-body2 text-weight-medium">start.gg</div>
+                <div class="text-caption text-grey-6">{{ t('playersStartggHelp') }}</div>
+              </div>
+              <div class="integration-row__actions row q-gutter-sm items-center">
+                <QChip
+                  v-if="startgg.hasTokenConfigured"
+                  dense
+                  :color="startgg.hasValidatedToken ? 'positive' : 'warning'"
+                  text-color="white"
+                  icon="check_circle"
+                >
+                  {{ t('playersConnected') }}
+                </QChip>
+                <QBtn
+                  v-if="!startgg.hasTokenConfigured"
+                  color="primary"
+                  icon="login"
+                  no-caps
+                  unelevated
+                  :label="t('playersConnectStartgg')"
+                  :loading="startgg.oauthLoading"
+                  @click="startgg.connectWithOAuth"
+                />
+                <QBtn
+                  v-else
+                  flat
+                  color="negative"
+                  icon="link_off"
+                  no-caps
+                  size="sm"
+                  :label="t('settingsDisconnect') || 'Disconnect'"
+                  @click="startggManualDraft = ''; startgg.token = ''; $q.notify({ type: 'info', message: 'start.gg disconnected.' })"
+                />
+                <QBtn
+                  outline
+                  :color="startgg.hasTokenConfigured ? 'grey-5' : 'white'"
+                  icon="vpn_key"
+                  no-caps
+                  size="sm"
+                  :label="t('playersUsePersonalApi')"
+                  @click="openStartggManualDialog"
+                />
+              </div>
+            </div>
+
+            <QSeparator />
+
+            <!-- Challonge -->
+            <div class="integration-row">
+              <div class="integration-row__logo">
+                <img
+                  src="https://challonge.com/favicon.ico"
+                  alt="Challonge"
+                  style="width: 28px; height: 28px; border-radius: 6px;"
+                >
+              </div>
+              <div class="integration-row__info">
+                <div class="text-body2 text-weight-medium">Challonge</div>
+                <div class="text-caption text-grey-6">{{ t('playersChallongeHelp') }}</div>
+              </div>
+              <div class="integration-row__actions row q-gutter-sm items-center">
+                <QChip
+                  v-if="challonge.hasTokenConfigured"
+                  dense
+                  :color="challonge.hasValidatedToken ? 'positive' : 'warning'"
+                  text-color="white"
+                  icon="check_circle"
+                >
+                  {{ challongeConnectionLabel }}
+                </QChip>
+                <QBtn
+                  v-if="!challonge.hasTokenConfigured"
+                  color="primary"
+                  icon="login"
+                  no-caps
+                  unelevated
+                  :label="t('playersConnectChallonge')"
+                  :loading="challonge.oauthLoading"
+                  @click="challonge.connectWithOAuth"
+                />
+                <QBtn
+                  v-else
+                  flat
+                  color="negative"
+                  icon="link_off"
+                  no-caps
+                  size="sm"
+                  :label="t('settingsDisconnect') || 'Disconnect'"
+                  @click="challongeManualDraft = ''; challonge.token = ''; $q.notify({ type: 'info', message: 'Challonge disconnected.' })"
+                />
+                <QBtn
+                  outline
+                  :color="challonge.hasTokenConfigured ? 'grey-5' : 'white'"
+                  icon="vpn_key"
+                  no-caps
+                  size="sm"
+                  :label="t('playersUsePersonalApi')"
+                  @click="openChallongeManualDialog"
+                />
+              </div>
+            </div>
+
+          </div>
+        </QCardSection>
+      </QCard>
+
+      <!-- ── Atajos de teclado ───────────────────────────────────────────────── -->
+      <QCard flat bordered class="settings-card">
+        <QCardSection class="q-pa-lg">
+          <div class="row items-center justify-between q-mb-xs">
+            <div class="text-overline text-grey-6">
+              {{ t('settingsShortcutTitle') }}
+            </div>
+            <QBtn
+              round dense flat color="primary" icon="restart_alt"
+              :aria-label="t('settingsShortcutReset')"
+              @click="shortcutSettingsStore.resetShortcuts"
+            >
+              <QTooltip>{{ t('settingsShortcutReset') }}</QTooltip>
+            </QBtn>
+          </div>
+
+          <div class="text-caption text-grey-6 q-mb-lg">
+            {{ t('settingsShortcutDescription') }}
+          </div>
+
+          <QBanner
+            v-if="conflictingActions.size > 0"
+            class="bg-warning text-white q-mb-md"
+            rounded dense
+          >
+            <template #avatar>
+              <QIcon name="warning" color="white" />
             </template>
-          </QInput>
+            {{ t('settingsShortcutConflictWarning') }}
-        </div>
+          </QBanner>
-      </QCardSection>
+
-    </QCard>
+          <div ref="shortcutsContainerRef" class="column q-gutter-md">
+            <QInput
+              v-for="field in shortcutFields"
+              :key="field.action"
+              :model-value="shortcutSettingsStore.shortcuts[field.action]"
+              :hint="recordingAction === field.action ? t('settingsShortcutRecordingHint') : field.hint"
+              :color="
+                recordingAction === field.action
+                  ? 'negative'
+                  : conflictingActions.has(field.action)
+                    ? 'warning'
+                    : 'primary'
+              "
+              readonly outlined dense bottom-slots
+              :label="field.label"
+            >
+              <template #append>
+                <QBtn
+                  flat round dense
+                  :icon="recordingAction === field.action ? 'stop_circle' : 'keyboard'"
+                  :color="recordingAction === field.action ? 'negative' : 'primary'"
+                  :aria-label="recordingAction === field.action ? t('settingsShortcutStopRecording') : t('settingsShortcutStartRecording')"
+                  @click="startRecording(field.action)"
+                />
+                <QBtn
+                  flat round dense icon="restart_alt" color="grey-5"
+                  :aria-label="t('settingsShortcutResetSingle')"
+                  @click="shortcutSettingsStore.resetShortcut(field.action)"
+                >
+                  <QTooltip>{{ t('settingsShortcutResetSingle') }}</QTooltip>
+                </QBtn>
+              </template>
+            </QInput>
+          </div>
+        </QCardSection>
+      </QCard>
+
+    </div>
+
+    <!-- ── Diálogo token personal start.gg ──────────────────────────────────── -->
+    <QDialog v-model="isStartggManualDialogOpen">
+      <QCard class="settings-dialog">
+        <QCardSection>
+          <div class="text-h6">Personal start.gg API token</div>
+        </QCardSection>
+        <QSeparator />
+        <QCardSection>
+          <div class="text-body2 q-mb-sm">
+            If OAuth fails, you can create a personal token manually:
+          </div>
+          <ol class="q-pl-md q-mb-md settings-token-steps">
+            <li>Go to https://start.gg/admin/profile/developer</li>
+            <li>Sign in with your account</li>
+            <li>From the 3 access tokens, click <strong>Third Party</strong></li>
+            <li>Create a new one and fill the description with any name you want</li>
+            <li>Copy the generated token and paste it below</li>
+          </ol>
+          <QInput
+            v-model="startggManualDraft"
+            label="Paste your personal token"
+            dense outlined type="password"
+          />
+        </QCardSection>
+        <QSeparator />
+        <QCardActions align="right">
+          <QBtn flat no-caps label="Cancel" color="secondary" @click="isStartggManualDialogOpen = false" />
+          <QBtn flat no-caps color="negative" label="Delete token" @click="startggManualDraft = ''; saveStartggManualToken()" />
+          <QBtn no-caps color="primary" label="Save token" @click="saveStartggManualToken" />
+        </QCardActions>
+      </QCard>
+    </QDialog>
+
+    <!-- ── Diálogo token personal Challonge ─────────────────────────────────── -->
+    <QDialog v-model="isChallongeManualDialogOpen">
+      <QCard class="settings-dialog">
+        <QCardSection>
+          <div class="text-h6">Personal Challonge API token</div>
+        </QCardSection>
+        <QSeparator />
+        <QCardSection>
+          <div class="text-body2 q-mb-sm">
+            If OAuth fails, paste a personal Challonge API token.
+          </div>
+          <QInput
+            v-model="challongeManualDraft"
+            label="Paste your personal Challonge token"
+            dense outlined type="password"
+          />
+        </QCardSection>
+        <QSeparator />
+        <QCardActions align="right">
+          <QBtn flat no-caps label="Cancel" color="secondary" @click="isChallongeManualDialogOpen = false" />
+          <QBtn flat no-caps color="negative" label="Delete token" @click="challongeManualDraft = ''; saveChallongeManualToken()" />
+          <QBtn no-caps color="primary" label="Save token" @click="saveChallongeManualToken" />
+        </QCardActions>
+      </QCard>
+    </QDialog>
+
   </QPage>
 </template>
 
 <style scoped>
+.settings-layout {
+  max-width: 680px;
+}
+
 .settings-card {
-  max-width: 600px;
+  width: 100%;
+}
+
+.settings-dialog {
+  min-width: 320px;
+  width: min(560px, 90vw);
+}
+
+.settings-token-steps {
+  line-height: 1.6;
+}
+
+/* Fila de integración: logo | info | acciones */
+.integration-row {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+}
+
+.integration-row__logo {
+  flex-shrink: 0;
+  width: 36px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.integration-row__info {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.integration-row__actions {
+  flex-shrink: 0;
 }
 </style>

src/extension/api/challonge.ts

@@ -0,0 +1,64 @@
+export const CHALLONGE_API_BASE = 'https://api.challonge.com/v2.1';
+
+export type ChallongeErrorPayload = { errors?: { detail?: string }; error?: string } | null;
+
+const parseJsonResponse = async (response: Response): Promise<unknown> => {
+  const rawBody = await response.text();
+  if (!rawBody) return null;
+  try {
+    return JSON.parse(rawBody) as unknown;
+  } catch {
+    return null;
+  }
+};
+
+export const requestChallonge = async (path: string, token: string): Promise<unknown> => {
+  const requestUrl = `${CHALLONGE_API_BASE}${path}`;
+
+  // ── Intento v2 (OAuth Bearer) ─────────────────────────────────────────────
+  const v2Response = await fetch(requestUrl, {
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/vnd.api+json',
+      'Authorization-Type': 'v2',
+      Authorization: `Bearer ${token}`,
+    },
+  });
+  const v2Payload = await parseJsonResponse(v2Response);
+
+  if (v2Response.ok) {
+    return v2Payload;
+  }
+
+  // ── Fallback v1 (API key personal pegada manualmente) ─────────────────────
+  if (v2Response.status === 401) {
+    const v1Response = await fetch(requestUrl, {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/vnd.api+json',
+        'Authorization-Type': 'v1',
+        Authorization: token,
+      },
+    });
+    const v1Payload = await parseJsonResponse(v1Response);
+
+    if (v1Response.ok) {
+      return v1Payload;
+    }
+
+    const v1Error = v1Payload as ChallongeErrorPayload;
+    throw new Error(
+      v1Error?.errors?.detail ??
+      v1Error?.error ??
+      `Challonge responded with ${v1Response.status} ${v1Response.statusText}`.trim(),
+    );
+  }
+
+  // ── Otros errores v2 (4xx/5xx que no sean 401) ────────────────────────────
+  const v2Error = v2Payload as ChallongeErrorPayload;
+  throw new Error(
+    v2Error?.errors?.detail ??
+    v2Error?.error ??
+    `Challonge responded with ${v2Response.status} ${v2Response.statusText}`.trim(),
+  );
+};

src/extension/api/startgg.ts

@@ -0,0 +1,42 @@
+export const STARTGG_ENDPOINT = 'https://api.start.gg/gql/alpha';
+
+export interface StartGGGraphQLResponse<T> {
+  data?: T;
+  errors?: Array<{ message?: string }>;
+}
+
+export const requestStartGG = async <T>(
+  query: string,
+  variables: Record<string, unknown>,
+  token: string,
+): Promise<T> => {
+  const response = await fetch(STARTGG_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`start.gg responded with ${response.status} ${response.statusText}`.trim());
+  }
+
+  let payload: StartGGGraphQLResponse<T>;
+  try {
+    payload = (await response.json()) as StartGGGraphQLResponse<T>;
+  } catch {
+    throw new Error('Invalid JSON response from start.gg');
+  }
+
+  if (payload.errors?.length) {
+    throw new Error(payload.errors[0]?.message ?? 'Unknown start.gg error');
+  }
+
+  if (!payload.data) {
+    throw new Error('No data returned by start.gg');
+  }
+
+  return payload.data;
+};

src/extension/challonge.ts

@@ -1,562 +0,0 @@
-import { createServer, type Server, type ServerResponse } from 'node:http';
-import { randomUUID } from 'node:crypto';
-import { nodecg } from './util/nodecg.js';
-
-const CHALLONGE_API_BASE = 'https://api.challonge.com/v2.1';
-const CHALLONGE_OAUTH_AUTHORIZE_ENDPOINT = 'https://api.challonge.com/oauth/authorize';
-const CHALLONGE_OAUTH_TOKEN_ENDPOINT = 'https://api.challonge.com/oauth/token';
-const CHALLONGE_OAUTH_SCOPES = [
-  'me',
-  'tournaments:read',
-  'tournaments:write',
-  'matches:read',
-  'matches:write',
-  'participants:read',
-  'participants:write',
-].join(' ');
-const CHALLONGE_OAUTH_CALLBACK_PATH = '/challonge/callback';
-const CHALLONGE_OAUTH_DEFAULT_PORT = 34921;
-const CHALLONGE_OAUTH_SESSION_TTL_MS = 10 * 60 * 1000;
-
-interface OAuthConfig {
-  clientId: string;
-  clientSecret: string;
-  callbackPort: number;
-}
-
-interface OAuthSession {
-  sessionId: string;
-  state: string;
-  expiresAt: number;
-  status: 'pending' | 'completed' | 'error' | 'expired';
-  token?: string;
-  error?: string;
-}
-
-interface OAuthTokenResponse {
-  access_token?: string;
-  error?: string;
-  error_description?: string;
-  message?: string;
-}
-
-interface RecentTournament {
-  id: string;
-  name: string;
-  slug: string;
-  startAt: number | null;
-  endAt: number | null;
-}
-
-interface ImportedPlayer {
-  id: string;
-  gamertag: string;
-  name: string;
-  team: string;
-  country: string;
-  twitter: string;
-}
-
-const oauthSessions = new Map<string, OAuthSession>();
-let oauthCallbackServer: Server | null = null;
-
-const getStringProp = (payload: unknown, key: string): string => {
-  if (typeof payload !== 'object' || payload === null || !(key in payload)) {
-    return '';
-  }
-
-  const value = (payload as Record<string, unknown>)[key];
-  return typeof value === 'string' ? value.trim() : String(value || '').trim();
-};
-
-const getNumberProp = (payload: Record<string, unknown>, keys: string[]): number | null => {
-  for (const key of keys) {
-    const raw = payload[key];
-    if (typeof raw === 'number' && Number.isFinite(raw)) {
-      return raw;
-    }
-    if (typeof raw === 'string') {
-      const parsed = Number(raw);
-      if (Number.isFinite(parsed)) {
-        return parsed;
-      }
-    }
-  }
-  return null;
-};
-
-const sendAck = (ack: unknown, error: string | null, response?: unknown) => {
-  if (typeof ack !== 'function') {
-    return;
-  }
-  ack(error, response);
-};
-
-const getOAuthConfig = (): OAuthConfig | null => {
-  const bundleConfig = nodecg.bundleConfig as unknown as Record<string, unknown>;
-  const clientId = String(bundleConfig.challongeClientId || '').trim();
-  const clientSecret = String(bundleConfig.challongeClientSecret || '').trim();
-  const rawPort = Number(bundleConfig.challongeOAuthPort ?? CHALLONGE_OAUTH_DEFAULT_PORT);
-  const callbackPort = Number.isFinite(rawPort) && rawPort > 0 ? rawPort : CHALLONGE_OAUTH_DEFAULT_PORT;
-
-  if (!clientId || !clientSecret) {
-    return null;
-  }
-
-  return {
-    clientId,
-    clientSecret,
-    callbackPort,
-  };
-};
-
-const getCallbackUrl = (callbackPort: number) => `http://127.0.0.1:${callbackPort}${CHALLONGE_OAUTH_CALLBACK_PATH}`;
-
-const updateOAuthSession = (sessionId: string, update: Partial<OAuthSession>) => {
-  const session = oauthSessions.get(sessionId);
-  if (!session) {
-    return;
-  }
-
-  oauthSessions.set(sessionId, {
-    ...session,
-    ...update,
-  });
-};
-
-const cleanupExpiredOAuthSessions = () => {
-  const now = Date.now();
-  oauthSessions.forEach((session, sessionId) => {
-    if (session.expiresAt <= now && session.status === 'pending') {
-      updateOAuthSession(sessionId, { status: 'expired' });
-    }
-  });
-};
-
-const renderCallbackHtml = (title: string, message: string) => `<!doctype html>
-<html lang="es">
-  <head>
-    <meta charset="utf-8" />
-    <title>${title}</title>
-    <style>
-      body { font-family: Arial, sans-serif; margin: 2rem; background: #121212; color: #fff; }
-      .box { max-width: 680px; padding: 1rem 1.2rem; border: 1px solid #444; border-radius: 8px; }
-    </style>
-  </head>
-  <body>
-    <div class="box">
-      <h2>${title}</h2>
-      <p>${message}</p>
-      <p>You can close this tab and return to Scoreko.</p>
-    </div>
-  </body>
-</html>`;
-
-const respondWithCallbackHtml = (res: ServerResponse, statusCode: number, title: string, message: string) => {
-  res.statusCode = statusCode;
-  res.setHeader('Content-Type', 'text/html; charset=utf-8');
-  res.end(renderCallbackHtml(title, message));
-};
-
-const parseOAuthTokenPayload = async (response: Response): Promise<OAuthTokenResponse> => {
-  const rawBody = await response.text();
-  try {
-    return JSON.parse(rawBody) as OAuthTokenResponse;
-  } catch {
-    return { message: rawBody };
-  }
-};
-
-const exchangeOAuthCodeForToken = async (
-  code: string,
-  redirectUri: string,
-  oauthConfig: OAuthConfig,
-): Promise<string> => {
-  const params = new URLSearchParams({
-    grant_type: 'authorization_code',
-    code,
-    client_id: oauthConfig.clientId,
-    client_secret: oauthConfig.clientSecret,
-    redirect_uri: redirectUri,
-  });
-
-  const response = await fetch(CHALLONGE_OAUTH_TOKEN_ENDPOINT, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: params.toString(),
-  });
-
-  const payload = await parseOAuthTokenPayload(response);
-
-  if (!response.ok) {
-    throw new Error(payload.error_description || payload.error || payload.message || `OAuth token request failed (${response.status})`);
-  }
-
-  const token = String(payload.access_token || '').trim();
-  if (!token) {
-    throw new Error(payload.error_description || payload.error || payload.message || 'OAuth token response did not include an access token');
-  }
-
-  return token;
-};
-
-const parseJsonResponse = async (response: Response): Promise<unknown> => {
-  const rawBody = await response.text();
-  if (!rawBody) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(rawBody) as unknown;
-  } catch {
-    return null;
-  }
-};
-
-const requestChallonge = async (path: string, token: string): Promise<unknown> => {
-  const requestUrl = `${CHALLONGE_API_BASE}${path}`;
-
-  const v2Response = await fetch(requestUrl, {
-    headers: {
-      Accept: 'application/json',
-      'Content-Type': 'application/vnd.api+json',
-      'Authorization-Type': 'v2',
-      Authorization: `Bearer ${token}`,
-    },
-  });
-
-  const v2Payload = await parseJsonResponse(v2Response);
-
-  if (v2Response.ok) {
-    return v2Payload;
-  }
-
-  // Fallback for personal API keys pasted manually (v1 auth style).
-  if (v2Response.status === 401) {
-    const v1Response = await fetch(requestUrl, {
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/vnd.api+json',
-        'Authorization-Type': 'v1',
-        Authorization: token,
-      },
-    });
-
-    const v1Payload = await parseJsonResponse(v1Response);
-    if (v1Response.ok) {
-      return v1Payload;
-    }
-  }
-
-  const maybeError = v2Payload as { errors?: { detail?: string }; error?: string } | null;
-  if (!v2Response.ok) {
-    throw new Error(
-      maybeError?.errors?.detail || maybeError?.error || `Challonge responded with ${v2Response.status} ${v2Response.statusText}`.trim(),
-    );
-  }
-
-  return v2Payload;
-};
-
-const normalizeTournamentSlug = (value: string): string => {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return '';
-  }
-  return trimmed.replace(/^https?:\/\/[^/]+\//i, '').replace(/^tournaments\//i, '').replace(/^\/+/, '');
-};
-
-const parseRecentTournaments = (payload: unknown): RecentTournament[] => {
-  const rows: RecentTournament[] = [];
-
-  const push = (candidate: Record<string, unknown>) => {
-    const attributes = (typeof candidate.attributes === 'object' && candidate.attributes !== null)
-      ? (candidate.attributes as Record<string, unknown>)
-      : candidate;
-
-    const id = String(candidate.id || attributes.id || attributes.tournament_id || '').trim();
-    const name = String(attributes.name || attributes.full_name || '').trim();
-    const slug = normalizeTournamentSlug(String(attributes.url || attributes.slug || attributes.identifier || id));
-
-    if (!id || !name || !slug) {
-      return;
-    }
-
-    rows.push({
-      id,
-      name,
-      slug,
-      startAt: getNumberProp(attributes, ['start_at', 'started_at', 'startAt']),
-      endAt: getNumberProp(attributes, ['completed_at', 'end_at', 'ended_at', 'endAt']),
-    });
-  };
-
-  if (Array.isArray(payload)) {
-    payload.forEach((row) => {
-      const wrapper = row as Record<string, unknown>;
-      const tournament = (typeof wrapper.tournament === 'object' && wrapper.tournament !== null)
-        ? (wrapper.tournament as Record<string, unknown>)
-        : wrapper;
-      push(tournament);
-    });
-    return rows;
-  }
-
-  if (typeof payload === 'object' && payload !== null) {
-    const root = payload as Record<string, unknown>;
-    const data = root.data;
-    if (Array.isArray(data)) {
-      data.forEach((row) => {
-        if (typeof row === 'object' && row !== null) {
-          push(row as Record<string, unknown>);
-        }
-      });
-      return rows;
-    }
-  }
-
-  return rows;
-};
-
-const parseImportedPlayers = (payload: unknown): ImportedPlayer[] => {
-  const map = new Map<string, ImportedPlayer>();
-
-  const push = (candidate: Record<string, unknown>) => {
-    const attributes = (typeof candidate.attributes === 'object' && candidate.attributes !== null)
-      ? (candidate.attributes as Record<string, unknown>)
-      : candidate;
-
-    const id = String(candidate.id || attributes.id || attributes.participant_id || '').trim();
-    const gamertag = String(
-      attributes.display_name
-      || attributes.name
-      || attributes.username
-      || attributes.gamer_tag
-      || '',
-    ).trim();
-
-    if (!id || !gamertag) {
-      return;
-    }
-
-    map.set(id, {
-      id,
-      gamertag,
-      name: gamertag,
-      team: String(attributes.group_player_ids || attributes.team_name || '').trim(),
-      country: '',
-      twitter: String(attributes.twitter_handle || attributes.twitter || '').trim(),
-    });
-  };
-
-  if (Array.isArray(payload)) {
-    payload.forEach((row) => {
-      const wrapper = row as Record<string, unknown>;
-      const participant = (typeof wrapper.participant === 'object' && wrapper.participant !== null)
-        ? (wrapper.participant as Record<string, unknown>)
-        : wrapper;
-      push(participant);
-    });
-    return Array.from(map.values());
-  }
-
-  if (typeof payload === 'object' && payload !== null) {
-    const root = payload as Record<string, unknown>;
-    const data = root.data;
-    if (Array.isArray(data)) {
-      data.forEach((row) => {
-        if (typeof row === 'object' && row !== null) {
-          push(row as Record<string, unknown>);
-        }
-      });
-    }
-  }
-
-  return Array.from(map.values());
-};
-
-const ensureOAuthCallbackServer = async (oauthConfig: OAuthConfig) => {
-  if (oauthCallbackServer) {
-    return;
-  }
-
-  const callbackUrl = getCallbackUrl(oauthConfig.callbackPort);
-
-  const server = createServer((req, res) => {
-    if (!req.url) {
-      res.statusCode = 400;
-      res.end('Bad request');
-      return;
-    }
-
-    const requestUrl = new URL(req.url, callbackUrl);
-    if (requestUrl.pathname !== CHALLONGE_OAUTH_CALLBACK_PATH) {
-      res.statusCode = 404;
-      res.end('Not found');
-      return;
-    }
-
-    cleanupExpiredOAuthSessions();
-
-    const state = requestUrl.searchParams.get('state') || '';
-    const code = requestUrl.searchParams.get('code') || '';
-    const error = requestUrl.searchParams.get('error') || '';
-
-    const session = Array.from(oauthSessions.values()).find((candidate) => candidate.state === state);
-    if (!session) {
-      respondWithCallbackHtml(res, 400, 'Invalid OAuth', 'No active session was found for this authorization.');
-      return;
-    }
-
-    if (session.expiresAt <= Date.now()) {
-      updateOAuthSession(session.sessionId, { status: 'expired' });
-      respondWithCallbackHtml(res, 400, 'Session expired', 'The OAuth session expired. Start the process again from Scoreko.');
-      return;
-    }
-
-    if (error) {
-      updateOAuthSession(session.sessionId, { status: 'error', error });
-      respondWithCallbackHtml(res, 400, 'OAuth canceled', `Challonge returned this error: ${error}`);
-      return;
-    }
-
-    if (!code) {
-      updateOAuthSession(session.sessionId, {
-        status: 'error',
-        error: 'Missing authorization code',
-      });
-      respondWithCallbackHtml(res, 400, 'Incomplete OAuth', 'No authorization code was received.');
-      return;
-    }
-
-    void exchangeOAuthCodeForToken(code, callbackUrl, oauthConfig)
-      .then((token) => {
-        updateOAuthSession(session.sessionId, { status: 'completed', token, error: undefined });
-      })
-      .catch((exchangeError) => {
-        const message = exchangeError instanceof Error ? exchangeError.message : 'Failed to exchange authorization code';
-        updateOAuthSession(session.sessionId, { status: 'error', error: message });
-      });
-
-    respondWithCallbackHtml(res, 200, 'Authorization received', 'Your authorization was received. Finishing sign-in in the background...');
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(oauthConfig.callbackPort, '127.0.0.1', () => {
-      server.off('error', reject);
-      resolve();
-    });
-  });
-
-  oauthCallbackServer = server;
-};
-
-nodecg.listenFor('challonge:createOAuthSession', async (_payload: unknown, ack) => {
-  const oauthConfig = getOAuthConfig();
-  if (!oauthConfig) {
-    sendAck(ack, 'OAuth is not configured in this installation (missing challongeClientId/challongeClientSecret). Use the Client ID and Client Secret from a Challonge OAuth app.');
-    return;
-  }
-
-  try {
-    await ensureOAuthCallbackServer(oauthConfig);
-  } catch (serverError) {
-    const message = serverError instanceof Error ? serverError.message : 'Could not start the local OAuth callback';
-    sendAck(ack, message);
-    return;
-  }
-
-  cleanupExpiredOAuthSessions();
-
-  const sessionId = randomUUID();
-  const state = randomUUID();
-  oauthSessions.set(sessionId, {
-    sessionId,
-    state,
-    expiresAt: Date.now() + CHALLONGE_OAUTH_SESSION_TTL_MS,
-    status: 'pending',
-  });
-
-  const params = new URLSearchParams({
-    response_type: 'code',
-    client_id: oauthConfig.clientId,
-    redirect_uri: getCallbackUrl(oauthConfig.callbackPort),
-    scope: CHALLONGE_OAUTH_SCOPES,
-    state,
-  });
-
-  sendAck(ack, null, {
-    sessionId,
-    authUrl: `${CHALLONGE_OAUTH_AUTHORIZE_ENDPOINT}?${params.toString()}`,
-  });
-});
-
-nodecg.listenFor('challonge:getOAuthSessionStatus', (payload: unknown, ack) => {
-  cleanupExpiredOAuthSessions();
-
-  const sessionId = getStringProp(payload, 'sessionId');
-  if (!sessionId) {
-    sendAck(ack, 'Missing OAuth session id');
-    return;
-  }
-
-  const session = oauthSessions.get(sessionId);
-  if (!session) {
-    sendAck(ack, 'OAuth session not found');
-    return;
-  }
-
-  sendAck(ack, null, {
-    status: session.status,
-    token: session.status === 'completed' ? session.token : undefined,
-    error: session.status === 'error' ? session.error : undefined,
-  });
-});
-
-nodecg.listenFor('challonge:fetchRecentTournaments', async (payload: unknown, ack) => {
-  const token = getStringProp(payload, 'token');
-
-  if (!token) {
-    sendAck(ack, 'Missing Challonge API token');
-    return;
-  }
-
-  try {
-    const raw = await requestChallonge('/tournaments.json', token);
-    const tournaments = parseRecentTournaments(raw)
-      .sort((a, b) => (b.startAt ?? 0) - (a.startAt ?? 0))
-      .slice(0, 20);
-
-    sendAck(ack, null, tournaments);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error while loading tournaments';
-    sendAck(ack, message);
-  }
-});
-
-nodecg.listenFor('challonge:fetchTournamentPlayers', async (payload: unknown, ack) => {
-  const token = getStringProp(payload, 'token');
-  const slug = normalizeTournamentSlug(getStringProp(payload, 'slug'));
-
-  if (!token) {
-    sendAck(ack, 'Missing Challonge API token');
-    return;
-  }
-
-  if (!slug) {
-    sendAck(ack, 'Missing tournament slug');
-    return;
-  }
-
-  try {
-    const raw = await requestChallonge(`/tournaments/${encodeURIComponent(slug)}/participants.json`, token);
-    const players = parseImportedPlayers(raw);
-    sendAck(ack, null, players);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error while importing players';
-    sendAck(ack, message);
-  }
-});

src/extension/index.ts

@@ -9,6 +9,7 @@ export default async (nodecg: NodeCGServerAPI) => {
   set(nodecg); // set nodecg "context" before anything else
   await import('./util/replicants.js'); // make sure replicants are set up
   await import('./example.js');
-  await import('./startgg.js');
+  await import('./nodecg-bindings/startgg.js');
-  await import('./challonge.js');
+  await import('./nodecg-bindings/challonge.js');
+  await import('./pack-manager.js');
 };

src/extension/nodecg-bindings/challonge.ts

@@ -0,0 +1,91 @@
+import { nodecg } from '../util/nodecg.js';
+import { getStringProp, normalizeTournamentSlug } from '../../shared/utils/string.js';
+import { challongeOAuthServer, getOAuthMode } from '../oauth/challonge.js';
+import { fetchRecentTournaments, fetchTournamentPlayers } from '../services/challonge.js';
+import type { OAuthConfig } from '../util/oauth-server.js';
+
+const sendAck = (ack: unknown, error: string | null, response?: unknown) => {
+  if (typeof ack === 'function') ack(error, response);
+};
+
+nodecg.listenFor('challonge:createOAuthSession', async (_payload: unknown, ack) => {
+  const mode = getOAuthMode();
+  let serverConfig: OAuthConfig;
+
+  if (mode.type === 'dev') {
+    serverConfig = {
+      clientId: mode.clientId,
+      callbackPort: mode.callbackPort,
+    };
+  } else {
+    try {
+      const res = await fetch(`${mode.proxyBaseUrl}/oauth/challonge/client-id`);
+      if (!res.ok) throw new Error(`Proxy responded with ${res.status}`);
+      const data = await res.json() as { clientId?: string };
+      const clientId = String(data.clientId ?? '').trim();
+      if (!clientId) throw new Error('Proxy did not return a clientId');
+      serverConfig = { clientId, callbackPort: mode.callbackPort };
+    } catch (err) {
+      sendAck(
+        ack,
+        err instanceof Error ? err.message : 'Could not fetch OAuth config from proxy',
+      );
+      return;
+    }
+  }
+
+  try {
+    await challongeOAuthServer.ensureServer(serverConfig);
+  } catch (err) {
+    sendAck(ack, err instanceof Error ? err.message : 'Could not start the OAuth callback server');
+    return;
+  }
+
+  sendAck(ack, null, challongeOAuthServer.createSession(serverConfig));
+});
+
+nodecg.listenFor('challonge:getOAuthSessionStatus', (payload: unknown, ack) => {
+  const sessionId = getStringProp(payload, 'sessionId');
+  if (!sessionId) {
+    sendAck(ack, 'Missing OAuth session id');
+    return;
+  }
+
+  const status = challongeOAuthServer.getSessionStatus(sessionId);
+  if (!status) {
+    sendAck(ack, 'OAuth session not found');
+    return;
+  }
+
+  sendAck(ack, null, status);
+});
+
+nodecg.listenFor('challonge:fetchRecentTournaments', async (payload: unknown, ack) => {
+  const token = getStringProp(payload, 'token');
+  if (!token) {
+    sendAck(ack, 'Missing Challonge API token');
+    return;
+  }
+
+  try {
+    const tournaments = await fetchRecentTournaments(token);
+    sendAck(ack, null, tournaments);
+  } catch (error) {
+    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while loading tournaments');
+  }
+});
+
+nodecg.listenFor('challonge:fetchTournamentPlayers', async (payload: unknown, ack) => {
+  const token = getStringProp(payload, 'token');
+  const slug = normalizeTournamentSlug(getStringProp(payload, 'slug'));
+
+  if (!token) { sendAck(ack, 'Missing Challonge API token'); return; }
+  if (!slug) { sendAck(ack, 'Missing tournament slug'); return; }
+
+  try {
+    const players = await fetchTournamentPlayers(slug, token);
+    sendAck(ack, null, players);
+  } catch (error) {
+    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while importing players');
+  }
+});

src/extension/nodecg-bindings/startgg.ts

@@ -0,0 +1,91 @@
+import { nodecg } from '../util/nodecg.js';
+import { getStringProp } from '../../shared/utils/string.js';
+import { startggOAuthServer, getOAuthMode } from '../oauth/startgg.js';
+import { fetchRecentTournaments, fetchTournamentPlayers } from '../services/startgg.js';
+import type { OAuthConfig } from '../util/oauth-server.js';
+
+const sendAck = (ack: unknown, error: string | null, response?: unknown) => {
+  if (typeof ack === 'function') ack(error, response);
+};
+
+nodecg.listenFor('startgg:createOAuthSession', async (_payload: unknown, ack) => {
+  const mode = getOAuthMode();
+  let serverConfig: OAuthConfig;
+
+  if (mode.type === 'dev') {
+    serverConfig = {
+      clientId: mode.clientId,
+      callbackPort: mode.callbackPort,
+    };
+  } else {
+    try {
+      const res = await fetch(`${mode.proxyBaseUrl}/oauth/startgg/client-id`);
+      if (!res.ok) throw new Error(`Proxy responded with ${res.status}`);
+      const data = await res.json() as { clientId?: string };
+      const clientId = String(data.clientId ?? '').trim();
+      if (!clientId) throw new Error('Proxy did not return a clientId');
+      serverConfig = { clientId, callbackPort: mode.callbackPort };
+    } catch (err) {
+      sendAck(
+        ack,
+        err instanceof Error ? err.message : 'Could not fetch OAuth config from proxy',
+      );
+      return;
+    }
+  }
+
+  try {
+    await startggOAuthServer.ensureServer(serverConfig);
+  } catch (err) {
+    sendAck(ack, err instanceof Error ? err.message : 'Could not start the OAuth callback server');
+    return;
+  }
+
+  sendAck(ack, null, startggOAuthServer.createSession(serverConfig));
+});
+
+nodecg.listenFor('startgg:getOAuthSessionStatus', (payload: unknown, ack) => {
+  const sessionId = getStringProp(payload, 'sessionId');
+  if (!sessionId) {
+    sendAck(ack, 'Missing OAuth session id');
+    return;
+  }
+
+  const status = startggOAuthServer.getSessionStatus(sessionId);
+  if (!status) {
+    sendAck(ack, 'OAuth session not found');
+    return;
+  }
+
+  sendAck(ack, null, status);
+});
+
+nodecg.listenFor('startgg:fetchRecentTournaments', async (payload: unknown, ack) => {
+  const token = getStringProp(payload, 'token');
+  if (!token) {
+    sendAck(ack, 'Missing start.gg API token');
+    return;
+  }
+
+  try {
+    const tournaments = await fetchRecentTournaments(token);
+    sendAck(ack, null, tournaments);
+  } catch (error) {
+    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while loading tournaments');
+  }
+});
+
+nodecg.listenFor('startgg:fetchTournamentPlayers', async (payload: unknown, ack) => {
+  const token = getStringProp(payload, 'token');
+  const slug = getStringProp(payload, 'slug');
+
+  if (!token) { sendAck(ack, 'Missing start.gg API token'); return; }
+  if (!slug) { sendAck(ack, 'Missing tournament slug'); return; }
+
+  try {
+    const players = await fetchTournamentPlayers(slug, token);
+    sendAck(ack, null, players);
+  } catch (error) {
+    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while importing players');
+  }
+});

src/extension/oauth/challonge.ts

@@ -0,0 +1,137 @@
+import { nodecg } from '../util/nodecg.js';
+import { createOAuthServer, type OAuthConfig } from '../util/oauth-server.js';
+import type { OAuthMode, OAuthTokenResponse } from '../../shared/types/domain.js';
+
+const CHALLONGE_OAUTH_AUTHORIZE_ENDPOINT = 'https://api.challonge.com/oauth/authorize';
+const CHALLONGE_OAUTH_TOKEN_ENDPOINT = 'https://api.challonge.com/oauth/token';
+const CHALLONGE_OAUTH_SCOPES = [
+  'me',
+  'tournaments:read',
+  'tournaments:write',
+  'matches:read',
+  'matches:write',
+  'participants:read',
+  'participants:write',
+].join(' ');
+export const CHALLONGE_OAUTH_CALLBACK_PATH = '/challonge/callback';
+const CHALLONGE_OAUTH_DEFAULT_PORT = 34921;
+const CHALLONGE_OAUTH_SESSION_TTL_MS = 10 * 60 * 1000;
+const OAUTH_PROXY_BASE_URL = 'https://scoreko-oauth-proxy.panver.workers.dev';
+
+export const getOAuthMode = (): OAuthMode => {
+  const bundleConfig = nodecg.bundleConfig as Record<string, unknown>;
+  const clientId     = String(bundleConfig.challongeClientId     ?? '').trim();
+  const clientSecret = String(bundleConfig.challongeClientSecret ?? '').trim();
+  const rawPort      = Number(bundleConfig.challongeOAuthPort    ?? CHALLONGE_OAUTH_DEFAULT_PORT);
+  const callbackPort =
+    Number.isFinite(rawPort) && rawPort > 0 ? rawPort : CHALLONGE_OAUTH_DEFAULT_PORT;
+
+  const proxyBaseUrl =
+    String(bundleConfig.oauthProxyUrl ?? '').trim() || OAUTH_PROXY_BASE_URL;
+
+  if (clientId && clientSecret) {
+    nodecg.log.info('[Challonge] OAuth: modo dev (credenciales locales)');
+    return { type: 'dev', clientId, clientSecret, callbackPort };
+  }
+
+  nodecg.log.info(`[Challonge] OAuth: modo proxy → ${proxyBaseUrl}`);
+  return { type: 'proxy', proxyBaseUrl, callbackPort };
+};
+
+const exchangeCodeDirectly = async (
+  code: string,
+  redirectUri: string,
+  clientId: string,
+  clientSecret: string,
+): Promise<string> => {
+  const params = new URLSearchParams({
+    grant_type:    'authorization_code',
+    code,
+    client_id:     clientId,
+    client_secret: clientSecret,
+    redirect_uri:  redirectUri,
+  });
+
+  const response = await fetch(CHALLONGE_OAUTH_TOKEN_ENDPOINT, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: params.toString(),
+  });
+
+  const rawBody = await response.text();
+  let payload: OAuthTokenResponse;
+  try {
+    payload = JSON.parse(rawBody) as OAuthTokenResponse;
+  } catch {
+    payload = { message: rawBody };
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      payload.error_description ??
+      payload.error ??
+      payload.message ??
+      `OAuth token request failed (${response.status})`,
+    );
+  }
+
+  const token = String(payload.access_token ?? '').trim();
+  if (!token) {
+    throw new Error(
+      payload.error_description ??
+      payload.error ??
+      payload.message ??
+      'OAuth token response did not include an access token',
+    );
+  }
+
+  return token;
+};
+
+const exchangeCodeViaProxy = async (
+  code: string,
+  redirectUri: string,
+  proxyBaseUrl: string,
+): Promise<string> => {
+  const response = await fetch(`${proxyBaseUrl}/oauth/challonge/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ code, redirectUri }),
+  });
+
+  const rawBody = await response.text();
+  let payload: { access_token?: string; error?: string };
+  try {
+    payload = JSON.parse(rawBody) as typeof payload;
+  } catch {
+    payload = { error: rawBody };
+  }
+
+  if (!response.ok) {
+    throw new Error(payload.error ?? `Proxy responded with ${response.status}`);
+  }
+  const token = String(payload.access_token ?? '').trim();
+  if (!token) throw new Error(payload.error ?? 'Proxy did not return a token');
+  return token;
+};
+
+const exchangeOAuthCodeForToken = async (
+  code: string,
+  redirectUri: string,
+  _config: OAuthConfig,
+): Promise<string> => {
+  const mode = getOAuthMode();
+  if (mode.type === 'dev') {
+    return exchangeCodeDirectly(code, redirectUri, mode.clientId, mode.clientSecret);
+  }
+  return exchangeCodeViaProxy(code, redirectUri, mode.proxyBaseUrl);
+};
+
+export const challongeOAuthServer = createOAuthServer({
+  provider: 'Challonge',
+  callbackPath: CHALLONGE_OAUTH_CALLBACK_PATH,
+  authorizeEndpoint: CHALLONGE_OAUTH_AUTHORIZE_ENDPOINT,
+  scope: CHALLONGE_OAUTH_SCOPES,
+  sessionTtlMs: CHALLONGE_OAUTH_SESSION_TTL_MS,
+  exchangeToken: exchangeOAuthCodeForToken,
+});

src/extension/oauth/startgg.ts

@@ -0,0 +1,139 @@
+import { nodecg } from '../util/nodecg.js';
+import { createOAuthServer, type OAuthConfig } from '../util/oauth-server.js';
+import type { OAuthMode, OAuthTokenResponse } from '../../shared/types/domain.js';
+
+const STARTGG_OAUTH_AUTHORIZE_ENDPOINT = 'https://www.start.gg/api/-/rest/oauth/authorize';
+const STARTGG_OAUTH_TOKEN_ENDPOINTS = [
+  'https://www.start.gg/api/-/rest/oauth/access_token',
+  'https://api.start.gg/oauth/access_token',
+];
+const STARTGG_OAUTH_SCOPES = 'user.identity tournament.manager';
+export const STARTGG_OAUTH_CALLBACK_PATH = '/startgg/callback';
+const STARTGG_OAUTH_DEFAULT_PORT = 34920;
+const STARTGG_OAUTH_SESSION_TTL_MS = 10 * 60 * 1000;
+const OAUTH_PROXY_BASE_URL = 'https://scoreko-oauth-proxy.panver.workers.dev';
+
+export const getOAuthMode = (): OAuthMode => {
+  const bundleConfig = nodecg.bundleConfig as Record<string, unknown>;
+  const clientId     = String(bundleConfig.startggClientId     ?? '').trim();
+  const clientSecret = String(bundleConfig.startggClientSecret ?? '').trim();
+  const rawPort      = Number(bundleConfig.startggOAuthPort    ?? STARTGG_OAUTH_DEFAULT_PORT);
+  const callbackPort =
+    Number.isFinite(rawPort) && rawPort > 0 ? rawPort : STARTGG_OAUTH_DEFAULT_PORT;
+
+  const proxyBaseUrl =
+    String(bundleConfig.oauthProxyUrl ?? '').trim() || OAUTH_PROXY_BASE_URL;
+
+  if (clientId && clientSecret) {
+    nodecg.log.info('[start.gg] OAuth: modo dev (credenciales locales)');
+    return { type: 'dev', clientId, clientSecret, callbackPort };
+  }
+
+  nodecg.log.info(`[start.gg] OAuth: modo proxy → ${proxyBaseUrl}`);
+  return { type: 'proxy', proxyBaseUrl, callbackPort };
+};
+
+const parseOAuthTokenPayload = async (response: Response): Promise<OAuthTokenResponse> => {
+  const rawBody = await response.text();
+  try {
+    return JSON.parse(rawBody) as OAuthTokenResponse;
+  } catch {
+    return { message: rawBody };
+  }
+};
+
+const exchangeCodeDirectly = async (
+  code: string,
+  redirectUri: string,
+  clientId: string,
+  clientSecret: string,
+): Promise<string> => {
+  const params = new URLSearchParams({
+    grant_type:    'authorization_code',
+    code,
+    client_id:     clientId,
+    client_secret: clientSecret,
+    redirect_uri:  redirectUri,
+  });
+
+  let lastError = 'Unknown OAuth token exchange error';
+
+  for (const tokenEndpoint of STARTGG_OAUTH_TOKEN_ENDPOINTS) {
+    const response = await fetch(tokenEndpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: params.toString(),
+    });
+
+    const payload = await parseOAuthTokenPayload(response);
+
+    if (response.ok) {
+      const token = String(payload.access_token ?? '').trim();
+      if (token) return token;
+      lastError =
+        payload.error_description ??
+        payload.error ??
+        payload.message ??
+        'OAuth token response did not include an access token';
+      continue;
+    }
+
+    lastError =
+      payload.error_description ??
+      payload.error ??
+      payload.message ??
+      `OAuth token request failed (${response.status})`;
+
+    if (response.status !== 404) break;
+  }
+
+  throw new Error(lastError);
+};
+
+const exchangeCodeViaProxy = async (
+  code: string,
+  redirectUri: string,
+  proxyBaseUrl: string,
+): Promise<string> => {
+  const response = await fetch(`${proxyBaseUrl}/oauth/startgg/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ code, redirectUri }),
+  });
+
+  const rawBody = await response.text();
+  let payload: { access_token?: string; error?: string };
+  try {
+    payload = JSON.parse(rawBody) as typeof payload;
+  } catch {
+    payload = { error: rawBody };
+  }
+
+  if (!response.ok) {
+    throw new Error(payload.error ?? `Proxy responded with ${response.status}`);
+  }
+  const token = String(payload.access_token ?? '').trim();
+  if (!token) throw new Error(payload.error ?? 'Proxy did not return a token');
+  return token;
+};
+
+const exchangeOAuthCodeForToken = async (
+  code: string,
+  redirectUri: string,
+  _config: OAuthConfig,
+): Promise<string> => {
+  const mode = getOAuthMode();
+  if (mode.type === 'dev') {
+    return exchangeCodeDirectly(code, redirectUri, mode.clientId, mode.clientSecret);
+  }
+  return exchangeCodeViaProxy(code, redirectUri, mode.proxyBaseUrl);
+};
+
+export const startggOAuthServer = createOAuthServer({
+  provider: 'start.gg',
+  callbackPath: STARTGG_OAUTH_CALLBACK_PATH,
+  authorizeEndpoint: STARTGG_OAUTH_AUTHORIZE_ENDPOINT,
+  scope: STARTGG_OAUTH_SCOPES,
+  sessionTtlMs: STARTGG_OAUTH_SESSION_TTL_MS,
+  exchangeToken: exchangeOAuthCodeForToken,
+});

src/extension/pack-manager.ts

@@ -0,0 +1,441 @@
+// src/extension/pack-manager.ts
+// ─────────────────────────────────────────────────────────────────────────────
+// Módulo autocontenido: no importa nada de src/shared/ para respetar el
+// rootDir del tsconfig de la extensión. Las constantes de Gitea y los tipos
+// necesarios están definidos aquí directamente.
+//
+// Para activarlo, añade UNA línea en src/extension/index.ts:
+//   await import('./pack-manager.js');
+// ─────────────────────────────────────────────────────────────────────────────
+
+import * as fs from 'fs';
+import type { IncomingMessage, ServerResponse } from 'http';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { nodecg } from './util/nodecg.js';
+
+// ── Configuración de Gitea ────────────────────────────────────────────────────
+// Edita estas constantes para apuntar a tu instancia.
+
+const GITEA_BASE_URL = 'http://10.0.0.10:3002';
+const GITEA_OWNER    = 'Pandipipas';
+const GITEA_REPO     = 'fighting-game-packs';
+const GITEA_BRANCH   = 'main';
+
+const rawUrl = (repoPath: string) =>
+  `${GITEA_BASE_URL}/${GITEA_OWNER}/${GITEA_REPO}/raw/branch/${GITEA_BRANCH}/${repoPath}`;
+
+const REGISTRY_URL              = rawUrl('registry.json');
+const getManifestUrl            = (id: string) => rawUrl(`${id}/manifest.json`);
+const getPackLogoUrl            = (id: string) => rawUrl(`${id}/logo.png`);
+const getCharacterImageRepoUrl  = (id: string, slug: string, ext: string) =>
+  rawUrl(`${id}/characters/${slug}.${ext}`);
+
+// ── Tipos locales ─────────────────────────────────────────────────────────────
+
+interface PackCharacter {
+  name: string;
+  slug: string;
+  dlc?: boolean;
+  sizeBytes: number;
+}
+
+interface PackManifest {
+  id: string;
+  name: string;
+  version: string;
+  palette: { start: string; end: string };
+  defaultPair?: { left: string; right: string };
+  characters: PackCharacter[];
+}
+
+interface PackRegistry {
+  schemaVersion: number;
+  updatedAt: string;
+  packs: Array<{
+    id: string;
+    name: string;
+    version: string;
+    totalSizeBytes: number;
+    logoPath: string;
+    characterCount: number;
+    palette: { start: string; end: string };
+    bundled: boolean;
+  }>;
+}
+
+interface PackDownloadState {
+  status: 'idle' | 'fetching-manifest' | 'downloading' | 'done' | 'error';
+  progress: number;
+  error?: string;
+}
+
+// Replicamos la forma exacta del tipo Acknowledgement de NodeCG sin necesidad
+// de importar @nodecg/types. HandledAcknowledgement NO es callable (es un objeto),
+// UnhandledAcknowledgement SÍ lo es. El helper reply() comprueba cuál es antes de llamar.
+type HandledAcknowledgement   = { handled: true };
+type UnhandledAcknowledgement = ((error?: Error | null, ...args: unknown[]) => void) & { handled: false };
+type Acknowledgement          = HandledAcknowledgement | UnhandledAcknowledgement;
+
+const reply = (ack: Acknowledgement | undefined, err: Error | null, result?: unknown): void => {
+  if (ack && !ack.handled) ack(err ?? undefined, result);
+};
+
+// ── Constantes ────────────────────────────────────────────────────────────────
+
+const IMAGE_EXTENSIONS = ['png', 'webp', 'jpg', 'jpeg', 'avif'] as const;
+
+
+// Raíz del proyecto: 2 niveles por encima de extension/pack-manager.js
+// Usamos import.meta.url porque nodecg.bundleDir no está disponible cuando
+// NodeCG se usa como dependencia en lugar de servidor standalone.
+const bundleDir = fileURLToPath(new URL('../', import.meta.url));
+
+// ── Replicants ────────────────────────────────────────────────────────────────
+
+const installedPacksRep = nodecg.Replicant<string[]>('installedPacks', {
+  defaultValue: [],
+  persistent: true,
+});
+
+const packRegistryRep = nodecg.Replicant<PackRegistry | null>('packRegistry', {
+  defaultValue: null,
+  persistent: true,
+});
+
+const downloadStatesRep = nodecg.Replicant<Record<string, PackDownloadState>>('downloadStates', {
+  defaultValue: {},
+  persistent: false,
+});
+
+/** Packs instalados para los que hay una versión más nueva en el registro. */
+const availableUpdatesRep = nodecg.Replicant<Record<string, { installedVersion: string; latestVersion: string }>>('availableUpdates', {
+  defaultValue: {},
+  persistent: false,
+});
+
+// ── Filesystem ────────────────────────────────────────────────────────────────
+
+const packsDir = path.join(bundleDir, 'packs');
+fs.mkdirSync(packsDir, { recursive: true });
+nodecg.log.info(`[pack-manager] Packs directory: ${packsDir}`);
+
+// Registrar el directorio de packs como ruta estática usando nodecg.mount().
+// Las imágenes quedan accesibles en /packs/<packId>/characters/<slug>.png
+// independientemente de cómo NodeCG configure el resto de rutas del bundle.
+const packsMiddleware = (req: IncomingMessage, res: ServerResponse) => {
+  const urlPath = decodeURIComponent(req.url ?? '/');
+  const safe    = path.normalize(urlPath).replace(/^(\.\.[/\\])+/, '');
+  const file    = path.join(packsDir, safe);
+
+  // Security: only serve files inside packsDir
+  if (!file.startsWith(packsDir)) {
+    res.writeHead(403);
+    res.end();
+    return;
+  }
+
+  fs.stat(file, (statErr, stat) => {
+    if (statErr || !stat.isFile()) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const mimeTypes: Record<string, string> = {
+      '.png':  'image/png',
+      '.jpg':  'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.webp': 'image/webp',
+      '.avif': 'image/avif',
+      '.json': 'application/json',
+    };
+    const ext = path.extname(file).toLowerCase();
+    res.setHeader('Content-Type', mimeTypes[ext] ?? 'application/octet-stream');
+    res.setHeader('Cache-Control', 'public, max-age=3600');
+    fs.createReadStream(file).pipe(res);
+  });
+};
+
+// nodecg.mount registra el middleware en el servidor Express de NodeCG
+(nodecg as unknown as { mount: (p: string, h: typeof packsMiddleware) => void })
+  .mount('/packs', packsMiddleware);
+
+// Verificación de integridad al arrancar
+const installedAtStart = installedPacksRep.value ?? [];
+const verified = installedAtStart.filter((id) =>
+  fs.existsSync(path.join(packsDir, id, 'manifest.json')),
+);
+if (verified.length !== installedAtStart.length) {
+  nodecg.log.warn('[pack-manager] Algunos packs instalados no estaban en disco y se han eliminado del registro.');
+  installedPacksRep.value = verified;
+}
+
+// ── Helpers internos ──────────────────────────────────────────────────────────
+
+const setDownloadState = (packId: string, patch: Partial<PackDownloadState>): void => {
+  const current = downloadStatesRep.value?.[packId] ?? { status: 'idle', progress: 0 };
+  downloadStatesRep.value = {
+    ...downloadStatesRep.value,
+    [packId]: { ...current, ...patch },
+  };
+};
+
+const fetchBuffer = async (url: string): Promise<Buffer> => {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status} — ${url}`);
+  return Buffer.from(await response.arrayBuffer());
+};
+
+const trySaveImage = async (
+  destDir: string,
+  filename: string,
+  extensions: readonly string[],
+  buildUrl: (ext: string) => string,
+): Promise<boolean> => {
+  for (const ext of extensions) {
+    try {
+      const buffer = await fetchBuffer(buildUrl(ext));
+      // Siempre guardamos como .png para que la URL del dashboard sea predecible.
+      // Los navegadores modernos identifican el formato por el contenido (magic bytes),
+      // no por la extensión, así que WebP/AVIF/JPEG se renderizan correctamente.
+      fs.writeFileSync(path.join(destDir, `${filename}.png`), buffer);
+      return true;
+    } catch { /* prueba siguiente extensión */ }
+  }
+  return false;
+};
+
+// ── Detección de actualizaciones ─────────────────────────────────────────────
+// Compara la versión en el manifest.json local de cada pack instalado contra
+// la versión en el registro de Gitea. Solo aplica a packs descargados (no bundled).
+
+const checkForUpdates = (): void => {
+  const registry = packRegistryRep.value;
+  const installed = installedPacksRep.value ?? [];
+
+  if (!registry || installed.length === 0) {
+    availableUpdatesRep.value = {};
+    return;
+  }
+
+  const updates: Record<string, { installedVersion: string; latestVersion: string }> = {};
+
+  for (const packId of installed) {
+    const registryEntry = registry.packs.find((p) => p.id === packId);
+    if (!registryEntry) continue;
+
+    const manifestPath = path.join(packsDir, packId, 'manifest.json');
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as PackManifest;
+      if (manifest.version !== registryEntry.version) {
+        updates[packId] = {
+          installedVersion: manifest.version,
+          latestVersion: registryEntry.version,
+        };
+        nodecg.log.info(
+          `[pack-manager] Actualización disponible para "${packId}": ${manifest.version} → ${registryEntry.version}`,
+        );
+      }
+    } catch {
+      // Manifest ilegible — ignorar este pack
+    }
+  }
+
+  availableUpdatesRep.value = updates;
+};
+
+// Comprobar al arrancar si ya hay un registro cacheado
+checkForUpdates();
+
+// ── Mensaje: fetchPackRegistry ────────────────────────────────────────────────
+
+nodecg.listenFor('fetchPackRegistry', async (_data: unknown, ack: Acknowledgement | undefined) => {
+  try {
+    const response = await fetch(REGISTRY_URL);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const registry = await response.json() as PackRegistry;
+    packRegistryRep.value = registry;
+    checkForUpdates(); // re-evaluar actualizaciones con el registro nuevo
+    reply(ack, null, registry);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    nodecg.log.error(`[pack-manager] Error al obtener el registro: ${message}`);
+    reply(ack, new Error(message));
+  }
+});
+
+// ── Mensaje: downloadPack ─────────────────────────────────────────────────────
+
+nodecg.listenFor('downloadPack', async (packId: unknown, ack: Acknowledgement | undefined) => {
+  if (typeof packId !== 'string' || !packId) {
+    return reply(ack, new Error('downloadPack requiere un packId no vacío.'));
+  }
+  if (installedPacksRep.value?.includes(packId)) {
+    return reply(ack, null, { alreadyInstalled: true });
+  }
+  if (downloadStatesRep.value?.[packId]?.status === 'downloading') {
+    return reply(ack, new Error(`El pack "${packId}" ya se está descargando.`));
+  }
+
+  setDownloadState(packId, { status: 'fetching-manifest', progress: 0, error: undefined });
+
+  try {
+    const manifestRes = await fetch(getManifestUrl(packId));
+    if (!manifestRes.ok) throw new Error(`No se puede obtener el manifest: HTTP ${manifestRes.status}`);
+    const manifest = await manifestRes.json() as PackManifest;
+
+    const packDir  = path.join(packsDir, packId);
+    const charsDir = path.join(packDir, 'characters');
+    fs.mkdirSync(charsDir, { recursive: true });
+    fs.writeFileSync(path.join(packDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+    setDownloadState(packId, { status: 'downloading', progress: 2 });
+    try {
+      const logoBuffer = await fetchBuffer(getPackLogoUrl(packId));
+      fs.writeFileSync(path.join(packDir, 'logo.png'), logoBuffer);
+    } catch {
+      nodecg.log.warn(`[pack-manager] No se encontró logo para "${packId}" — se omite.`);
+    }
+
+    const total = manifest.characters.length;
+    for (let i = 0; i < total; i++) {
+      const char = manifest.characters[i]!;
+      const saved = await trySaveImage(
+        charsDir,
+        char.slug,
+        IMAGE_EXTENSIONS,
+        (ext) => getCharacterImageRepoUrl(packId, char.slug, ext),
+      );
+      if (!saved) {
+        nodecg.log.warn(`[pack-manager] Sin imagen para "${packId}/${char.slug}" — se usará placeholder.`);
+      }
+      setDownloadState(packId, { progress: 5 + Math.round(((i + 1) / total) * 93) });
+    }
+
+    const current = installedPacksRep.value ?? [];
+    if (!current.includes(packId)) installedPacksRep.value = [...current, packId];
+
+    setDownloadState(packId, { status: 'done', progress: 100 });
+    reply(ack, null, { packId, characterCount: manifest.characters.length });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    nodecg.log.error(`[pack-manager] Error al descargar "${packId}": ${message}`);
+    setDownloadState(packId, { status: 'error', error: message });
+    reply(ack, new Error(message));
+  }
+});
+
+// ── Mensaje: uninstallPack ────────────────────────────────────────────────────
+
+nodecg.listenFor('uninstallPack', (packId: unknown, ack: Acknowledgement | undefined) => {
+  if (typeof packId !== 'string' || !packId) {
+    return reply(ack, new Error('uninstallPack requiere un packId no vacío.'));
+  }
+  try {
+    fs.rmSync(path.join(packsDir, packId), { recursive: true, force: true });
+    installedPacksRep.value = (installedPacksRep.value ?? []).filter((id) => id !== packId);
+    const states = { ...downloadStatesRep.value };
+    delete states[packId];
+    downloadStatesRep.value = states;
+    const updates = { ...availableUpdatesRep.value };
+    delete updates[packId];
+    availableUpdatesRep.value = updates;
+    reply(ack, null);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    nodecg.log.error(`[pack-manager] Error al desinstalar "${packId}": ${message}`);
+    reply(ack, new Error(message));
+  }
+});
+
+// ── Mensaje: updatePack ──────────────────────────────────────────────────────
+// Dashboard → Extension: "Actualiza el pack <packId> a la última versión."
+// Borra las imágenes antiguas y descarga las nuevas desde Gitea.
+
+nodecg.listenFor('updatePack', async (packId: unknown, ack: Acknowledgement | undefined) => {
+  if (typeof packId !== 'string' || !packId) {
+    return reply(ack, new Error('updatePack requiere un packId no vacío.'));
+  }
+  if (!installedPacksRep.value?.includes(packId)) {
+    return reply(ack, new Error(`El pack "${packId}" no está instalado. Usa downloadPack primero.`));
+  }
+  if (downloadStatesRep.value?.[packId]?.status === 'downloading') {
+    return reply(ack, new Error(`El pack "${packId}" ya se está actualizando.`));
+  }
+
+  setDownloadState(packId, { status: 'fetching-manifest', progress: 0, error: undefined });
+
+  try {
+    // 1. Obtener nuevo manifest
+    const manifestRes = await fetch(getManifestUrl(packId));
+    if (!manifestRes.ok) throw new Error(`No se puede obtener el manifest: HTTP ${manifestRes.status}`);
+    const manifest = await manifestRes.json() as PackManifest;
+
+    const packDir  = path.join(packsDir, packId);
+    const charsDir = path.join(packDir, 'characters');
+
+    // 2. Limpiar imágenes antiguas para evitar residuos de personajes renombrados
+    if (fs.existsSync(charsDir)) {
+      fs.rmSync(charsDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(charsDir, { recursive: true });
+
+    // 3. Guardar nuevo manifest en disco
+    fs.writeFileSync(path.join(packDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+    // 4. Logo
+    setDownloadState(packId, { status: 'downloading', progress: 2 });
+    try {
+      const logoBuffer = await fetchBuffer(getPackLogoUrl(packId));
+      fs.writeFileSync(path.join(packDir, 'logo.png'), logoBuffer);
+    } catch {
+      nodecg.log.warn(`[pack-manager] No se encontró logo para "${packId}" — se omite.`);
+    }
+
+    // 5. Imágenes de personajes
+    const total = manifest.characters.length;
+    for (let i = 0; i < total; i++) {
+      const char = manifest.characters[i]!;
+      const saved = await trySaveImage(
+        charsDir,
+        char.slug,
+        IMAGE_EXTENSIONS,
+        (ext) => getCharacterImageRepoUrl(packId, char.slug, ext),
+      );
+      if (!saved) {
+        nodecg.log.warn(`[pack-manager] Sin imagen para "${packId}/${char.slug}" — se usará placeholder.`);
+      }
+      setDownloadState(packId, { progress: 5 + Math.round(((i + 1) / total) * 93) });
+    }
+
+    // 6. Quitar de availableUpdates
+    const updates = { ...availableUpdatesRep.value };
+    delete updates[packId];
+    availableUpdatesRep.value = updates;
+
+    setDownloadState(packId, { status: 'done', progress: 100 });
+    nodecg.log.info(`[pack-manager] Pack "${packId}" actualizado a v${manifest.version}.`);
+    reply(ack, null, { packId, version: manifest.version });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    nodecg.log.error(`[pack-manager] Error al actualizar "${packId}": ${message}`);
+    setDownloadState(packId, { status: 'error', error: message });
+    reply(ack, new Error(message));
+  }
+});
+
+// ── Mensaje: readLocalManifest ────────────────────────────────────────────────
+
+nodecg.listenFor('readLocalManifest', (packId: unknown, ack: Acknowledgement | undefined) => {
+  if (typeof packId !== 'string' || !packId) {
+    return reply(ack, new Error('readLocalManifest requiere un packId no vacío.'));
+  }
+  const manifestPath = path.join(packsDir, packId, 'manifest.json');
+  try {
+    const raw = fs.readFileSync(manifestPath, 'utf-8');
+    reply(ack, null, JSON.parse(raw) as PackManifest);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    reply(ack, new Error(`No se puede leer el manifest de "${packId}": ${message}`));
+  }
+});

src/extension/services/challonge.ts

@@ -0,0 +1,138 @@
+import { requestChallonge } from '../api/challonge.js';
+import { normalizeTournamentSlug, getNumberProp } from '../../shared/utils/string.js';
+import type { RecentTournament, ImportedPlayer } from '../../shared/types/domain.js';
+
+const RECENT_TOURNAMENTS_LIMIT = 20;
+
+export const parseRecentTournaments = (payload: unknown): RecentTournament[] => {
+  const rows: RecentTournament[] = [];
+
+  const push = (candidate: Record<string, unknown>) => {
+    const attributes =
+      typeof candidate.attributes === 'object' && candidate.attributes !== null
+        ? (candidate.attributes as Record<string, unknown>)
+        : candidate;
+
+    const id = String(candidate.id ?? attributes.id ?? attributes.tournament_id ?? '').trim();
+    const name = String(attributes.name ?? attributes.full_name ?? '').trim();
+    const slug = normalizeTournamentSlug(
+      String(attributes.url ?? attributes.slug ?? attributes.identifier ?? id),
+    );
+
+    if (!id || !name || !slug) return;
+
+    rows.push({
+      id,
+      name,
+      slug,
+      startAt: getNumberProp(attributes, ['start_at', 'started_at', 'startAt']),
+      endAt: getNumberProp(attributes, ['completed_at', 'end_at', 'ended_at', 'endAt']),
+    });
+  };
+
+  if (Array.isArray(payload)) {
+    for (const row of payload) {
+      const wrapper = row as Record<string, unknown>;
+      const tournament =
+        typeof wrapper.tournament === 'object' && wrapper.tournament !== null
+          ? (wrapper.tournament as Record<string, unknown>)
+          : wrapper;
+      push(tournament);
+    }
+    return rows;
+  }
+
+  if (typeof payload === 'object' && payload !== null) {
+    const data = (payload as Record<string, unknown>).data;
+    if (Array.isArray(data)) {
+      for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+          push(row as Record<string, unknown>);
+        }
+      }
+    }
+  }
+
+  return rows;
+};
+
+export const parseImportedPlayers = (payload: unknown): ImportedPlayer[] => {
+  const map = new Map<string, ImportedPlayer>();
+
+  const push = (candidate: Record<string, unknown>) => {
+    const attributes =
+      typeof candidate.attributes === 'object' && candidate.attributes !== null
+        ? (candidate.attributes as Record<string, unknown>)
+        : candidate;
+
+    const id = String(
+      candidate.id ?? attributes.id ?? attributes.participant_id ?? '',
+    ).trim();
+
+    const rawDisplayName = String(
+      attributes.display_name ??
+      attributes.name ??
+      attributes.username ??
+      attributes.gamer_tag ??
+      '',
+    ).trim();
+
+    if (!id || !rawDisplayName) return;
+
+    const PIPE_PATTERN = /^(.+?)\s*\|\s*(.+)$/;
+    const pipeMatch = PIPE_PATTERN.exec(rawDisplayName);
+
+    const teamFromName = pipeMatch ? pipeMatch[1].trim() : '';
+    const gamertag = pipeMatch ? pipeMatch[2].trim() : rawDisplayName;
+    const team = String(attributes.team_name ?? '').trim() || teamFromName;
+
+    map.set(id, {
+      id,
+      gamertag,
+      name: '',
+      team,
+      country: '',
+      twitter: String(attributes.twitter_handle ?? attributes.twitter ?? '').trim(),
+    });
+  };
+
+  if (Array.isArray(payload)) {
+    for (const row of payload) {
+      const wrapper = row as Record<string, unknown>;
+      const participant =
+        typeof wrapper.participant === 'object' && wrapper.participant !== null
+          ? (wrapper.participant as Record<string, unknown>)
+          : wrapper;
+      push(participant);
+    }
+    return Array.from(map.values());
+  }
+
+  if (typeof payload === 'object' && payload !== null) {
+    const data = (payload as Record<string, unknown>).data;
+    if (Array.isArray(data)) {
+      for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+          push(row as Record<string, unknown>);
+        }
+      }
+    }
+  }
+
+  return Array.from(map.values());
+};
+
+export const fetchRecentTournaments = async (token: string): Promise<RecentTournament[]> => {
+  const raw = await requestChallonge('/tournaments.json', token);
+  return parseRecentTournaments(raw)
+    .sort((a, b) => (b.startAt ?? 0) - (a.startAt ?? 0))
+    .slice(0, RECENT_TOURNAMENTS_LIMIT);
+};
+
+export const fetchTournamentPlayers = async (slug: string, token: string): Promise<ImportedPlayer[]> => {
+  const raw = await requestChallonge(
+    `/tournaments/${encodeURIComponent(slug)}/participants.json`,
+    token,
+  );
+  return parseImportedPlayers(raw);
+};

src/extension/services/startgg.ts

@@ -0,0 +1,115 @@
+import { getData, type CountryRecord } from 'country-list';
+import { requestStartGG } from '../api/startgg.js';
+import type { RecentTournament, ImportedPlayer } from '../../shared/types/domain.js';
+
+const RECENT_TOURNAMENTS_LIMIT = 12;
+const PARTICIPANTS_PAGE_SIZE = 120;
+
+const countries = getData();
+const countryByCode = new Set(countries.map((c: CountryRecord) => c.code.toUpperCase()));
+const countryByName = new Map(
+  countries.map((c: CountryRecord) => [c.name.toLowerCase(), c.code.toUpperCase()]),
+);
+
+export const resolveCountryCodeFromStartGG = (country: string | null | undefined): string => {
+  const raw = (country ?? '').trim();
+  if (!raw) return '';
+  const upper = raw.toUpperCase();
+  if (countryByCode.has(upper)) return upper;
+  return countryByName.get(raw.toLowerCase()) ?? '';
+};
+
+export const fetchRecentTournaments = async (token: string): Promise<RecentTournament[]> => {
+  const query = `
+    query RecentTournaments($perPage: Int!) {
+      currentUser {
+        tournaments(query: { perPage: $perPage, filter: { tournamentView: "admin" } }) {
+          nodes {
+            id
+            name
+            slug
+            startAt
+            endAt
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await requestStartGG<{
+    currentUser: { tournaments: { nodes: RecentTournament[] } } | null;
+  }>(query, { perPage: RECENT_TOURNAMENTS_LIMIT }, token);
+
+  return data.currentUser?.tournaments.nodes
+    .filter((item) => item.slug)
+    .sort((a, b) => (b.startAt ?? 0) - (a.startAt ?? 0))
+    .map(({ id, name, slug, startAt, endAt }) => ({ id: String(id), name, slug, startAt, endAt })) ?? [];
+};
+
+export const fetchTournamentPlayers = async (slug: string, token: string): Promise<ImportedPlayer[]> => {
+  const query = `
+    query TournamentParticipants($slug: String!, $page: Int!, $perPage: Int!) {
+      tournament(slug: $slug) {
+        participants(query: { page: $page, perPage: $perPage }) {
+          pageInfo {
+            totalPages
+          }
+          nodes {
+            id
+            gamerTag
+            prefix
+            user {
+              location {
+                country
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  let currentPage = 1;
+  let totalPages = 1;
+  const playersMap = new Map<string, ImportedPlayer>();
+
+  while (currentPage <= totalPages) {
+    const data = await requestStartGG<{
+      tournament: {
+        participants: {
+          pageInfo: { totalPages: number };
+          nodes: Array<{
+            id: number;
+            gamerTag: string | null;
+            prefix: string | null;
+            user: { location: { country: string | null } | null } | null;
+          }>;
+        };
+      } | null;
+    }>(query, { slug, page: currentPage, perPage: PARTICIPANTS_PAGE_SIZE }, token);
+
+    if (!data.tournament) throw new Error('Tournament not found');
+
+    const apiTotalPages = Number(data.tournament.participants.pageInfo.totalPages);
+    totalPages = Number.isFinite(apiTotalPages) ? Math.max(apiTotalPages, 1) : 1;
+
+    for (const participant of data.tournament.participants.nodes) {
+      const playerId = String(participant.id);
+      const gamertag = (participant.gamerTag ?? '').trim();
+      if (!gamertag) continue;
+
+      playersMap.set(playerId, {
+        id: playerId,
+        gamertag,
+        name: gamertag,
+        team: (participant.prefix ?? '').trim(),
+        country: resolveCountryCodeFromStartGG(participant.user?.location?.country),
+        twitter: '',
+      });
+    }
+
+    currentPage += 1;
+  }
+
+  return Array.from(playersMap.values());
+};

src/extension/startgg.ts

@@ -1,540 +0,0 @@
-import { createServer, type Server, type ServerResponse } from 'node:http';
-import { randomUUID } from 'node:crypto';
-import { getData, type CountryRecord } from 'country-list';
-import { nodecg } from './util/nodecg.js';
-
-const STARTGG_ENDPOINT = 'https://api.start.gg/gql/alpha';
-const STARTGG_OAUTH_AUTHORIZE_ENDPOINT = 'https://www.start.gg/api/-/rest/oauth/authorize';
-const STARTGG_OAUTH_TOKEN_ENDPOINTS = [
-  'https://www.start.gg/api/-/rest/oauth/access_token',
-  'https://api.start.gg/oauth/access_token',
-];
-const STARTGG_OAUTH_SCOPES = 'user.identity tournament.manager';
-const STARTGG_OAUTH_CALLBACK_PATH = '/startgg/callback';
-const STARTGG_OAUTH_DEFAULT_PORT = 34920;
-const STARTGG_OAUTH_SESSION_TTL_MS = 10 * 60 * 1000;
-
-const RECENT_TOURNAMENTS_LIMIT = 12;
-const PARTICIPANTS_PAGE_SIZE = 120;
-
-interface StartGGGraphQLResponse<T> {
-  data?: T;
-  errors?: Array<{ message?: string }>;
-}
-
-interface RecentTournament {
-  id: number;
-  name: string;
-  slug: string;
-  startAt: number | null;
-  endAt: number | null;
-}
-
-interface ImportedPlayer {
-  id: string;
-  gamertag: string;
-  name: string;
-  team: string;
-  country: string;
-  twitter: string;
-}
-
-interface OAuthConfig {
-  clientId: string;
-  clientSecret: string;
-  callbackPort: number;
-}
-
-interface OAuthSession {
-  sessionId: string;
-  state: string;
-  expiresAt: number;
-  status: 'pending' | 'completed' | 'error' | 'expired';
-  token?: string;
-  error?: string;
-}
-
-interface OAuthTokenResponse {
-  access_token?: string;
-  error?: string;
-  error_description?: string;
-  message?: string;
-}
-
-const oauthSessions = new Map<string, OAuthSession>();
-let oauthCallbackServer: Server | null = null;
-
-const getStringProp = (payload: unknown, key: string): string => {
-  if (typeof payload !== 'object' || payload === null || !(key in payload)) {
-    return '';
-  }
-
-  const value = (payload as Record<string, unknown>)[key];
-  return typeof value === 'string' ? value.trim() : String(value || '').trim();
-};
-
-const updateOAuthSession = (sessionId: string, update: Partial<OAuthSession>) => {
-  const session = oauthSessions.get(sessionId);
-  if (!session) {
-    return;
-  }
-
-  oauthSessions.set(sessionId, {
-    ...session,
-    ...update,
-  });
-};
-
-const requestStartGG = async <T>(query: string, variables: Record<string, unknown>, token: string): Promise<T> => {
-  const response = await fetch(STARTGG_ENDPOINT, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({ query, variables }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`start.gg responded with ${response.status} ${response.statusText}`.trim());
-  }
-
-  let payload: StartGGGraphQLResponse<T>;
-  try {
-    payload = (await response.json()) as StartGGGraphQLResponse<T>;
-  } catch {
-    throw new Error('Invalid JSON response from start.gg');
-  }
-
-  if (payload.errors?.length) {
-    throw new Error(payload.errors[0]?.message || 'Unknown start.gg error');
-  }
-
-  if (!payload.data) {
-    throw new Error('No data returned by start.gg');
-  }
-
-  return payload.data;
-};
-
-const countries = getData();
-const countryByCode = new Set(countries.map((country: CountryRecord) => country.code.toUpperCase()));
-const countryByName = new Map(countries.map((country: CountryRecord) => [country.name.toLowerCase(), country.code.toUpperCase()]));
-
-const resolveCountryCodeFromStartGG = (country: string | null | undefined): string => {
-  const raw = (country || '').trim();
-  if (!raw) {
-    return '';
-  }
-
-  const upper = raw.toUpperCase();
-  if (countryByCode.has(upper)) {
-    return upper;
-  }
-
-  return countryByName.get(raw.toLowerCase()) ?? '';
-};
-
-const sendAck = (ack: unknown, error: string | null, response?: unknown) => {
-  if (typeof ack !== 'function') {
-    return;
-  }
-  ack(error, response);
-};
-
-const getOAuthConfig = (): OAuthConfig | null => {
-  const bundleConfig = nodecg.bundleConfig as unknown as Record<string, unknown>;
-  const clientId = String(bundleConfig.startggClientId || '').trim();
-  const clientSecret = String(bundleConfig.startggClientSecret || '').trim();
-  const rawPort = Number(bundleConfig.startggOAuthPort ?? STARTGG_OAUTH_DEFAULT_PORT);
-  const callbackPort = Number.isFinite(rawPort) && rawPort > 0 ? rawPort : STARTGG_OAUTH_DEFAULT_PORT;
-
-  if (!clientId || !clientSecret) {
-    return null;
-  }
-
-  return {
-    clientId,
-    clientSecret,
-    callbackPort,
-  };
-};
-
-const getCallbackUrl = (callbackPort: number) => `http://127.0.0.1:${callbackPort}${STARTGG_OAUTH_CALLBACK_PATH}`;
-
-const cleanupExpiredOAuthSessions = () => {
-  const now = Date.now();
-  oauthSessions.forEach((session, sessionId) => {
-    if (session.expiresAt <= now && session.status === 'pending') {
-      updateOAuthSession(sessionId, { status: 'expired' });
-    }
-  });
-};
-
-const respondWithCallbackHtml = (res: ServerResponse, statusCode: number, title: string, message: string) => {
-  res.statusCode = statusCode;
-  res.setHeader('Content-Type', 'text/html; charset=utf-8');
-  res.end(renderCallbackHtml(title, message));
-};
-
-const renderCallbackHtml = (title: string, message: string) => `<!doctype html>
-<html lang="es">
-  <head>
-    <meta charset="utf-8" />
-    <title>${title}</title>
-    <style>
-      body { font-family: Arial, sans-serif; margin: 2rem; background: #121212; color: #fff; }
-      .box { max-width: 680px; padding: 1rem 1.2rem; border: 1px solid #444; border-radius: 8px; }
-      .ok { color: #66bb6a; }
-      .ko { color: #ef5350; }
-    </style>
-  </head>
-  <body>
-    <div class="box">
-      <h2>${title}</h2>
-      <p>${message}</p>
-      <p>You can close this tab and return to Scoreko.</p>
-    </div>
-  </body>
-</html>`;
-
-const parseOAuthTokenPayload = async (response: Response): Promise<OAuthTokenResponse> => {
-  const rawBody = await response.text();
-  try {
-    return JSON.parse(rawBody) as OAuthTokenResponse;
-  } catch {
-    return { message: rawBody };
-  }
-};
-
-const exchangeOAuthCodeForToken = async (
-  code: string,
-  redirectUri: string,
-  oauthConfig: OAuthConfig,
-): Promise<string> => {
-  const params = new URLSearchParams({
-    grant_type: 'authorization_code',
-    code,
-    client_id: oauthConfig.clientId,
-    client_secret: oauthConfig.clientSecret,
-    redirect_uri: redirectUri,
-  });
-
-  let lastError = 'Unknown OAuth token exchange error';
-
-  for (const tokenEndpoint of STARTGG_OAUTH_TOKEN_ENDPOINTS) {
-    const response = await fetch(tokenEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: params.toString(),
-    });
-
-    const payload = await parseOAuthTokenPayload(response);
-
-    if (response.ok) {
-      const token = String(payload.access_token || '').trim();
-      if (token) {
-        return token;
-      }
-
-      lastError = payload.error_description || payload.error || payload.message || 'OAuth token response did not include an access token';
-      continue;
-    }
-
-    lastError = payload.error_description || payload.error || payload.message || `OAuth token request failed (${response.status})`;
-
-    if (response.status !== 404) {
-      break;
-    }
-  }
-
-  throw new Error(lastError);
-};
-
-const ensureOAuthCallbackServer = async (oauthConfig: OAuthConfig) => {
-  if (oauthCallbackServer) {
-    return;
-  }
-
-  const callbackUrl = getCallbackUrl(oauthConfig.callbackPort);
-
-  const server = createServer((req, res) => {
-    if (!req.url) {
-      res.statusCode = 400;
-      res.end('Bad request');
-      return;
-    }
-
-    const requestUrl = new URL(req.url, callbackUrl);
-    if (requestUrl.pathname !== STARTGG_OAUTH_CALLBACK_PATH) {
-      res.statusCode = 404;
-      res.end('Not found');
-      return;
-    }
-
-    cleanupExpiredOAuthSessions();
-
-    const state = requestUrl.searchParams.get('state') || '';
-    const code = requestUrl.searchParams.get('code') || '';
-    const error = requestUrl.searchParams.get('error') || '';
-
-    const session = Array.from(oauthSessions.values()).find((candidate) => candidate.state === state);
-    if (!session) {
-      respondWithCallbackHtml(res, 400, 'Invalid OAuth', 'No active session was found for this authorization.');
-      return;
-    }
-
-    if (session.expiresAt <= Date.now()) {
-      updateOAuthSession(session.sessionId, { status: 'expired' });
-      respondWithCallbackHtml(res, 400, 'Session expired', 'The OAuth session expired. Start the process again from Scoreko.');
-      return;
-    }
-
-    if (error) {
-      updateOAuthSession(session.sessionId, { status: 'error', error });
-      respondWithCallbackHtml(res, 400, 'OAuth canceled', `start.gg returned this error: ${error}`);
-      return;
-    }
-
-    if (!code) {
-      updateOAuthSession(session.sessionId, {
-        status: 'error',
-        error: 'Missing authorization code',
-      });
-      respondWithCallbackHtml(res, 400, 'Incomplete OAuth', 'No authorization code was received.');
-      return;
-    }
-
-    void exchangeOAuthCodeForToken(code, callbackUrl, oauthConfig)
-      .then((token) => {
-        updateOAuthSession(session.sessionId, { status: 'completed', token, error: undefined });
-      })
-      .catch((exchangeError) => {
-        const message = exchangeError instanceof Error ? exchangeError.message : 'Failed to exchange authorization code';
-        updateOAuthSession(session.sessionId, { status: 'error', error: message });
-      });
-
-    respondWithCallbackHtml(res, 200, 'Authorization received', 'Your authorization was received. Finishing sign-in in the background...');
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(oauthConfig.callbackPort, '127.0.0.1', () => {
-      server.off('error', reject);
-      resolve();
-    });
-  });
-
-  oauthCallbackServer = server;
-};
-
-nodecg.listenFor('startgg:createOAuthSession', async (_payload: unknown, ack) => {
-  const oauthConfig = getOAuthConfig();
-  if (!oauthConfig) {
-    sendAck(ack, 'OAuth is not configured in this installation (missing startggClientId/startggClientSecret). Use the Client ID and Client Secret from a start.gg OAuth app.');
-    return;
-  }
-
-  try {
-    await ensureOAuthCallbackServer(oauthConfig);
-  } catch (serverError) {
-    const message = serverError instanceof Error ? serverError.message : 'Could not start the local OAuth callback';
-    sendAck(ack, message);
-    return;
-  }
-
-  cleanupExpiredOAuthSessions();
-
-  const sessionId = randomUUID();
-  const state = randomUUID();
-  const session: OAuthSession = {
-    sessionId,
-    state,
-    expiresAt: Date.now() + STARTGG_OAUTH_SESSION_TTL_MS,
-    status: 'pending',
-  };
-  oauthSessions.set(sessionId, session);
-
-  const params = new URLSearchParams({
-    response_type: 'code',
-    client_id: oauthConfig.clientId,
-    redirect_uri: getCallbackUrl(oauthConfig.callbackPort),
-    scope: STARTGG_OAUTH_SCOPES,
-    state,
-  });
-
-  sendAck(ack, null, {
-    sessionId,
-    authUrl: `${STARTGG_OAUTH_AUTHORIZE_ENDPOINT}?${params.toString()}`,
-  });
-});
-
-nodecg.listenFor('startgg:getOAuthSessionStatus', (payload: unknown, ack) => {
-  cleanupExpiredOAuthSessions();
-
-  const sessionId = getStringProp(payload, 'sessionId');
-
-  if (!sessionId) {
-    sendAck(ack, 'Missing OAuth session id');
-    return;
-  }
-
-  const session = oauthSessions.get(sessionId);
-  if (!session) {
-    sendAck(ack, 'OAuth session not found');
-    return;
-  }
-
-  sendAck(ack, null, {
-    status: session.status,
-    token: session.status === 'completed' ? session.token : undefined,
-    error: session.status === 'error' ? session.error : undefined,
-  });
-});
-
-nodecg.listenFor('startgg:fetchRecentTournaments', async (payload: unknown, ack) => {
-  const token = getStringProp(payload, 'token');
-
-  if (!token) {
-    sendAck(ack, 'Missing start.gg API token');
-    return;
-  }
-
-  const query = `
-    query RecentTournaments($perPage: Int!) {
-      currentUser {
-        tournaments(query: { perPage: $perPage, filter: { tournamentView: "admin" } }) {
-          nodes {
-            id
-            name
-            slug
-            startAt
-            endAt
-          }
-        }
-      }
-    }
-  `;
-
-  try {
-    const data = await requestStartGG<{
-      currentUser: { tournaments: { nodes: RecentTournament[] } } | null;
-    }>(query, { perPage: RECENT_TOURNAMENTS_LIMIT }, token);
-
-    const tournaments = data.currentUser?.tournaments.nodes
-      .filter((item) => item.slug)
-      .sort((a, b) => (b.startAt ?? 0) - (a.startAt ?? 0))
-      .map((item) => ({
-        id: item.id,
-        name: item.name,
-        slug: item.slug,
-        startAt: item.startAt,
-        endAt: item.endAt,
-      })) ?? [];
-
-    sendAck(ack, null, tournaments);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error while loading tournaments';
-    sendAck(ack, message);
-  }
-});
-
-nodecg.listenFor('startgg:fetchTournamentPlayers', async (payload: unknown, ack) => {
-  const token = getStringProp(payload, 'token');
-  const slug = getStringProp(payload, 'slug');
-
-  if (!token) {
-    sendAck(ack, 'Missing start.gg API token');
-    return;
-  }
-
-  if (!slug) {
-    sendAck(ack, 'Missing tournament slug');
-    return;
-  }
-
-  const query = `
-    query TournamentParticipants($slug: String!, $page: Int!, $perPage: Int!) {
-      tournament(slug: $slug) {
-        participants(query: { page: $page, perPage: $perPage }) {
-          pageInfo {
-            totalPages
-          }
-          nodes {
-            id
-            gamerTag
-            prefix
-            user {
-              location {
-                country
-              }
-            }
-          }
-        }
-      }
-    }
-  `;
-
-  try {
-    let currentPage = 1;
-    let totalPages = 1;
-    const playersMap = new Map<string, ImportedPlayer>();
-
-    while (currentPage <= totalPages) {
-      const data = await requestStartGG<{
-        tournament: {
-          participants: {
-            pageInfo: { totalPages: number };
-            nodes: Array<{
-              id: number;
-              gamerTag: string | null;
-              prefix: string | null;
-              user: {
-                location: {
-                  country: string | null;
-                } | null;
-              } | null;
-            }>;
-          };
-        } | null;
-      }>(query, {
-        slug,
-        page: currentPage,
-        perPage: PARTICIPANTS_PAGE_SIZE,
-      }, token);
-
-      if (!data.tournament) {
-        throw new Error('Tournament not found');
-      }
-
-      const apiTotalPages = Number(data.tournament.participants.pageInfo.totalPages);
-      totalPages = Number.isFinite(apiTotalPages) ? Math.max(apiTotalPages, 1) : 1;
-
-      data.tournament.participants.nodes.forEach((participant) => {
-        const playerId = String(participant.id);
-        const gamertag = (participant.gamerTag || '').trim();
-        if (!gamertag) {
-          return;
-        }
-        const country = resolveCountryCodeFromStartGG(participant.user?.location?.country);
-        playersMap.set(playerId, {
-          id: playerId,
-          gamertag,
-          name: gamertag,
-          team: (participant.prefix || '').trim(),
-          country,
-          twitter: '',
-        });
-      });
-
-      currentPage += 1;
-    }
-
-    sendAck(ack, null, Array.from(playersMap.values()));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error while importing players';
-    sendAck(ack, message);
-  }
-});

src/extension/util/oauth-server.ts

@@ -0,0 +1,275 @@
+import { createServer, type Server, type ServerResponse } from 'node:http';
+import { randomUUID } from 'node:crypto';
+
+// ─── Tipos públicos ────────────────────────────────────────────────────────────
+
+export interface OAuthConfig {
+  clientId: string;
+  /** Solo necesario en modo dev (exchange directo con el proveedor).
+   *  En modo proxy el exchange lo hace el Worker y no necesita el secret. */
+  clientSecret?: string;
+  callbackPort: number;
+}
+
+export interface OAuthSessionStatus {
+  status: 'pending' | 'completed' | 'error' | 'expired';
+  token?: string;
+  error?: string;
+}
+
+export interface CreateSessionResult {
+  sessionId: string;
+  authUrl: string;
+}
+
+export interface OAuthServerOptions {
+  /** Nombre legible del proveedor, usado en mensajes y HTML del callback */
+  provider: string;
+  /** Ruta del callback OAuth, p.ej. '/startgg/callback' */
+  callbackPath: string;
+  /** URL del endpoint de autorización del proveedor */
+  authorizeEndpoint: string;
+  /** Scopes separados por espacio */
+  scope: string;
+  /** Milisegundos antes de que una sesión pendiente expire */
+  sessionTtlMs: number;
+  /**
+   * Intercambia un código de autorización por un access token.
+   * Lanza un error si el intercambio falla.
+   */
+  exchangeToken: (code: string, redirectUri: string, config: OAuthConfig) => Promise<string>;
+}
+
+export interface OAuthServerHandle {
+  /** Arranca el servidor de callback si aún no está corriendo */
+  ensureServer(config: OAuthConfig): Promise<void>;
+  /** Crea una nueva sesión OAuth y devuelve sessionId + URL de autorización */
+  createSession(config: OAuthConfig): CreateSessionResult;
+  /** Devuelve el estado actual de una sesión, o null si no existe */
+  getSessionStatus(sessionId: string): OAuthSessionStatus | null;
+}
+
+// ─── Tipos internos ────────────────────────────────────────────────────────────
+
+interface OAuthSession {
+  sessionId: string;
+  state: string;
+  expiresAt: number;
+  status: 'pending' | 'completed' | 'error' | 'expired';
+  token?: string;
+  error?: string;
+}
+
+// ─── HTML de callback ──────────────────────────────────────────────────────────
+
+const renderCallbackHtml = (title: string, message: string) => `<!doctype html>
+<html lang="es">
+  <head>
+    <meta charset="utf-8" />
+    <title>${title}</title>
+    <style>
+      body { font-family: Arial, sans-serif; margin: 2rem; background: #121212; color: #fff; }
+      .box { max-width: 680px; padding: 1rem 1.2rem; border: 1px solid #444; border-radius: 8px; }
+      .ok { color: #66bb6a; }
+      .ko { color: #ef5350; }
+    </style>
+  </head>
+  <body>
+    <div class="box">
+      <h2>${title}</h2>
+      <p>${message}</p>
+      <p>You can close this tab and return to Scoreko.</p>
+    </div>
+  </body>
+</html>`;
+
+const respondWithCallbackHtml = (
+  res: ServerResponse,
+  statusCode: number,
+  title: string,
+  message: string,
+) => {
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  res.end(renderCallbackHtml(title, message));
+};
+
+// ─── Factory principal ─────────────────────────────────────────────────────────
+
+export const createOAuthServer = (options: OAuthServerOptions): OAuthServerHandle => {
+  const sessions = new Map<string, OAuthSession>();
+  let server: Server | null = null;
+
+  const getCallbackUrl = (port: number) =>
+    `http://127.0.0.1:${port}${options.callbackPath}`;
+
+  const updateSession = (sessionId: string, update: Partial<OAuthSession>) => {
+    const session = sessions.get(sessionId);
+    if (!session) return;
+    sessions.set(sessionId, { ...session, ...update });
+  };
+
+  /**
+   * Marca como expiradas las sesiones pendientes que han superado su TTL,
+   * y elimina del Map las sesiones ya terminadas (completed / error / expired)
+   * que también hayan superado su TTL.
+   */
+  const cleanupSessions = () => {
+    const now = Date.now();
+    sessions.forEach((session, sessionId) => {
+      if (session.expiresAt > now) return;
+
+      if (session.status === 'pending') {
+        updateSession(sessionId, { status: 'expired' });
+      }
+
+      // Eliminar sesiones terminadas que ya hayan expirado para no crecer sin límite
+      if (session.status !== 'pending') {
+        sessions.delete(sessionId);
+      }
+    });
+  };
+
+  const ensureServer = async (config: OAuthConfig): Promise<void> => {
+    if (server) return;
+
+    const callbackUrl = getCallbackUrl(config.callbackPort);
+
+    const newServer = createServer((req, res) => {
+      if (!req.url) {
+        res.statusCode = 400;
+        res.end('Bad request');
+        return;
+      }
+
+      const requestUrl = new URL(req.url, callbackUrl);
+      if (requestUrl.pathname !== options.callbackPath) {
+        res.statusCode = 404;
+        res.end('Not found');
+        return;
+      }
+
+      cleanupSessions();
+
+      const state = requestUrl.searchParams.get('state') ?? '';
+      const code = requestUrl.searchParams.get('code') ?? '';
+      const error = requestUrl.searchParams.get('error') ?? '';
+
+      const session = Array.from(sessions.values()).find((s) => s.state === state);
+
+      if (!session) {
+        respondWithCallbackHtml(
+          res, 400,
+          'Invalid OAuth',
+          'No active session was found for this authorization.',
+        );
+        return;
+      }
+
+      if (session.expiresAt <= Date.now()) {
+        updateSession(session.sessionId, { status: 'expired' });
+        respondWithCallbackHtml(
+          res, 400,
+          'Session expired',
+          'The OAuth session expired. Start the process again from Scoreko.',
+        );
+        return;
+      }
+
+      if (error) {
+        updateSession(session.sessionId, { status: 'error', error });
+        respondWithCallbackHtml(
+          res, 400,
+          'OAuth canceled',
+          `${options.provider} returned this error: ${error}`,
+        );
+        return;
+      }
+
+      if (!code) {
+        updateSession(session.sessionId, { status: 'error', error: 'Missing authorization code' });
+        respondWithCallbackHtml(
+          res, 400,
+          'Incomplete OAuth',
+          'No authorization code was received.',
+        );
+        return;
+      }
+
+      void options
+        .exchangeToken(code, callbackUrl, config)
+        .then((token) => {
+          updateSession(session.sessionId, { status: 'completed', token, error: undefined });
+        })
+        .catch((err: unknown) => {
+          const message =
+            err instanceof Error ? err.message : 'Failed to exchange authorization code';
+          updateSession(session.sessionId, { status: 'error', error: message });
+        });
+
+      respondWithCallbackHtml(
+        res, 200,
+        'Authorization received',
+        'Your authorization was received. Finishing sign-in in the background...',
+      );
+    });
+
+    // Si el servidor sufre un error tras arrancar, resetear la referencia
+    // para que la próxima llamada a ensureServer() pueda reiniciarlo.
+    newServer.on('error', (err) => {
+      console.error(`[${options.provider}] OAuth callback server error:`, err);
+      server = null;
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      newServer.once('error', reject);
+      newServer.listen(config.callbackPort, '127.0.0.1', () => {
+        newServer.off('error', reject);
+        resolve();
+      });
+    });
+
+    server = newServer;
+  };
+
+  const createSession = (config: OAuthConfig): CreateSessionResult => {
+    cleanupSessions();
+
+    const sessionId = randomUUID();
+    const state = randomUUID();
+
+    sessions.set(sessionId, {
+      sessionId,
+      state,
+      expiresAt: Date.now() + options.sessionTtlMs,
+      status: 'pending',
+    });
+
+    const params = new URLSearchParams({
+      response_type: 'code',
+      client_id: config.clientId,
+      redirect_uri: getCallbackUrl(config.callbackPort),
+      scope: options.scope,
+      state,
+    });
+
+    return {
+      sessionId,
+      authUrl: `${options.authorizeEndpoint}?${params.toString()}`,
+    };
+  };
+
+  const getSessionStatus = (sessionId: string): OAuthSessionStatus | null => {
+    cleanupSessions();
+    const session = sessions.get(sessionId);
+    if (!session) return null;
+
+    return {
+      status: session.status,
+      token: session.status === 'completed' ? session.token : undefined,
+      error: session.status === 'error' ? session.error : undefined,
+    };
+  };
+
+  return { ensureServer, createSession, getSessionStatus };
+};

src/graphics/scoreboard-2xko/main.vue

@@ -2,7 +2,7 @@
 import { useHead } from '@unhead/vue';
 import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue';
 import { graphicsSettingsReplicant, playersReplicant, scoreboardReplicant } from '../../browser_shared/replicants';
-import { resolveCountryCode } from '../../shared/countries';
+import { resolveCountryCode } from '../../shared/utils/countries';
 import { getCharactersByGame } from '../../shared/fighting-characters';
 import type { Schemas } from '../../types';
 

src/graphics/scoreboard/main.vue

@@ -2,7 +2,7 @@
 import { useHead } from '@unhead/vue';
 import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue';
 import { graphicsSettingsReplicant, playersReplicant, scoreboardReplicant } from '../../browser_shared/replicants';
-import { resolveCountryCode } from '../../shared/countries';
+import { resolveCountryCode } from '../../shared/utils/countries';
 import type { Schemas } from '../../types';
 
 useHead({ title: 'Scoreboard' });