ci: bump version to v0.6.3

Use relative /api/tournament path instead of hardcoded
http://141.37.123.132:8086. The browser was hitting the external
tournament-server directly with the user's RS256 token, which it
rejects. Routing through our backend lets it publish to the native
server with the auto-registered director token.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -41,3 +41,6 @@ Thumbs.db
 # Claude Code
 /.claude/settings.local.json
 /.claude/worktrees/
+
+# Local clone of the tournament server repo (not tracked)
+/tournament-server/

CHANGELOG.md

@@ -96,3 +96,20 @@
 ### Features
 
 * NCWF-10 streaming endpoint ([#14](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/issues/14)) ([1dabd88](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/1dabd88c6286a7b01d6fe8527aec864b24e21cca))
+## [0.0.0](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/compare/0.6.0...0.0.0) (2026-06-23)
+
+### Bug Fixes
+
+* api streaming issues ([0621968](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/0621968c3ceddebe01e9c363bda345b5dcccfbbf))
+* api url ([2229cfd](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/2229cfd00a7d16daa6a9544c8940e792c4362dfb))
+* streaming issues ([bd6d023](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/bd6d02351336ed6adf66244979c6d959f47e318b))
+## [0.0.0](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/compare/0.6.1...0.0.0) (2026-06-23)
+
+### Bug Fixes
+
+* jwt token issue ([147d7f0](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/147d7f0d2ca7a77bb80eb4b73b8d60b00ad2f708))
+## [0.0.0](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/compare/0.6.2...0.0.0) (2026-06-23)
+
+### Bug Fixes
+
+* route tournament calls through backend gateway ([890c3fc](https://git.janis-eccarius.de/NowChess/NowChess-Frontend/commit/890c3fcecccec89e643180725e2a601f84fa5d99))

src/app/components/toolbar/toolbar.component.html

@@ -9,7 +9,7 @@
   <!-- Center links — only when logged in -->
   @if (currentUser) {
   <div class="nc-links">
-    <button type="button" class="nc-link">
+    <button type="button" class="nc-link" (click)="goToTournaments()">
       <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"
         stroke-linecap="round" stroke-linejoin="round">
         <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" />

src/app/models/tournament.models.ts

@@ -51,13 +51,20 @@ export interface TournamentList {
   finished: Tournament[];
 }
 
+export interface TournamentMatch {
+  gameId: string;
+  whiteId: string;
+  winner?: 'white' | 'black' | 'draw' | null;
+  status?: GameStatus;
+}
+
 export interface TournamentPairing {
-  id: string;
-  round: number;
+  id?: string;
+  round?: number;
   white: TournamentBotRef | null;
   black: TournamentBotRef;
-  gameId: string | null;
-  winner: 'white' | 'black' | 'draw' | null;
+  matches: TournamentMatch[];
+  winner?: 'white' | 'black' | 'draw' | null;
 }
 
 export interface RoundPairings {

src/app/pages/tournaments/tournaments.component.html

@@ -158,9 +158,10 @@
                       <div class="state-msg small"><span class="pulse"></span>Loading…</div>
                     } @else if (pairings && pairings.pairings.length > 0) {
                       <div class="pairings-list">
-                        @for (p of pairings.pairings; track p.id) {
-                          <div class="pairing-row" [class.is-watchable]="!!p.gameId"
-                            (click)="p.gameId && watchGame(p.gameId)">
+                        @for (p of pairings.pairings; track pairingKey(p)) {
+                          @let gid = firstGameId(p);
+                          <div class="pairing-row" [class.is-watchable]="!!gid"
+                            (click)="gid && watchGame(gid)">
                             <span class="pairing-white">{{ p.white?.name ?? 'Bye' }}</span>
                             <span class="pairing-vs">vs</span>
                             <span class="pairing-black">{{ p.black.name }}</span>
@@ -168,7 +169,7 @@
                               <span class="pairing-result" [class]="'result-' + p.winner">
                                 {{ p.winner === 'draw' ? '½–½' : p.winner === 'white' ? '1–0' : '0–1' }}
                               </span>
-                            } @else if (p.gameId) {
+                            } @else if (gid) {
                               <span class="pairing-ongoing">
                                 <svg width="9" height="9" viewBox="0 0 24 24" fill="currentColor">
                                   <circle cx="12" cy="12" r="10"/>

src/app/pages/tournaments/tournaments.component.ts

@@ -10,7 +10,7 @@ import { BotService } from '../../services/bot.service';
 import { OfficialBotService } from '../../services/official-bot.service';
 import { TournamentServerService, ExternalTournamentServer } from '../../services/tournament-server.service';
 import { Bot } from '../../models/bot.models';
-import { Tournament, TournamentResult, RoundPairings } from '../../models/tournament.models';
+import { Tournament, TournamentResult, RoundPairings, TournamentPairing } from '../../models/tournament.models';
 import { CurrentUser } from '../../models/auth.models';
 import { environment } from '../../../environments/environment';
 
@@ -167,6 +167,16 @@ export class TournamentsComponent implements OnInit {
     });
   }
 
+  firstGameId(p: TournamentPairing): string | null {
+    return p.matches?.[0]?.gameId ?? null;
+  }
+
+  pairingKey(p: TournamentPairing): string {
+    const w = p.white?.id ?? 'bye';
+    const b = p.black?.id ?? 'bye';
+    return `${w}-${b}-${this.firstGameId(p) ?? ''}`;
+  }
+
   watchGame(gameId: string): void {
     const tid = this.selectedTournament?.id;
     if (!tid) return;

src/app/services/tournament-auth.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+
+interface RegisterResponse {
+  id: string;
+  token: string;
+}
+
+@Injectable({ providedIn: 'root' })
+export class TournamentAuthService {
+  private readonly inflight = new Map<string, Promise<string>>();
+
+  async getToken(serverUrl: string): Promise<string> {
+    const key = this.cacheKey(serverUrl);
+    const cached = localStorage.getItem(key);
+    if (cached) return cached;
+
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+
+    const promise = this.register(serverUrl)
+      .then(token => {
+        localStorage.setItem(key, token);
+        this.inflight.delete(key);
+        return token;
+      })
+      .catch(err => {
+        this.inflight.delete(key);
+        throw err;
+      });
+
+    this.inflight.set(key, promise);
+    return promise;
+  }
+
+  clearToken(serverUrl: string): void {
+    localStorage.removeItem(this.cacheKey(serverUrl));
+  }
+
+  private async register(serverUrl: string): Promise<string> {
+    const base = serverUrl.replace(/\/+$/, '');
+    const localName = localStorage.getItem('username') ?? 'viewer';
+    const res = await fetch(`${base}/api/auth/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: `${localName}-watch`, isBot: false })
+    });
+    if (!res.ok) throw new Error(`tournament-server register failed: ${res.status}`);
+    const body = (await res.json()) as RegisterResponse;
+    return body.token;
+  }
+
+  private cacheKey(serverUrl: string): string {
+    return `tournament-token:${serverUrl.replace(/\/+$/, '')}`;
+  }
+}

src/app/services/tournament-stream.service.ts

@@ -1,36 +1,38 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable } from 'rxjs';
 import { GameStreamEvent, TournamentStreamEvent } from '../models/tournament.models';
+import { TournamentAuthService } from './tournament-auth.service';
 
 @Injectable({ providedIn: 'root' })
 export class TournamentStreamService {
+  private readonly auth = inject(TournamentAuthService);
+
   streamTournament(serverUrl: string, tournamentId: string): Observable<TournamentStreamEvent> {
     return this.ndjson<TournamentStreamEvent>(
-      this.url(serverUrl, `/api/tournament/${tournamentId}/stream`)
+      serverUrl,
+      `/api/tournament/${tournamentId}/stream`
     );
   }
 
   streamGame(serverUrl: string, tournamentId: string, gameId: string): Observable<GameStreamEvent> {
     return this.ndjson<GameStreamEvent>(
-      this.url(serverUrl, `/api/tournament/${tournamentId}/game/${gameId}/stream`)
+      serverUrl,
+      `/api/tournament/${tournamentId}/game/${gameId}/stream`
     );
   }
 
-  private url(base: string, path: string): string {
+  private fullUrl(base: string, path: string): string {
     if (!base) return path;
     return `${base.replace(/\/+$/, '')}${path}`;
   }
 
-  private ndjson<T>(url: string): Observable<T> {
+  private ndjson<T>(serverUrl: string, path: string): Observable<T> {
     return new Observable<T>(subscriber => {
       const controller = new AbortController();
-      const token = localStorage.getItem('token');
-      const headers: Record<string, string> = { Accept: 'application/x-ndjson' };
-      if (token) headers['Authorization'] = `Bearer ${token}`;
 
       (async () => {
         try {
-          const res = await fetch(url, { headers, signal: controller.signal });
+          const res = await this.openWithRetry(serverUrl, path, controller.signal);
           if (!res.ok || !res.body) {
             subscriber.error(new Error(`Stream failed: ${res.status} ${res.statusText}`));
             return;
@@ -63,4 +65,20 @@ export class TournamentStreamService {
       return () => controller.abort();
     });
   }
+
+  private async openWithRetry(serverUrl: string, path: string, signal: AbortSignal): Promise<Response> {
+    const url = this.fullUrl(serverUrl, path);
+    const token = await this.auth.getToken(serverUrl);
+    const res = await fetch(url, {
+      headers: { Accept: 'application/x-ndjson', Authorization: `Bearer ${token}` },
+      signal,
+    });
+    if (res.status !== 401) return res;
+    this.auth.clearToken(serverUrl);
+    const fresh = await this.auth.getToken(serverUrl);
+    return fetch(url, {
+      headers: { Accept: 'application/x-ndjson', Authorization: `Bearer ${fresh}` },
+      signal,
+    });
+  }
 }

versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
 MINOR=6
-PATCH=0
+PATCH=3