vimp-engine 0.37.0 → 0.38.0

package/src/client/lib/authApi.js

@@ -0,0 +1,97 @@
+// REST-клиент auth-сервиса (packages/auth): регистрация, сессия, OAuth,
+// управление профилем. Без DOM; fetch инъектируется (тесты).
+//
+// Каждый метод возвращает { ok: true, status, data } или
+// { ok: false, status, error }: error — поле `error` тела ответа ('unknown',
+// если его нет), 'network' — fetch бросил исключение (status 0).
+
+const JSON_HEADERS = { 'Content-Type': 'application/json' };
+
+/**
+ * @param {Object} options
+ * @param {string} options.serviceUrl - базовый URL auth-сервиса.
+ * @param {Function} [options.fetchImpl]
+ */
+export function createAuthApi({
+  serviceUrl,
+  fetchImpl = (...args) => fetch(...args),
+}) {
+  // куки не используются: личность — заголовок Authorization
+  async function request(method, path, { session, body } = {}) {
+    const headers = {};
+
+    if (body !== undefined) {
+      Object.assign(headers, JSON_HEADERS);
+    }
+
+    if (session) {
+      headers.Authorization = `Session ${session}`;
+    }
+
+    const init = { method, headers };
+
+    if (body !== undefined) {
+      init.body = JSON.stringify(body);
+    }
+
+    let res;
+
+    try {
+      res = await fetchImpl(`${serviceUrl}${path}`, init);
+    } catch {
+      return { ok: false, status: 0, error: 'network' };
+    }
+
+    const data = res.status === 204 ? null : await res.json().catch(() => null);
+
+    if (!res.ok) {
+      return {
+        ok: false,
+        status: res.status,
+        error: (data && data.error) || 'unknown',
+      };
+    }
+
+    return { ok: true, status: res.status, data };
+  }
+
+  return {
+    clientConfig: () => request('GET', '/client-config'),
+
+    register: ({ nick, turnstileToken, termsVersion }) =>
+      request('POST', '/register', {
+        body: { nick, turnstileToken, termsVersion },
+      }),
+
+    token: session => request('POST', '/token', { session }),
+
+    logout: session => request('POST', '/logout', { session }),
+
+    restore: ({ code, verifier, termsVersion }) =>
+      request('POST', '/session/restore', {
+        body: { code, verifier, termsVersion },
+      }),
+
+    linkOauth: (session, { code, verifier, consentVersion }) =>
+      request('POST', '/account/oauth', {
+        session,
+        body: { code, verifier, consentVersion },
+      }),
+
+    unlinkOauth: (session, provider) =>
+      request('DELETE', `/account/oauth/${encodeURIComponent(provider)}`, {
+        session,
+      }),
+
+    deleteAccount: (session, confirmNick) =>
+      request('DELETE', '/account', { session, body: { confirmNick } }),
+
+    exportData: session => request('GET', '/account/export', { session }),
+
+    // навигация вкладки, не fetch: URL отдаётся вызывающему
+    oauthStartUrl: (provider, { mode, returnUrl, challenge }) =>
+      `${serviceUrl}/oauth/${provider}/start?mode=${encodeURIComponent(mode)}` +
+      `&returnUrl=${encodeURIComponent(returnUrl)}` +
+      `&challenge=${encodeURIComponent(challenge)}`,
+  };
+}

package/src/client/lib/pkce.js

@@ -0,0 +1,23 @@
+// PKCE-подобная привязка результата OAuth к начавшей вкладке: verifier
+// остаётся в её sessionStorage, на auth уходит только challenge.
+
+const toBase64Url = bytes =>
+  btoa(String.fromCharCode(...bytes))
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+
+// 32 случайных байта → base64url (43 символа)
+export function createVerifier(cryptoImpl = crypto) {
+  return toBase64Url(cryptoImpl.getRandomValues(new Uint8Array(32)));
+}
+
+// base64url(sha256(verifier)); Web Crypto, поэтому асинхронно
+export async function challengeOf(verifier, cryptoImpl = crypto) {
+  const digest = await cryptoImpl.subtle.digest(
+    'SHA-256',
+    new TextEncoder().encode(verifier),
+  );
+
+  return toBase64Url(new Uint8Array(digest));
+}

package/src/client/lib/roomLink.js

@@ -5,7 +5,7 @@
 //   #/<gameId>/<roomId>   — прямой вход в комнату
 //
 // Маршрут живёт в hash: страница одна (SPA), сервер про маршруты не знает, а
