pi-mega-compact 0.8.21 → 0.8.23

package/extensions/dashboard-server/routes-repo.ts

@@ -0,0 +1,212 @@
+/**
+ * dashboard-server/routes-repo.ts — Repo-index and static route handlers.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { readSnapshot } from "./snapshot.js";
+import { dashboardHtml } from "./html.js";
+import { readIndex, getIndexDir } from "./index-reader.js";
+import { ACTIVE_WINDOW_SEC } from "./types.js";
+import type { RouteContext } from "./routes-core.js";
+import type { LiveSnapshot } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// handleIndex — "/" | "/index.html" | "/api/snapshot" | "/api/version"
+// ---------------------------------------------------------------------------
+
+export function handleIndex(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const { snapshotPath, SERVER_VERSION, serveClientAsset } = ctx;
+
+	if (req.url === "/" || req.url === "/index.html") {
+		// Sprint B1: prefer the React client build when present; fall back to the
+		// legacy inline html.ts template when the client dist is absent.
+		if (serveClientAsset("/", res)) return true;
+		const tier = readSnapshot(snapshotPath).tier;
+		res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+		res.end(dashboardHtml(tier));
+		return true;
+	}
+
+	if (req.url === "/api/snapshot") {
+		const snap = readSnapshot(snapshotPath);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(snap));
+		return true;
+	}
+
+	// Server version — lets the /dashboard launcher detect a stale server from
+	// an older build and replace it on upgrade rather than reuse it.
+	if (req.url === "/api/version") {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ version: SERVER_VERSION }));
+		return true;
+	}
+
+	return false;
+}
+
+// ---------------------------------------------------------------------------
+// handleRepoIndex — "/api/index" | "/api/repos" | "/api/summary" | "/api/drift" | "/api/servers"
+// ---------------------------------------------------------------------------
+
+export function handleRepoIndex(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const { overlayCurrentRepo, detectCrossRepoDrift } = ctx;
+
+	if (req.url === "/api/index") {
+		const idx = readIndex();
+		if (idx) overlayCurrentRepo(idx);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify(idx ?? { updatedAt: null, summary: null, repos: [] }),
+		);
+		return true;
+	}
+
+	// /api/repos — registry list. Optional `?active=24h` filters to repos
+	// seen within the last N hours (default: all). The dashboard uses this to
+	// drive its "active vs archived" badge without refetching /api/index.
+	if (req.url?.startsWith("/api/repos")) {
+		const url = new URL(req.url, "http://x"); // guardrails-allow PREVENT-PI-004: localhost dashboard URL base (loopback-only)
+		const activeParam = url.searchParams.get("active");
+		const idx = readIndex();
+		if (idx) overlayCurrentRepo(idx);
+		let repos = idx?.repos ?? [];
+		if (activeParam) {
+			const m = /^(\d+)h$/.exec(activeParam);
+			if (m) {
+				const cutoffSec = Math.floor(Date.now() / 1000) - Number(m[1]) * 3600;
+				repos = repos.filter((r) => (r.lastSeen ?? 0) >= cutoffSec);
+			}
+		}
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({
+				updatedAt: idx?.updatedAt ?? null,
+				repos,
+				count: repos.length,
+			}),
+		);
+		return true;
+	}
+
+	// /api/summary — header tiles without the full repo list (keeps payload
+	// small for embed scenarios). activeRepos mirrors the /api/repos?active=24h
+	// count so the dashboard can render the active badge alongside totals.
+	if (req.url?.startsWith("/api/summary")) {
+		const idx = readIndex();
+		if (idx) overlayCurrentRepo(idx);
+		const repos = idx?.repos ?? [];
+		const cutoffSec = Math.floor(Date.now() / 1000) - 24 * 3600;
+		const activeRepos = repos.filter(
+			(r) => (r.lastSeen ?? 0) >= cutoffSec,
+		).length;
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({
+				updatedAt: idx?.updatedAt ?? null,
+				summary: idx?.summary ?? null,
+				activeRepos,
+				totalRepos: repos.length,
+			}),
+		);
+		return true;
+	}
+
+	// /api/drift — R4: cross-repo drift report over repo_registry. Flags stale
+	// repos (>30d idle), compaction lag (active but >24h since last
+	// compaction), and recent model churn. Read-only.
+	if (req.url?.startsWith("/api/drift")) {
+		const report = detectCrossRepoDrift(getIndexDir());
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(report));
+		return true;
+	}
+
+	if (req.url === "/api/servers") {
+		try {
+			const idx = readIndex();
+			const nowSec = Math.floor(Date.now() / 1000);
+			const servers = (idx?.repos ?? [])
+				.filter((r) => (r.lastSeen ?? 0) >= nowSec - ACTIVE_WINDOW_SEC)
+				.map((r) => {
+					const out: Record<string, unknown> = {
+						repoRoot: r.repoRoot,
+						displayName: r.displayName,
+						model: r.modelName,
+						provider: r.providerName,
+						lastSeen: r.lastSeen,
+						lastCompactedAt: r.lastCompactedAt,
+					};
+					try {
+						const p = join(r.stateDir, "dashboard.json");
+						if (existsSync(p)) {
+							const snap = JSON.parse(
+								readFileSync(p, "utf-8"),
+							) as LiveSnapshot;
+							out.tier = snap.tier ?? null;
+							out.contextPct =
+								snap.context && snap.context.percent != null
+									? snap.context.percent
+									: null;
+							out.state = (snap.session && snap.session.state) || null;
+							out.cacheHits = snap.cacheHits ?? null;
+							out.compacts = snap.compacts ?? null;
+							out.timeSaved = snap.timeSaved ?? null;
+							out.updatedAt = snap.updatedAt ?? null;
+						}
+					} catch {
+						/* best-effort */
+					}
+					return out;
+				})
+				.sort((a, b) => (b.lastSeen as number) - (a.lastSeen as number));
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({ updatedAt: new Date().toISOString(), servers }),
+			);
+		} catch {
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "servers_unavailable" }));
+		}
+		return true;
+	}
+
+	return false;
+}
+
+// ---------------------------------------------------------------------------
+// handleStatic — non-/api/* GET fallback (SPA client build or legacy HTML).
+// ---------------------------------------------------------------------------
+
+export function handleStatic(
+	req: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	const { snapshotPath, serveClientAsset } = _ctx;
+
+	if (
+		req.method === "GET" &&
+		req.url &&
+		!req.url.startsWith("/api/") &&
+		serveClientAsset(req.url, res)
+	) {
+		return true;
+	}
+	// Legacy SPA fallback — serve inline HTML with current tier.
+	const tier = readSnapshot(snapshotPath).tier;
+	res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+	res.end(dashboardHtml(tier));
+	return true;
+}

