pi-mega-compact 0.8.7 → 0.8.10

package/extensions/dashboard-server/api-contracts.ts

@@ -0,0 +1,96 @@
+/**
+ * @deprecated Import from `./api-contracts/index.js` (barrel) instead.
+ * This file is retained for backward compatibility. All types are re-exported
+ * from domain modules under `api-contracts/`.
+ *
+ * See: api-contracts/core.ts, snapshot.ts, multi-repo.ts, game.ts, infrastructure.ts
+ */
+
+// Re-export everything from the barrel
+export type {
+  // Core
+  HttpMethod,
+  EndpointDef,
+  SseCompactStart,
+  SseCompactEnd,
+  SseCompactTrigger,
+  SseCompactSkip,
+  SseTierChanged,
+  SseModelChanged,
+  SsePressureLifted,
+  SseCheckpointPersisted,
+  SseRecallInject,
+  SseAnchorsUpdated,
+  SseConfigUpdated,
+  SseConfigPreset,
+  SseCrewPresenceChanged,
+  SseCrewTurnChanged,
+  SseCrewBanditChosen,
+  // Snapshot
+  SnapshotResponse,
+  TriggerResponse,
+  CompressionTotalsResponse,
+  CompactHistoryEntry,
+  CompactionRequest,
+  CompactionResponse,
+  // Multi-repo
+  RepoListItem,
+  RepoSnapshotEntry,
+  RepoSnapshotMap,
+  IndexesIndexRow,
+  IndexesSummaryResponse,
+  IndexesDiffEntry,
+  DiffRequest,
+  SnapshotLike,
+  DiffResponse,
+  UpdateRepoConfigRequest,
+  // Game
+  GameConfig,
+  GameStateResponse,
+  GameRitualStage,
+  SseGameRitualStart,
+  SseGameRitualStage,
+  SseGameRitualEnd,
+  SseGameModeChanged,
+  SseGameRender,
+  // Infrastructure
+  InfraHealthResponse,
+  InfraPerfSampleResponse,
+  InfraRateLimitStatus,
+  InfraRateLimitResponse,
+  ContextLevelState,
+  TierOverrideState,
+  FallbackState,
+  RepeatInjectionState,
+  SupersedeGatingState,
+  MinHashBandState,
+  // Composite
+  SseEvent,
+  // Endpoints registry (Sprint A1)
+  VersionResponse,
+  IndexSummary,
+  IndexFallbackResponse,
+  ReposQuery,
+  ReposResponse,
+  SummaryResponse,
+  DriftSeverity,
+  DriftSignal,
+  RepoDrift,
+  DriftReportResponse,
+  ServerEntry,
+  ServersResponse,
+  PerfPercentile,
+  PerfAverage,
+  PerfLatest,
+  PerfCacheHit,
+  PerfDiag,
+  PerfQuery,
+  PerfResponse,
+  GameScoreRow,
+  GameScoresQuery,
+  AchievementRow,
+  GameStatePatch,
+  SseEndpointDef,
+} from './api-contracts/index.js';
+
+export { ENDPOINTS } from './api-contracts/index.js';

package/extensions/dashboard-server/auth.ts

@@ -0,0 +1,20 @@
+import { randomUUID } from "node:crypto";
+
+const CSRF_TOKENS = new Map<string, number>();
+export const CSRF_MAX_AGE_MS = 60 * 60 * 1000; // 60 min rotation
+
+export function generateCsrfToken(): string {
+	const token = randomUUID();
+	CSRF_TOKENS.set(token, Date.now());
+	return token;
+}
+
+export function isCsrfValid(token: string): boolean {
+	if (!CSRF_TOKENS.has(token)) return false;
+	const ts = CSRF_TOKENS.get(token) ?? 0;
+	if (Date.now() - ts > CSRF_MAX_AGE_MS) {
+		CSRF_TOKENS.delete(token);
+		return false;
+	}
+	return true;
+}

package/extensions/dashboard-server/html.ts