-// OAuth-возврат hash сохраняет (returnUrl LobbyAuthModel.loginUrl). Решения
+// OAuth-возврат hash сохраняет (returnUrl LobbyAuthModel.restoreUrl). Решения
 // «что делать с маршрутом» и «куда уходить из комнаты» — чистые функции:
 // main.js исполняется при импорте, и проверить ветвление внутри него нечем.
 

package/src/client/lib/signalingErrors.js

@@ -52,13 +52,13 @@ export function decideUnknownRoom({
 }
 
 /**
- * Что делать с error {code: 'invalidToken'} мастера (истёкший вход).
+ * Что делать с error {code: 'invalidToken'} мастера (токен отклонён).
  * @param {Object} ctx
  * @param {Object} ctx.msg - сообщение ошибки ({ code, re, roomId }).
  * @param {boolean} ctx.promoting - вкладка занимает комнату (hostPromotion).
  * @param {boolean} ctx.inRoom - вкладка в комнате.
  * @param {string|null} ctx.sessionState - состояние SessionSupervisor.
- * @returns {'abandonPromotion'|'keepPlaying'|'logoutAndLeave'|'logout'}
+ * @returns {'abandonPromotion'|'keepPlaying'|'renewAndRetry'}
  */
 export function decideInvalidToken({ msg, promoting, inRoom, sessionState }) {
   if (msg.re === 'register_host' && promoting) {
@@ -70,5 +70,5 @@ export function decideInvalidToken({ msg, promoting, inRoom, sessionState }) {
     return 'keepPlaying';
   }
 
-  return inRoom ? 'logoutAndLeave' : 'logout';
+  return 'renewAndRetry';
 }

package/src/client/lib/turnstile.js

@@ -0,0 +1,130 @@
+// Cloudflare Turnstile на регистрации: ленивая загрузка скрипта, один
+// виджет, токен на одну отправку формы. Без сети в тестах: документ, окно и
+// таймеры инъектируются.
+
+// code: 'blocked' — скрипт или виджет недоступны (блокировщик, ошибка
+// виджета); 'expired' — проверка истекла, не дождавшись игрока
+function turnstileError(code) {
+  const error = new Error(`Turnstile ${code}`);
+
+  error.code = code;
+
+  return error;
+}
+
+const blockedError = () => turnstileError('blocked');
+
+/**
+ * @param {Object} options
+ * @param {string} options.scriptUrl
+ * @param {number} options.loadTimeoutMs
+ * @param {string} options.action
+ * @param {Document} [options.doc]
+ * @param {Window} [options.win]
+ * @param {Object} [options.timers] - { setTimeout, clearTimeout } (тесты).
+ */
+export function createTurnstile({
+  scriptUrl,
+  loadTimeoutMs,
+  action,
+  doc = document,
+  win = window,
+  timers = globalThis,
+}) {
+  let widgetId = null;
+  // виджет уже отдавал токен: перед следующим execute нужен reset
+  let used = false;
+  // текущий getToken: виджет создаётся один раз, а его callback'и должны
+  // завершать именно ожидающий вызов, не первый
+  let pending = null;
+
+  // скрипт подгружается при первом обращении; отказ (error, таймаут, нет
+  // win.turnstile после load) убирает элемент — Retry загрузит его заново
+  function loadScript() {
+    if (win.turnstile) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      const script = doc.createElement('script');
+      let timer = null;
+
+      const fail = () => {
+        timers.clearTimeout(timer);
+        script.remove();
+        reject(blockedError());
+      };
+
+      timer = timers.setTimeout(fail, loadTimeoutMs);
+
+      script.addEventListener('load', () => {
+        if (!win.turnstile) {
+          fail();
+          return;
+        }
+
+        timers.clearTimeout(timer);
+        resolve();
+      });
+      script.addEventListener('error', fail);
+
+      script.src = scriptUrl;
+      script.async = true;
+      doc.head.appendChild(script);
+    });
+  }
+
+  return {
+    // токен на одну отправку формы; отказ — Error с полем code = 'blocked'
+    async getToken(container, siteKey) {
+      await loadScript();
+
+      return new Promise((resolve, reject) => {
+        pending = { resolve, reject };
+
+        if (widgetId === null) {
+          widgetId = win.turnstile.render(container, {
+            sitekey: siteKey,
+            action,
+            execution: 'execute',
+            appearance: 'interaction-only',
+            callback: token => {
+              used = true;
+              pending?.resolve(token);
+            },
+            'error-callback': () => {
+              // после ошибки виджету нужен reset перед следующим execute
+              used = true;
+              pending?.reject(blockedError());
+              return true;
+            },
+            // проверка истекла, пока игрок не ответил: без этого getToken
+            // не завершился бы и форма осталась заблокированной
+            'timeout-callback': () => {
+              used = true;
+              pending?.reject(turnstileError('expired'));
+            },
+            'expired-callback': () => {
+              used = true;
+              pending?.reject(turnstileError('expired'));
+            },
+          });
+        } else if (used) {
+          win.turnstile.reset(widgetId);
+          used = false;
+        }
+
+        // срока ожидания нет: интерактивная проверка может ждать клика
+        win.turnstile.execute(container);
+      });
+    },
+
+    // токен израсходован сервером: следующая отправка получит новый
+    reset() {
+      if (widgetId !== null) {
+        win.turnstile.reset(widgetId);
+        used = false;
+      }
+    },
+  };
+}