package/extensions/dashboard-server/routes-sessions.ts

@@ -0,0 +1,195 @@
+/**
+ * dashboard-server/routes-sessions.ts — Session and SSE event route handlers.
+ */
+
+import { createRequire } from "node:module";
+import { existsSync, watch } from "node:fs";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { readFrom } from "./snapshot.js";
+import type { RouteContext } from "./routes-core.js";
+
+// ---------------------------------------------------------------------------
+// handleEvents — "/api/events" SSE
+// ---------------------------------------------------------------------------
+
+export function handleEvents(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (req.url !== "/api/events") return false;
+
+	const { eventsPath, eventOffsetRef } = ctx;
+
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive",
+	});
+
+	// Drain existing events so the client starts with history
+	const { data: existing, offset: initialOffset } = readFrom(eventsPath, 0);
+	eventOffsetRef.value = initialOffset;
+	const lines = existing.split("\n").filter((l: string) => l.trim());
+	for (const line of lines) {
+		res.write(`data: ${line}\n\n`);
+	}
+
+	// Tail new events via fs.watch (coalesced with 100ms debounce)
+	let watchTimer: ReturnType<typeof setTimeout> | null = null;
+	const onWatch = () => {
+		if (watchTimer) return;
+		watchTimer = setTimeout(() => {
+			watchTimer = null;
+			const { data, offset } = readFrom(eventsPath, eventOffsetRef.value);
+			eventOffsetRef.value = offset;
+			const newLines = data.split("\n").filter((l: string) => l.trim());
+			for (const line of newLines) {
+				res.write(`data: ${line}\n\n`);
+			}
+		}, 100);
+	};
+
+	// Set up file watching: if file exists, watch it directly;
+	// otherwise poll for creation every 1s then switch to fs.watch.
+	let watcher: ReturnType<typeof watch> | null = null;
+	let pollInterval: ReturnType<typeof setInterval> | null = null;
+
+	function startFileWatch(): void {
+		try {
+			watcher = watch(eventsPath, onWatch);
+		} catch {
+			/* give up */
+		}
+	}
+
+	if (existsSync(eventsPath)) {
+		startFileWatch();
+	} else {
+		pollInterval = setInterval(() => {
+			if (existsSync(eventsPath)) {
+				if (pollInterval) {
+					clearInterval(pollInterval);
+					pollInterval = null;
+				}
+				startFileWatch();
+			}
+		}, 1000);
+	}
+
+	req.on("close", () => {
+		if (watchTimer) clearTimeout(watchTimer);
+		if (pollInterval) clearInterval(pollInterval);
+		watcher?.close();
+	});
+
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// handleSessions — "/api/sessions" (GET sessions list) and
+// "/api/sessions/timeseries" (GET timeseries).
+// ---------------------------------------------------------------------------
+
+export function handleSessions(
+	req: IncomingMessage,
+	res: ServerResponse,
+	_ctx: RouteContext,
+): boolean {
+	if (!req.url?.startsWith("/api/sessions")) return false;
+
+	// /api/sessions/timeseries handled inline below.
+	if (req.url.startsWith("/api/sessions/timeseries")) {
+		// /api/sessions/timeseries — S39: stacked per-session token timeseries for
+		// the recharts memory graph. GET ?minutes=N (clamped [1,1440]) returns
+		// {updatedAt, windowMinutes, series[], totals[]} in recharts-ready shape.
+		// Non-GET -> 405. PREVENT-PI-004: loopback.
+		const tsReq = createRequire(import.meta.url);
+		const {
+			readSessionTimeseries,
+			pruneTokenSamples,
+		} = tsReq(
+				"../../src/store/sqlite.js",
+			) as typeof import("../../src/store/sqlite.js");
+		if (req.method !== "GET") {
+			res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+			res.end(JSON.stringify({ error: "method_not_allowed" }));
+			return true;
+		}
+		try {
+			const url = new URL(req.url, "http://x"); // guardrails-allow PREVENT-PI-004: localhost dashboard URL base (loopback-only)
+			let minutes = Number(url.searchParams.get("minutes") ?? "30");
+			if (!Number.isFinite(minutes) || minutes <= 0) minutes = 30;
+			minutes = Math.min(Math.max(minutes, 1), 1440);
+			const sinceTs = Date.now() - minutes * 60_000;
+			const pruneMs = Math.max(minutes * 60_000, 1_800_000);
+			pruneTokenSamples(pruneMs); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+			const result = readSessionTimeseries(sinceTs); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					updatedAt: new Date().toISOString(),
+					windowMinutes: minutes,
+					series: result.series,
+					totals: result.totals,
+				}),
+			);
+		} catch (e) {
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({ error: "timeseries_unavailable", detail: String(e) }),
+			);
+		}
+		return true;
+	}
+
+	// /api/sessions — S39: active pi sessions with latest token usage + heartbeat.
+	// GET returns {updatedAt, pruned, sessions[]} after pruning stale heartbeats.
+	// The dashboard server is a detached child with no MegaRuntime ref, so it
+	// reads session_heartbeats via a require()'d sqlite helper (same pattern as
+	// /api/achievements, /api/perf). Non-GET -> 405. PREVENT-PI-004: loopback.
+	const sReq = createRequire(import.meta.url);
+	const {
+		readActiveSessions,
+		pruneStaleSessions,
+		listRepoRegistry,
+	} = sReq(
+			"../../src/store/sqlite.js",
+		) as typeof import("../../src/store/sqlite.js");
+	if (req.method !== "GET") {
+		res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	try {
+		const pruned = pruneStaleSessions(); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+		const active = readActiveSessions();
+		const repos = listRepoRegistry();
+		const repoMap = new Map(repos.map((r) => [r.repoRoot, r]));
+		const sessions = active.map((s) => ({
+			pid: s.pid,
+			sessionId: s.sessionId,
+			repoRoot: s.repoRoot,
+			displayName: s.repoRoot
+				? (s.repoRoot.split(/[\\/]/).filter(Boolean).pop() ?? s.repoRoot)
+				: (s.stateDir?.split(/[\\/]/).filter(Boolean).pop() ?? "unknown"),
+			model: s.repoRoot ? (repoMap.get(s.repoRoot)?.modelName ?? null) : null,
+			tokens: s.tokens,
+			percent: s.percent,
+			ctxWindow: s.ctxWindow,
+			lastSeen: s.lastSeen,
+			stateDir: s.stateDir,
+		}));
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({ updatedAt: new Date().toISOString(), pruned, sessions }),
+		);
+	} catch (e) {
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({ error: "sessions_unavailable", detail: String(e) }),
+		);
+	}
+	return true;
+}

package/extensions/dashboard-server/routes.ts

@@ -0,0 +1,13 @@
+/**
+ * dashboard-server/routes.ts — Barrel: re-exports all route handlers + types.
+ *
+ * server.ts imports only from this barrel; the actual handler implementations
+ * live in the split files below.
+ */
+
+export { buildRouteContext } from "./routes-core.js";
+export type { RouteContext } from "./routes-core.js";
+
+export { handleIndex, handleRepoIndex, handleStatic } from "./routes-repo.js";
+export { handleGameState, handleGameScores, handlePerf, handleAchievements } from "./routes-game.js";
+export { handleEvents, handleSessions } from "./routes-sessions.js";