@linxiraos/pi-stats 1.1.26 → 1.2.0

package/src/server.ts

@@ -14,9 +14,12 @@ import {
 	getRecentErrors,
 	getRecentRequests,
 	getRequestDetails,
+	getTimeRangeConfig,
 	getToolDashboardStats,
 } from "./aggregator";
-import { decodeEmbeddedClientArchive } from "./embedded-client";
+import { initDb } from "./db";
+import { decodeEmbeddedClientArchive, hasEmbeddedClientArchive } from "./embedded-client";
+import { resolveLocaleTag, type StatsLocale } from "./locale";
 import embeddedClientArchiveTxt from "./embedded-client.generated.txt";
 import {
 	cancelFrustrationRun,
@@ -36,18 +39,17 @@ import {
 	STATS_DASHBOARD_HOSTNAME_HEADER,
 	STATS_DASHBOARD_SECURITY_VERSION,
 } from "./port-conflict";
-import type { LiveStatus } from "./shared-types";
+import { getStatsByModel, getTimeSeries } from "./rollup";
 import {
 	buildSessionTrace,
 	getTraceEntry,
 	listSessionSummaries,
 	TRACE_ETAG_VERSION,
+	type TraceFingerprint,
 	traceFingerprintForEtag,
 	TracePathError,
 } from "./trace";
 
-const EMBEDDED_CLIENT_ARCHIVE = decodeEmbeddedClientArchive(embeddedClientArchiveTxt);
-
 const CLIENT_DIR = path.join(import.meta.dir, "client");
 const STATIC_DIR = path.join(import.meta.dir, "..", "dist", "client");
 const IS_BUN_COMPILED =
@@ -60,21 +62,27 @@ const IS_BUN_COMPILED =
 // dashboard sources or prebuilt dist/client next to the bundle, so the
 // embedded archive is the only viable asset source.
 const IS_PREBUILT = IS_BUN_COMPILED || Boolean(process.env.PI_BUNDLED || Bun.env.PI_BUNDLED);
-const USE_EMBEDDED_CLIENT = EMBEDDED_CLIENT_ARCHIVE !== null || IS_PREBUILT;
+// Sniff the base64 gzip magic instead of decoding: importing this module (every
+// TUI start) must not pay for a multi-megabyte archive nobody may serve.
+const USE_EMBEDDED_CLIENT = hasEmbeddedClientArchive(embeddedClientArchiveTxt) || IS_PREBUILT;
+
+/** Host UI language for the served shell; `startServer` sets it from `StartServerOptions.language`. */
+let dashboardLocale: StatsLocale = "en";
 
 let embeddedClientFilesPromise: Promise<Map<string, Blob>> | null = null;
 
 async function getEmbeddedClientFiles(): Promise<Map<string, Blob>> {
 	if (embeddedClientFilesPromise) return embeddedClientFilesPromise;
 
-	if (!EMBEDDED_CLIENT_ARCHIVE) {
+	const archive = decodeEmbeddedClientArchive(embeddedClientArchiveTxt);
+	if (!archive) {
 		throw new Error(
 			"Embedded stats client bundle missing. Rebuild the zeta binary or npm bundle with embedded stats assets.",
 		);
 	}
 
 	// Keep bundled assets in memory so OS temporary-file cleanup cannot break a live dashboard.
-	embeddedClientFilesPromise = new Bun.Archive(EMBEDDED_CLIENT_ARCHIVE).files().then(files => {
+	embeddedClientFilesPromise = new Bun.Archive(archive).files().then(files => {
 		for (const [name, file] of files) {
 			// Archive entries are untyped blobs; infer MIME types just as disk-backed Bun files do.
 			files.set(name, new File([file], name, { type: Bun.file(name).type }));
@@ -241,8 +249,9 @@ export async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/stats/models") {
-		const stats = await getDashboardStats(range);
-		return Response.json(stats.byModel);
+		// Also the port-conflict identity probe: keep it to the one query it serves.
+		await initDb();
+		return Response.json(getStatsByModel(getTimeRangeConfig(range).cutoff));
 	}
 
 	if (path === "/api/stats/folders") {
@@ -251,8 +260,8 @@ export async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/stats/timeseries") {
-		const stats = await getDashboardStats(range);
-		return Response.json(stats.timeSeries);
+		await initDb();
+		return Response.json(getTimeSeries(getTimeRangeConfig(range)));
 	}
 
 	if (path.startsWith("/api/request/")) {
@@ -293,14 +302,15 @@ export async function handleApi(req: Request): Promise<Response> {
 			// The fingerprint covers child transcripts, so a subagent-only
 			// append changes the ETag and never 304s stale.
 			const clientEtag = req.headers.get("if-none-match");
+			let fingerprint: TraceFingerprint | undefined;
 			if (clientEtag) {
-				const fingerprint = await traceFingerprintForEtag(file);
+				fingerprint = await traceFingerprintForEtag(file);
 				if (fingerprint !== undefined) {
-					const etag = `"${TRACE_ETAG_VERSION}:${fingerprint}"`;
+					const etag = `"${TRACE_ETAG_VERSION}:${fingerprint.rootMtimeMs}:${fingerprint.childFingerprint}"`;
 					if (clientEtag === etag) return new Response(null, { status: 304 });
 				}
 			}
-			const trace = await buildSessionTrace(file);
+			const trace = await buildSessionTrace(file, fingerprint);
 			const etag = `"${TRACE_ETAG_VERSION}:${trace.etag}"`;
 			if (clientEtag === etag) return new Response(null, { status: 304 });
 			return Response.json(trace, { headers: { ETag: etag } });
@@ -332,10 +342,12 @@ export async function handleApi(req: Request): Promise<Response> {
  * Handle static file requests.
  */
 async function handleStatic(requestPath: string): Promise<Response> {
+	const wantsIndex = requestPath === "/" || requestPath.endsWith("index.html");
 	if (USE_EMBEDDED_CLIENT) {
 		const files = await getEmbeddedClientFiles();
 		const file = files.get(requestPath.slice(1)) ?? files.get("index.html");
-		return file ? new Response(file) : new Response("Not Found", { status: 404 });
+		if (!file) return new Response("Not Found", { status: 404 });
+		return wantsIndex ? shellResponse(await file.text()) : new Response(file);
 	}
 
 	const filePath = requestPath === "/" ? "/index.html" : requestPath;
@@ -343,18 +355,31 @@ async function handleStatic(requestPath: string): Promise<Response> {
 
 	const file = Bun.file(fullPath);
 	if (await file.exists()) {
-		return new Response(file);
+		return filePath.endsWith("index.html") ? shellResponse(await file.text()) : new Response(file);
 	}
 
 	// SPA fallback
 	const index = Bun.file(path.join(STATIC_DIR, "index.html"));
 	if (await index.exists()) {
-		return new Response(index);
+		return shellResponse(await index.text());
 	}
 
 	return new Response("Not Found", { status: 404 });
 }
 
+/**
+ * The shell HTML with the host's language stamped in — `<html lang>` plus an
+ * inline global the client reads at boot (`resolveInitialLocale`), the same
+ * pre-paint pattern the persisted theme uses.
+ */
+function shellResponse(html: string): Response {
+	const locale = dashboardLocale;
+	const stamped = html
+		.replace(/<html lang="[^"]*"/, `<html lang="${locale}"`)
+		.replace("</head>", `<script>window.__ZETA_STATS_LOCALE__=${JSON.stringify(locale)}</script></head>`);
+	return new Response(stamped, { headers: { "content-type": "text/html; charset=utf-8" } });
+}
+
 /** Format a dashboard origin, including brackets required by IPv6 literals. */
 export function formatStatsDashboardUrl(hostname: string, port: number): string {
 	const urlHostname = hostname.includes(":") && !hostname.startsWith("[") ? `[${hostname}]` : hostname;
@@ -383,7 +408,7 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 			if (path === "/api/events") {
 				// Long-lived stream: exempt from the idle timeout.
 				server.timeout(req, 0);
-				return liveEventStream(dashboardHeaders);
+				return liveEventStream(dashboardHeaders, req.signal);
 			}
 
 			try {
@@ -423,8 +448,9 @@ const EVENT_HEARTBEAT_MS = 15_000;
 /**
  * Server-sent events of {@link LiveStatus}: the current status immediately,
  * then every change (sync progress, data version bumps, indexing backlog).
+ * Disconnects unsubscribe, so ingest winds down once no page is listening.
  */
-function liveEventStream(headers: Record<string, string>): Response {
+function liveEventStream(headers: Record<string, string>, signal: AbortSignal): Response {
 	const live = statsLive();
 	// Ingest starts when the first page connects, not when the server binds.
 	live.start();
@@ -432,19 +458,26 @@ function liveEventStream(headers: Record<string, string>): Response {
 	let cleanup = () => {};
 	const stream = new ReadableStream<Uint8Array>({
 		start(controller) {
-			const send = (status: LiveStatus) => {
-				controller.enqueue(encoder.encode(`data: ${JSON.stringify(status)}\n\n`));
+			const write = (chunk: string) => {
+				try {
+					controller.enqueue(encoder.encode(chunk));
+				} catch {
+					// Stream already closed: the client left without a cancel.
+					cleanup();
+				}
 			};
-			send(live.status());
-			const unsubscribe = live.subscribe(send);
-			const heartbeat = setInterval(
-				() => controller.enqueue(encoder.encode(": keep-alive\n\n")),
-				EVENT_HEARTBEAT_MS,
-			);
+			write(`data: ${JSON.stringify(live.status())}\n\n`);
+			const unsubscribe = live.subscribe((_status, frame) => write(`data: ${frame}\n\n`));
+			const heartbeat = setInterval(() => write(": keep-alive\n\n"), EVENT_HEARTBEAT_MS);
+			const onAbort = () => cleanup();
 			cleanup = () => {
+				cleanup = () => {};
 				unsubscribe();
 				clearInterval(heartbeat);
+				signal.removeEventListener("abort", onAbort);
 			};
+			if (signal.aborted) cleanup();
+			else signal.addEventListener("abort", onAbort, { once: true });
 		},
 		cancel() {
 			cleanup();
@@ -480,6 +513,12 @@ let liveServers = 0;
 export interface StartServerOptions {
 	/** Host judge for the Frustration dashboard's judge runs; replaces any previously registered one. */
 	judge?: StatsJudgeProvider;
+	/**
+	 * Host UI language (`zh`, `zh-CN`, `en`, …). Stamped into the served page so
+	 * the dashboard renders in the same language as the CLI that launched it;
+	 * anything unrecognized resolves to English.
+	 */
+	language?: string;
 }
 
 export async function startServer(
@@ -488,6 +527,7 @@ export async function startServer(
 	options: StartServerOptions = {},
 ): Promise<StatsServerHandle> {
 	if (options.judge) setStatsJudgeProvider(options.judge);
+	dashboardLocale = resolveLocaleTag(options.language);
 	const activeKey = `${hostname}:${port}`;
 	if (port !== 0) {
 		const active = activeServers.get(activeKey);

package/src/shared-types.ts

@@ -203,6 +203,13 @@ export interface FrustrationCounts {
 	messages: number;
 	/** Messages whose prose has a cached judge verdict; the rest use regex fallback. */
 	judged: number;
+	/**
+	 * Unjudged messages whose prose is written in a script no lexicon covers
+	 * (Kana, Hangul, Cyrillic, …). Their regex counts are zeros because there is
+	 * no lexicon, not because the user was calm - the dashboard says so instead
+	 * of folding them into "not annoyed", and the judge is the fix for them.
+	 */
+	unscored: number;
 	/** Annoyed at anything (the assistant, tooling, other people, ...). */
 	annoyed: number;
 	/** Annoyed and aimed at the assistant. Subset of `annoyed`. */

package/src/trace.ts

@@ -750,11 +750,6 @@ async function buildTrackTree(
 // ---------------------------------------------------------------------------
 // Public surface
 
-/**
- * Assemble the full span tree for one root session transcript.
- * Throws {@link TracePathError} for paths outside the sessions root; ENOENT
- * passes through for the caller's 404 mapping.
- */
 // Single-entry memo: the dashboard polls one open trace every 15s. Keyed on
 // the root file's mtime PLUS a fingerprint of the child-transcript SET under
 // the root's artifacts tree (one cheap readdir+stat walk, no parse). A
@@ -788,35 +783,46 @@ async function childTranscriptsFingerprint(rootFile: string, depth = 0): Promise
 		return "";
 	}
 	names.sort();
+	const dir = transcriptStem(rootFile);
 	const transcriptNames = names.filter(name => name.endsWith(".jsonl") || name.endsWith(".jsonl.gz"));
-	const parts: string[] = [`n=${transcriptNames.length}`];
-	for (const name of transcriptNames) {
-		const childFile = path.join(transcriptStem(rootFile), name);
-		try {
-			const stat = await fs.stat(childFile);
-			parts.push(`${name}@${stat.mtimeMs}`);
-			// Recurse like the builder (nested subagents), without parsing.
-			const nested = await childTranscriptsFingerprint(childFile, depth + 1);
-			if (nested) parts.push(`${name}/{${nested}}`);
-		} catch {
-			parts.push(`${name}@gone`);
-		}
-	}
-	return parts.join(",");
+	const childParts = await Promise.all(
+		transcriptNames.map(async name => {
+			const childFile = path.join(dir, name);
+			try {
+				const stat = await fs.stat(childFile);
+				// Recurse like the builder (nested subagents), without parsing.
+				const nested = await childTranscriptsFingerprint(childFile, depth + 1);
+				return nested ? `${name}@${stat.mtimeMs},${name}/{${nested}}` : `${name}@${stat.mtimeMs}`;
+			} catch {
+				return `${name}@gone`;
+			}
+		}),
+	);
+	return [`n=${transcriptNames.length}`, ...childParts].join(",");
+}
+
+/** Freshness of a root trace: root mtime plus the child-transcript set fingerprint. */
+export interface TraceFingerprint {
+	rootMtimeMs: number;
+	childFingerprint: string;
+}
+
+/** Stat the root and walk its child transcripts (readdir+stat, no parse). */
+async function readTraceFingerprint(resolved: string): Promise<TraceFingerprint> {
+	const rootMtimeMs = (await fs.stat(resolved)).mtimeMs;
+	const childFingerprint = await childTranscriptsFingerprint(resolved);
+	return { rootMtimeMs, childFingerprint };
 }
 
 /**
- * Freshness fingerprint for the trace ETag pre-check: root mtime plus the
- * child-transcript set fingerprint (readdir+stat walk, no parse). Returns
- * undefined when the path is rejected or missing (the caller falls through
- * to the full build, which maps those to 400/404).
+ * Freshness fingerprint for the trace ETag pre-check; `SessionTrace.etag` is
+ * `${rootMtimeMs}:${childFingerprint}` for an unraced build. Returns undefined
+ * when the path is rejected or missing (the caller falls through to the full
+ * build, which maps those to 400/404).
  */
-export async function traceFingerprintForEtag(fileParam: string): Promise<string | undefined> {
+export async function traceFingerprintForEtag(fileParam: string): Promise<TraceFingerprint | undefined> {
 	try {
-		const resolved = resolveSessionPath(fileParam);
-		const rootMs = (await fs.stat(resolved)).mtimeMs;
-		const childFp = await childTranscriptsFingerprint(resolved);
-		return `${rootMs}:${childFp}`;
+		return await readTraceFingerprint(resolveSessionPath(fileParam));
 	} catch {
 		return undefined;
 	}
@@ -827,16 +833,22 @@ export function traceMemoForTests(): { file: string; mtimeMs: number } | undefin
 	return { file: traceMemo.file, mtimeMs: traceMemo.entry.mtimeMs };
 }
 
-export async function buildSessionTrace(fileParam: string): Promise<SessionTrace> {
+/**
+ * Assemble the full span tree for one root session transcript.
+ * Throws {@link TracePathError} for paths outside the sessions root; ENOENT
+ * passes through for the caller's 404 mapping. `fingerprint` may carry the
+ * {@link traceFingerprintForEtag} value the caller just computed for the same
+ * file (its ETag pre-check), sparing a second walk.
+ */
+export async function buildSessionTrace(fileParam: string, fingerprint?: TraceFingerprint): Promise<SessionTrace> {
 	const resolved = resolveSessionPath(fileParam);
-	const rootStat = await fs.stat(resolved);
 	const memo = traceMemo?.file === resolved ? traceMemo.entry : undefined;
 	// Pre-build child fingerprint on EVERY path (hit check and rebuild
 	// alike): the post-build race guard compares against this, so a child
 	// append landing mid-parse is detected even on first builds and
 	// memo-less rebuilds, where no prior fingerprint exists to compare.
-	const preChildFingerprint = await childTranscriptsFingerprint(resolved);
-	if (memo && memo.mtimeMs === rootStat.mtimeMs) {
+	const { rootMtimeMs, childFingerprint: preChildFingerprint } = fingerprint ?? (await readTraceFingerprint(resolved));
+	if (memo && memo.mtimeMs === rootMtimeMs) {
 		// Equality, not <=: a LOWER mark (delete/older-mtime replace) is
 		// also stale — only an identical child set may reuse the trace.
 		if (preChildFingerprint === memo.childFingerprint) return memo.trace;
@@ -901,7 +913,7 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 		else if (span.kind === "turn") turns++;
 	}
 
-	const start = startedAt ?? rootScan.headerTs ?? rootStat.mtimeMs;
+	const start = startedAt ?? rootScan.headerTs ?? rootMtimeMs;
 	const end = endedAt ?? start;
 	const wallMs = end - start;
 
@@ -925,7 +937,7 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 	// neither the trace nor the key.
 	const childFingerprint = await childTranscriptsFingerprint(resolved);
 	// Root rewritten mid-build: same no-cache rule as the child race below.
-	const rootChanged = (await fs.stat(resolved).catch(() => null))?.mtimeMs !== rootStat.mtimeMs;
+	const rootChanged = (await fs.stat(resolved).catch(() => null))?.mtimeMs !== rootMtimeMs;
 	const raced = childFingerprint !== preChildFingerprint;
 	// Raced builds keep the PRE-build fingerprint as their ETag: the parsed
 	// bytes predate the racy write, so claiming the post-write state would
@@ -941,15 +953,15 @@ export async function buildSessionTrace(fileParam: string): Promise<SessionTrace
 		cwd: rootScan.cwd,
 		startedAt: start,
 		endedAt: end,
-		mtimeMs: rootStat.mtimeMs,
-		etag: `${rootStat.mtimeMs}:${etagFingerprint}`,
+		mtimeMs: rootMtimeMs,
+		etag: `${rootMtimeMs}:${etagFingerprint}`,
 		tracks,
 		summary,
 	};
 	if (!raced && !rootChanged) {
 		traceMemo = {
 			file: resolved,
-			entry: { mtimeMs: rootStat.mtimeMs, childFingerprint, trace },
+			entry: { mtimeMs: rootMtimeMs, childFingerprint, trace },
 		};
 	}
 	return trace;
@@ -1068,7 +1080,8 @@ function basenameTimestamp(base: string): number | undefined {
 // Short-TTL memo for the disk sweep behind /api/sessions (30s poll): the
 // session list changes only on create/edit, so readdir+stat of every file per
 // poll is pure syscall churn. TTL is deliberately short so a just-created
-// session appears within seconds.
+// session appears within seconds. Only the newest `limit` roots are kept, so
+// the memo stays small however many sessions exist.
 let diskRootsMemo:
 	| {
 			atMs: number;
@@ -1117,8 +1130,9 @@ async function scanDiskRoots(limit: number): Promise<Array<{ file: string; mtime
 		}),
 	);
 	roots.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	if (roots.length <= 1000) diskRootsMemo = { atMs: Date.now(), sessionsDir, limit, roots };
-	return roots.slice(0, limit);
+	const newest = roots.slice(0, limit);
+	diskRootsMemo = { atMs: Date.now(), sessionsDir, limit, roots: newest };
+	return newest.slice();
 }
 
 /**

package/src/types.ts

@@ -35,6 +35,14 @@ export interface MessageStats {
 	usage: Usage;
 	/** Which agent produced this message (main agent, task subagent, advisor) */
 	agentType: AgentType;
+	/**
+	 * Service tier the provider reported serving this turn, or `null` when the
+	 * provider reported none. Lets consumers separate a fast serving path's
+	 * throughput and premium traffic from standard-tier traffic. Always written by
+	 * `rowToMessageStats`; optional only because session fixtures that stand in
+	 * for ingest input are typed as `MessageStats` too.
+	 */
+	serviceTier?: ServiceTier | null;
 	/**
 	 * Ingest refused to price this request: a scheduled (time-based) card with no
 	 * recoverable request timestamp, so `usage.cost.total` of 0 is unknown spend
@@ -63,7 +71,7 @@ export interface MessageStatsInput extends Omit<MessageStats, "usage" | "costUnp
 export interface RequestDetails extends MessageStats {
 	/** The full conversation history or just the last turn. */
 	messages: unknown[];
-	/** The model's response. */
+	/** The model's response; `null` for `model_usage` entries, which journal no payload. */
 	output: unknown;
 }
 
@@ -175,6 +183,10 @@ export interface UserMessageStats {
 	repetition: number;
 	/** Second-person reproach ("you didnt", "why did you", "stop X-ing") */
 	blame: number;
+	/** Emphatic CJK/voice markers the caps-based yelling cannot see (see `UserMessageMetrics.emphasis`). */
+	emphasis: number;
+	/** 1 when the prose leans on a script no lexicon covers; such rows are unscored, not calm. */
+	unsupportedScript: number;
 	/** Judge-facing prose (see `judgeProse`); empty when the message was all markup. */
 	prose: string;
 	/** Hex `Bun.hash` of `prose`, keying the shared verdict cache; empty when `prose` is. */