Files
liqa/client/src/lib/manifest.ts
T
agent 92141a25fb feat(client): add cookie-backed authentication UI
- Add session-aware login, logout and protected navigation.
- Send cookie credentials for API and run-event requests with localized UI stories.
2026-11-05 04:18:11 -05:00

131 lines
4.1 KiB
TypeScript

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<Manifest>;
const limits: Partial<LogDataLimits> = 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<void> | 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<void> {
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;
}