import { DEFAULT_LOG_DATA_LIMITS, type LogDataLimits } from '../ui/LogOutput/logText'; /** Public client configuration served by the server at /manifest.json. */ export interface Manifest { name: string; /** Server version; can differ from the client build's __APP_VERSION__ until the page is reloaded. */ version: string; runLogs: { dataLimits: LogDataLimits; }; auth: { enabled: boolean; }; } export const DEFAULT_MANIFEST: Manifest = { name: 'liqa', version: __APP_VERSION__, runLogs: { dataLimits: DEFAULT_LOG_DATA_LIMITS }, auth: { enabled: false }, }; const STORAGE_KEY = 'liqa-manifest'; /** A tab coming back into view refetches the manifest if it is older than this. */ const REFRESH_AFTER_MS = 5 * 60 * 1000; // Served next to the API's /api/v1 (so "/manifest.json" by default, or on // VITE_API_URL's origin when the client talks to another server) const MANIFEST_URL = new URL( '../../manifest.json', new URL( `${(import.meta.env.VITE_API_URL ?? '/api/v1').replace(/\/$/, '')}/`, window.location.href, ), ).toString(); /** Fills fields missing from `raw` (e.g. a manifest cached by an older version) with defaults. */ function normalize(raw: unknown): Manifest | null { if (typeof raw !== 'object' || raw === null) return null; const m = raw as Partial; const limits: Partial = m.runLogs?.dataLimits ?? {}; const num = (v: unknown, fallback: number) => (typeof v === 'number' && v >= 0 ? v : fallback); return { name: typeof m.name === 'string' ? m.name : DEFAULT_MANIFEST.name, version: typeof m.version === 'string' ? m.version : DEFAULT_MANIFEST.version, auth: { enabled: m.auth?.enabled === true }, runLogs: { dataLimits: { bytes: num(limits.bytes, DEFAULT_LOG_DATA_LIMITS.bytes), lines: num(limits.lines, DEFAULT_LOG_DATA_LIMITS.lines), }, }, }; } // Storage can be unavailable (private mode, blocked site data): the manifest // then just comes from the network on every page load function readCache(): Manifest | null { try { const stored = localStorage.getItem(STORAGE_KEY); return stored ? normalize(JSON.parse(stored)) : null; } catch { return null; } } function writeCache(manifest: Manifest) { try { localStorage.setItem(STORAGE_KEY, JSON.stringify(manifest)); } catch { // ignore, see readCache } } let current: Manifest = readCache() ?? DEFAULT_MANIFEST; let fetchedAt = 0; let inFlight: Promise | null = null; const listeners = new Set<() => void>(); /** * Fetches the manifest and notifies subscribers if it changed. Failures are * silent: the cached (or default) manifest stays in use. */ export function refreshManifest(): Promise { inFlight ??= fetch(MANIFEST_URL, { headers: { Accept: 'application/json' }, credentials: 'include', }) .then((res) => (res.ok ? res.json() : null)) .then((raw: unknown) => { const next = normalize(raw); if (!next) return; fetchedAt = Date.now(); writeCache(next); if (JSON.stringify(next) !== JSON.stringify(current)) { current = next; listeners.forEach((l) => l()); } }) .catch(() => undefined) .finally(() => { inFlight = null; }); return inFlight; } function onVisibilityChange() { if (document.visibilityState === 'visible' && Date.now() - fetchedAt > REFRESH_AFTER_MS) { void refreshManifest(); } } /** * Stale-while-revalidate: subscribers get the localStorage copy right away, * and the manifest is refetched once per page load (the server answers 304 * while it is unchanged) and when the tab becomes visible again after a while. */ export function subscribeManifest(listener: () => void): () => void { if (listeners.size === 0) document.addEventListener('visibilitychange', onVisibilityChange); listeners.add(listener); if (fetchedAt === 0) void refreshManifest(); return () => { listeners.delete(listener); if (listeners.size === 0) document.removeEventListener('visibilitychange', onVisibilityChange); }; } export function getManifest(): Manifest { return current; }