@@ -189,6 +189,7 @@ export function dashboardHtml(tierName: string): string {
   <button class="tab" data-tab="active">Active Repos</button>
   <button class="tab" data-tab="summary">Summary</button>
   <button class="tab" data-tab="game">Game Mode</button>
+  <button class="tab" data-tab="perf">Perf</button>
 </nav>
 
 <!-- Current repo (existing single-repo view) -->
@@ -443,6 +444,18 @@ export function dashboardHtml(tierName: string): string {
   <div id="game-empty">No scores yet — run a session with game mode on.</div>
 </div>
 
+<!-- Perf (v0.8.8) — live local instrumentation -->
+<div class="tab-panel" id="panel-perf">
+  <div class="grid">
+    <div class="card"><h2>Model latency</h2><div class="stat-grid"><span class="label">Turn p50</span><span class="value" id="pf-turn-p50">—</span><span class="label">Turn p95</span><span class="value" id="pf-turn-p95">—</span><span class="label">Provider p50</span><span class="value" id="pf-prov-p50">—</span><span class="label">Provider p95</span><span class="value" id="pf-prov-p95">—</span></div></div>
+    <div class="card"><h2>Throughput</h2><div class="stat-grid"><span class="label">TPS (avg)</span><span class="value" id="pf-tps">—</span><span class="label">Cache hit %</span><span class="value" id="pf-cache">—</span></div></div>
+    <div class="card"><h2>Process</h2><div class="stat-grid"><span class="label">RSS</span><span class="value" id="pf-rss">—</span><span class="label">Heap</span><span class="value" id="pf-heap">—</span><span class="label">CPU user/sys</span><span class="value" id="pf-cpu">—</span></div></div>
+    <div class="card"><h2>Snapshot cost</h2><div class="stat-grid"><span class="label">DB recompute p50</span><span class="value" id="pf-db-p50">—</span><span class="label">DB recompute p95</span><span class="value" id="pf-db-p95">—</span><span class="label">Disk write p50</span><span class="value" id="pf-disk">—</span></div></div>
+    <div class="card"><h2>TUI lag proxy</h2><div class="stat-grid"><span class="label">Live-trim fires</span><span class="value" id="pf-recompute">—</span><span class="label">Cache replays</span><span class="value" id="pf-replays">—</span><span class="label">Fast-gate skips</span><span class="value" id="pf-skips">—</span></div><div class="meter-sub">skip vs recompute vs replay cadence</div></div>
+  </div>
+  <div class="updated" id="perf-updated">waiting for data</div>
+</div>
+
 <script>
 (function() {
   var evBox = document.getElementById('events');
@@ -1000,9 +1013,40 @@ export function dashboardHtml(tierName: string): string {
     }).catch(function() {});
   }
 
+  // --- Perf tab (v0.8.8) — live local instrumentation ----------------------
+  var perfPollTimer = null;
+  function pollPerf() {
+    fetch('/api/perf?minutes=30').then(function(r) { return r.ok ? r.json() : null; }).then(function(d) { // guardrails-allow PREVENT-PI-004: browser-side fetch in dashboard HTML template (not Node runtime)
+      if (!d) return;
+      var el = document.getElementById('perf-updated');
+      if (el) el.textContent = d.sampleCount + ' samples \u00b7 updated ' + (d.updatedAt || '');
+      function setText(id, txt) { var e = document.getElementById(id); if (e) e.textContent = txt; }
+      function fmtMs(v) { return v == null ? '\u2014' : (v >= 100 ? Math.round(v) + 'ms' : v.toFixed(1) + 'ms'); }
+      function fmtNum(v, dec) { return v == null ? '\u2014' : (typeof v === 'number' ? v.toFixed(dec) : '\u2014'); }
+      setText('pf-turn-p50', fmtMs(d.turn_latency_ms && d.turn_latency_ms.p50));
+      setText('pf-turn-p95', fmtMs(d.turn_latency_ms && d.turn_latency_ms.p95));
+      setText('pf-prov-p50', fmtMs(d.provider_latency_ms && d.provider_latency_ms.p50));
+      setText('pf-prov-p95', fmtMs(d.provider_latency_ms && d.provider_latency_ms.p95));
+      setText('pf-tps', fmtNum(d.tps && d.tps.avg, 1));
+      setText('pf-cache', (d.cache_hit_pct && typeof d.cache_hit_pct.avg === 'number') ? fmtNum(d.cache_hit_pct.avg, 1) + '%' : '\u2014');
+      setText('pf-rss', (d.rss_mb && typeof d.rss_mb.latest === 'number') ? fmtNum(d.rss_mb.latest, 1) + ' MB' : '\u2014');
+      setText('pf-heap', (d.heap_mb && typeof d.heap_mb.latest === 'number') ? fmtNum(d.heap_mb.latest, 1) + ' MB' : '\u2014');
+      setText('pf-cpu', (d.cpu_user_ms && d.cpu_sys_ms) ? (fmtNum(d.cpu_user_ms.latest,1) + ' / ' + fmtNum(d.cpu_sys_ms.latest,1) + ' ms') : '\u2014');
+      setText('pf-db-p50', fmtMs(d.db_recompute_ms && d.db_recompute_ms.p50));
+      setText('pf-db-p95', fmtMs(d.db_recompute_ms && d.db_recompute_ms.p95));
+      setText('pf-disk', fmtMs(d.disk_write_ms && d.disk_write_ms.p50));
+      var diag = d.diag || {};
+      setText('pf-recompute', diag.liveTrimFires != null ? String(diag.liveTrimFires) : '\u2014');
+      setText('pf-replays', diag.liveTrimReplays != null ? String(diag.liveTrimReplays) : '\u2014');
+      setText('pf-skips', diag.ctxFastGate != null ? String(diag.ctxFastGate) : '\u2014');
+    }).catch(function() {});
+  }
+  function startPerfPoll() { if (perfPollTimer) return; pollPerf(); perfPollTimer = setInterval(pollPerf, 2000); }
+  function stopPerfPoll() { if (perfPollTimer) { clearInterval(perfPollTimer); perfPollTimer = null; } }
+
   // --- Tab switching ------------------------------------------------------
   var tabs = document.querySelectorAll('.tab');
-  var panels = { current: 'panel-current', all: 'panel-all', active: 'panel-active', summary: 'panel-summary', game: 'panel-game' };
+  var panels = { current: 'panel-current', all: 'panel-all', active: 'panel-active', summary: 'panel-summary', game: 'panel-game', perf: 'panel-perf' };
   for (var i = 0; i < tabs.length; i++) {
     tabs[i].addEventListener('click', function() {
       var name = this.getAttribute('data-tab');
@@ -1017,6 +1061,7 @@ export function dashboardHtml(tierName: string): string {
       if (name === 'all' || name === 'summary') pollIndex();
       if (name === 'active') pollServers();
       if (name === 'game') { renderGameScores(); renderAchievements(); }
+      if (name === 'perf') startPerfPoll(); else stopPerfPoll();
     });
   }
 })();

package/extensions/dashboard-server/perf-server.test.ts

@@ -0,0 +1,101 @@
+/**
+ * perf-server.test.ts — v0.8.8 /api/perf endpoint (GET aggregates + 405).
+ * Mirrors the server.test.ts spawn-and-fetch harness (self-contained so the
+ * dashboard HTTP-port lane stays isolated).
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { recordPerfSample } from "../../src/store/sqlite.js";
+
+const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
+
+function waitFor(cond: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const tick = async () => {
+      if (await cond()) return resolve();
+      if (Date.now() - start > timeoutMs) return reject(new Error("timeout"));
+      setTimeout(tick, 50);
+    };
+    tick();
+  });
+}
+
+function freshDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+async function withServer<T>(
+  port: string,
+  dir: string,
+  fn: (port: number) => Promise<T>,
+): Promise<T> {
+  process.env.MEGACOMPACT_DASHBOARD_PORT = port;
+  const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+  try {
+    await waitFor(async () => {
+      try {
+        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+        const res = await fetch(`http://localhost:${raw.port}/api/version`);
+        return res.ok;
+      } catch {
+        return false;
+      }
+    });
+    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+    return await fn(raw.port);
+  } finally {
+    child.kill("SIGTERM");
+    delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+interface PerfResp {
+  sampleCount: number;
+  turn_latency_ms: { p50: number; p95: number; n: number };
+  provider_latency_ms: { p50: number; p95: number; n: number };
+  tps: { avg: number; n: number };
+  cache_hit_pct: { avg: number; latest: number; n: number };
+  db_recompute_ms: { p50: number; p95: number; n: number };
+  disk_write_ms: { p50: number; p95: number; n: number };
+  rss_mb: { latest: number; n: number };
+  heap_mb: { latest: number; n: number };
+  cpu_user_ms: { latest: number; n: number };
+  cpu_sys_ms: { latest: number; n: number };
+  diag: { ctxFastGate: number; liveTrimFires: number; liveTrimReplays: number } | null;
+}
+
+describe("v0.8.8 /api/perf", () => {
+  test("GET returns aggregates over recorded perf_samples", async () => {
+    const dir = freshDir("dash-perf-agg-");
+    recordPerfSample(dir, "turn_latency_ms", 100, { turnIndex: 1 });
+    recordPerfSample(dir, "turn_latency_ms", 200);
+    recordPerfSample(dir, "tps", 50);
+    recordPerfSample(dir, "rss_mb", 256);
+    await withServer("19440", dir, async (port) => {
+      const res = await fetch(`http://localhost:${port}/api/perf?minutes=30`);
+      assert.equal(res.status, 200);
+      const d = (await res.json()) as PerfResp;
+      assert.equal(d.sampleCount, 4);
+      assert.equal(d.turn_latency_ms.n, 2);
+      assert.equal(d.turn_latency_ms.p50, 100); // nearest-rank p50 of [100,200]
+      assert.equal(d.turn_latency_ms.p95, 200); // nearest-rank p95 of [100,200]
+      assert.equal(d.tps.avg, 50);
+      assert.equal(d.rss_mb.latest, 256);
+      assert.equal(d.diag, null); // no runtime wrote dashboard.json in this dir
+    });
+  });
+
+  test("non-GET (POST) -> 405", async () => {
+    const dir = freshDir("dash-perf-meth-");
+    await withServer("19441", dir, async (port) => {
+      const res = await fetch(`http://localhost:${port}/api/perf`, { method: "POST" });
+      assert.equal(res.status, 405);
+    });
+  });
+});