package/src/client/main.js

@@ -69,6 +69,10 @@ import SessionSupervisor, {
 import FpsMeter from './lib/FpsMeter.js';
 import HostUnloadGuard from './lib/hostUnloadGuard.js';
 import { createPageReload } from './lib/pageReload.js';
+import { createAuthApi } from './lib/authApi.js';
+import { createVerifier, challengeOf } from './lib/pkce.js';
+import { createTurnstile } from './lib/turnstile.js';
+import TokenRenewer from './network/TokenRenewer.js';
 import {
   isKickClose,
   POLICY_CLOSE_INFORMS,
@@ -78,11 +82,14 @@ import LobbyModel from './components/model/Lobby.js';
 import LobbyView from './components/view/Lobby.js';
 import LobbyCtrl from './components/controller/Lobby.js';
 import LobbyAuthModel from './components/model/LobbyAuth.js';
+import ProfileModel from './components/model/Profile.js';
 import LobbyAuthView from './components/view/LobbyAuth.js';
 import LobbyAuthCtrl from './components/controller/LobbyAuth.js';
 import GamesModel from './components/model/Games.js';
 import GamesView from './components/view/Games.js';
 import GamesCtrl from './components/controller/Games.js';
+import ProfileView from './components/view/Profile.js';
+import ProfileCtrl from './components/controller/Profile.js';
 import { createRoomContext } from './session/roomContext.js';
 import { createHostRoomPrep } from './session/hostRoomPrep.js';
 import Membership from './session/Membership.js';
@@ -274,7 +281,6 @@ const PS_FIRST_SHOT_DATA = wsports.server.FIRST_SHOT_DATA;
 const PS_SOUND_DATA = wsports.server.SOUND_DATA;
 const PS_GAME_INFORM_DATA = wsports.server.GAME_INFORM_DATA;
 const PS_TECH_INFORM_DATA = wsports.server.TECH_INFORM_DATA;
-const PS_MISC = wsports.server.MISC;
 const PS_PING = wsports.server.PING;
 const PS_CLEAR = wsports.server.CLEAR;
 const PS_CONSOLE = wsports.server.CONSOLE;
@@ -290,6 +296,7 @@ const PS_RESUME_RESULT = wsports.server.RESUME_RESULT;
 // PC (client ports): порты получения данных от клиента
 const PC_CONFIG_READY = wsports.client.CONFIG_READY;
 const PC_AUTH_RESPONSE = wsports.client.AUTH_RESPONSE;
+const PC_TOKEN_REFRESH = wsports.client.TOKEN_REFRESH;
 const PC_MODULES_READY = wsports.client.MODULES_READY;
 const PC_MAP_READY = wsports.client.MAP_READY;
 const PC_FIRST_SHOT_READY = wsports.client.FIRST_SHOT_READY;
@@ -978,15 +985,6 @@ socketMethods[PS_TECH_INFORM_DATA] = data => {
   }
 };
 
-// misc
-socketMethods[PS_MISC] = data => {
-  const { key, value } = data;
-
-  if (key === 'localstorageNameReplace') {
-    localStorage['userName'] = value;
-  }
-};
-
 // ping
 socketMethods[PS_PING] = pingId => {
   sending(PC_PONG, pingId, false);
@@ -1909,7 +1907,7 @@ const guest = new GuestSession({
   getPromotion: () => promotionFlow,
   getSupervisor,
   getToken,
-  logout: () => lobbyAuthModel.logout(),
+  refreshIdentity: () => lobbyAuthModel.refresh(),
   config: lobbyConfig,
   diagnostics,
   ui: {
@@ -2493,6 +2491,17 @@ function initLobby() {
   clientReportsView.setGames([...gamesById.values()]);
   clientReports.setAdmin(lobbyAuthModel.getRole() === 'admin');
 
+  // панель профиля: привязка аккаунта, выход, выгрузка данных, удаление
+  const profileModel = new ProfileModel(lobbyConfig.profile, {
+    auth: lobbyAuthModel,
+    api: authApi,
+  });
+  const profileView = new ProfileView(profileModel, lobbyConfig.profile);
+  const profile = new ProfileCtrl(profileModel, profileView);
+
+  // выход и удаление меняют личность вкладки — только перезагрузкой
+  profile.publisher.on('left', () => reloadPage());
+
   // «Test»: манифест застейдженной версии кладётся в каталог вкладки, и
   // админ поднимает по нему комнату обычной кнопкой Create server
   games.publisher.on('staged', ({ manifest }) => {
@@ -2595,13 +2604,21 @@ function initLobby() {
   });
 
   lobby.open();
+
+  // вкладка вернулась от провайдера: итог привязки показывает панель
+  const linkResult = profileModel.takeLinkResult();
+
+  if (linkResult) {
+    profile.openWithLinkResult(linkResult);
+  }
 }
 
-// логин лобби (Этап B2): central auth-сервис выдаёт JWT, лобби открывается
-// только после успешной авторизации (глобальный ник вместо свободного ввода
-// в игре). Не зависит от сигнального сокета мастера — читает query string
-// (OAuth-редирект) и localStorage независимо от 'welcome'
+// экран профиля: central auth-сервис выдаёт JWT по сессии устройства, лобби
+// открывается только когда у вкладки есть личность (профиль с глобальным
+// ником). Не зависит от сигнального сокета мастера — читает query string
+// (возврат с OAuth) и localStorage независимо от 'welcome'
 let lobbyAuthModel = null;
+let authApi = null;
 let lobbyAuthView = null;
 
 let welcomeReceived = false;
@@ -2656,13 +2673,32 @@ function leaveRoomWith(message) {
   }
 }
 
-// точка 2 ветвления: лобби, OAuth-гейт и сигналинг живут только в lobby;
+// точка 2 ветвления: лобби, экран профиля и сигналинг живут только в lobby;
 // solo и dedicated идут сразу к транспорту
 if (isLobbyMode) {
-  lobbyAuthModel = new LobbyAuthModel(authClientConfig);
+  authApi = createAuthApi({ serviceUrl: authClientConfig.serviceUrl });
+
+  lobbyAuthModel = new LobbyAuthModel(authClientConfig, {
+    api: authApi,
+    pkce: { createVerifier, challengeOf },
+    isDev: isDevBuild,
+  });
   lobbyAuthView = new LobbyAuthView(lobbyAuthModel, authClientConfig);
 
-  const lobbyAuthCtrl = new LobbyAuthCtrl(lobbyAuthModel, lobbyAuthView);
+  // контроллер подписывается на вид сам
+  new LobbyAuthCtrl(lobbyAuthModel, lobbyAuthView, {
+    turnstile: createTurnstile(authClientConfig.turnstile),
+  });
+
+  // тихое продление identity-токена: вкладка остаётся в аккаунте, пока жива
+  // сессия устройства
+  const tokenRenewer = new TokenRenewer({
+    getExpiresAt: getTokenExpiresAt,
+    renew: () => lobbyAuthModel.refresh(),
+    onLost: () => {},
+    leadMs: authClientConfig.renew.leadMs,
+    retryMs: authClientConfig.renew.retryMs,
+  });
 
   signaling.publisher.on('welcome', () => {
     welcomeReceived = true;
@@ -2695,16 +2731,43 @@ if (isLobbyMode) {
       handoff.armTokenHandoff();
     }
 
-    // повторный вход после logout: маршрут уже разобран, а логин-гейт
-    // спрятал лобби — вернуть его, если вкладка не в комнате
-    if (route.booted && !roomCtx.entered) {
-      lobby?.open();
+    tokenRenewer.arm();
+  });
+
+  // свежий токен — мастеру (следующим сообщением сигналинга), хосту (порт
+  // TOKEN_REFRESH) и таймерам роли хоста
+  lobbyAuthModel.publisher.on('token-renewed', () => {
+    tokenRenewer.arm();
+    membership.armTokenCapsTimer();
+    // вкладка в комнате возвращает мастеру canHost по новому сроку
+    membership.sendUpdate();
+
+    if (hostRole.controller) {
+      handoff.armTokenHandoff();
+    }
+
+    if (sessionStarted && supervisor) {
+      sending(PC_TOKEN_REFRESH, { token: getToken() });
     }
   });
 
-  // OAuth-возврат: токены из query прочитаны — чистим только query, hash
+  // личность вкладки меняется только перезагрузкой страницы; из комнаты в
+  // лобби ведёт тоже только reloadPage(), поэтому в матче Welcome с
+  // уведомлением покажет следующая загрузка
+  lobbyAuthModel.publisher.on('session-lost', () => {
+    lobbyAuthModel.setNotice('profileGone');
+
+    if (!roomCtx.roomId) {
+      reloadPage();
+      return;
+    }
+
+    diagnostics.warn('engine.session.profileGone', {}, { source: 'client' });
+  });
+
+  // возврат с OAuth и dev-сессия прочитаны — чистим только query, hash
   // (маршрут #/<gameId>[/<roomId>]) остаётся
-  if (lobbyAuthCtrl.init(window.location.search)) {
+  if (lobbyAuthModel.takeUrlParams(window.location.search)) {
     window.history.replaceState(
       null,
       '',
@@ -2712,6 +2775,8 @@ if (isLobbyMode) {
     );
   }
 
+  lobbyAuthModel.boot();
+
   window.addEventListener('hashchange', () => route.handleHashChange());
 
   signaling.connect();

package/src/client/network/TokenRenewer.js

@@ -0,0 +1,90 @@
+// Тихое продление identity-токена: за leadMs до exp запрашивает свежий у
+// сессии устройства. Сбой сети — повтор через retryMs без ограничения числа
+// попыток: сеть вернётся — токен продлится.
+//
+// Без DOM: срок, продление и таймеры инъектирует владелец (client/main.js).
+
+export default class TokenRenewer {
+  /**
+   * @param {Object} options
+   * @param {Function} options.getExpiresAt - () → мс эпохи | null.
+   * @param {Function} options.renew - () → Promise<'ok' | 'retry' | 'lost'>.
+   * @param {Function} options.onLost - сессия потеряна, продлевать нечем.
+   * @param {number} options.leadMs
+   * @param {number} options.retryMs
+   * @param {Function} [options.now]
+   * @param {Object} [options.timers] - { setTimeout, clearTimeout } (тесты).
+   */
+  constructor({
+    getExpiresAt,
+    renew,
+    onLost,
+    leadMs,
+    retryMs,
+    now = () => Date.now(),
+    timers = globalThis,
+  }) {
+    this._getExpiresAt = getExpiresAt;
+    this._renew = renew;
+    this._onLost = onLost;
+    this._leadMs = leadMs;
+    this._retryMs = retryMs;
+    this._now = now;
+    this._timers = timers;
+    this._timer = null;
+  }
+
+  // таймер на expiresAt - leadMs, но не раньше «сейчас»; срок неизвестен —
+  // таймера нет. Повторный arm заменяет прежний таймер
+  arm() {
+    this._schedule(this._delayToLead());
+  }
+
+  cancel() {
+    if (this._timer !== null) {
+      this._timers.clearTimeout(this._timer);
+      this._timer = null;
+    }
+  }
+
+  _delayToLead() {
+    const expiresAt = this._getExpiresAt();
+
+    if (expiresAt === null) {
+      return null;
+    }
+
+    return Math.max(0, expiresAt - this._leadMs - this._now());
+  }
+
+  _schedule(delay) {
+    this.cancel();
+
+    if (delay === null) {
+      return;
+    }
+
+    this._timer = this._timers.setTimeout(() => this._fire(), delay);
+  }
+
+  async _fire() {
+    this._timer = null;
+
+    let result;
+
+    try {
+      result = await this._renew();
+    } catch {
+      // неожиданный сбой не должен обрывать цепочку продления
+      result = 'retry';
+    }
+
+    if (result === 'ok') {
+      this.arm();
+    } else if (result === 'retry') {
+      this._schedule(this._retryMs);
+    } else {
+      this._onLost();
+    }
+  }
+}