pi-mega-compact 0.7.8 → 0.8.0

package/dist/extensions/dashboard-server/snapshot.js

@@ -0,0 +1,43 @@
+/**
+ * dashboard-server/snapshot.ts — snapshot + events.log file readers.
+ */
+import { readFileSync } from "node:fs";
+export function readSnapshot(snapshotPath) {
+    try {
+        const raw = readFileSync(snapshotPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {
+            version: 1,
+            updatedAt: null,
+            tier: "unknown",
+            presetTier: "unknown",
+            pressure: 0,
+            config: { fastGatePct: 80, thresholdTokens: 100_000, tierPct: null, effectiveThresholdPct: null, anchorUserMessages: 1, preserveRecent: 2, auto: true, autoInlineK: 3 },
+            session: { id: null, state: null, persistedThisSession: false, lastCheckpointId: null, lastCompactedFrom: 0 },
+            context: { tokens: null, percent: null, contextWindow: 0 },
+            trigger: { armed: false, ready: false, currentTokens: null, thresholdTokens: 100_000, fastGatePct: 80, tierPct: null, effectiveThresholdPct: null },
+            store: { checkpointCount: 0, totalTokenEstimate: 0, originalTokens: 0, tokensSaved: 0, injectedCount: 0, dedupHitRate: 0, storageDedupRate: 0, dedupCollapsed: 0 },
+            crew: { activeAgents: 0, currentTurn: 0 },
+            repo: { checkpointCount: 0, totalTokenEstimate: 0, originalTokens: 0, tokensSaved: 0, sessionCount: 0, dedupAttempts: 0, dedupCollapsed: 0, storageDedupRate: 0 },
+            integrity: { regionsRetained: 0, compressedOriginalBytes: 0, duplicatesCollapsed: 0, bytesPermanentlyDeleted: 0 },
+            cacheHits: { session: 0, total: 0, sessionTokensSaved: 0, totalTokensSaved: 0 },
+            compacts: { session: 0, total: 0 },
+            timeSaved: { compact: { sessionSec: 0, totalSec: 0 }, cacheHit: { sessionSec: 0, totalSec: 0 } },
+            compression: { session: { tokensIn: 0, tokensOut: 0, tokensFreed: 0, compressionPct: 0, dedupPct: 0 }, repo: { tokensIn: 0, tokensOut: 0, tokensFreed: 0, compressionPct: 0, dedupPct: 0 } },
+            model: undefined,
+        };
+    }
+}
+export function readFrom(path, charOffset) {
+    try {
+        const content = readFileSync(path, "utf-8");
+        if (content.length <= charOffset)
+            return { data: "", offset: charOffset };
+        return { data: content.slice(charOffset), offset: content.length };
+    }
+    catch {
+        return { data: "", offset: charOffset };
+    }
+}

package/dist/extensions/dashboard-server/state.js

@@ -0,0 +1,30 @@
+/**
+ * dashboard-server/state.ts — local runtime log + version state.
+ *
+ * The dashboard server is spawned as a DETACHED child. When it is launched with
+ * `stdio: "ignore"` (the old default) any crash before the first console.log is
+ * invisible — there is no log to "check". We therefore mirror every lifecycle
+ * line to a file in the state dir so a failed start is always diagnosable. The
+ * launcher also captures stderr, so this doubles as defense-in-depth.
+ */
+import { appendFileSync } from "node:fs";
+let LOG_PATH = null;
+export function setLogPath(path) {
+    LOG_PATH = path;
+}
+export function log(...parts) {
+    const line = `[mega-compact][dashboard] ${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}`;
+    // eslint-disable-next-line no-console
+    console.error(line); // stderr — captured by the launcher pipe
+    if (LOG_PATH) {
+        try {
+            appendFileSync(LOG_PATH, new Date().toISOString() + " " + line + "\n");
+        }
+        catch { /* non-fatal */ }
+    }
+}
+/** Package version of this extension, surfaced in the dashboard header. */
+export let dashboardServerVersion = "0.0.0";
+export function setDashboardServerVersion(v) {
+    dashboardServerVersion = v;
+}

package/dist/extensions/dashboard-server/types.js

@@ -0,0 +1,5 @@
+/**
+ * dashboard-server/types.ts — shared types for the dashboard server.
+ */
+// Active-window cutoff (seconds) for the /api/servers endpoint.
+export const ACTIVE_WINDOW_SEC = 1800;

package/dist/extensions/dashboard-server-s32.test.js

@@ -0,0 +1,181 @@
+/**
+ * dashboard-server.test.ts — S32 game-state API + settings strip tests.
+ *
+ * GET/PUT /api/game-state round-trips the game_state SQLite row through the
+ * real server subprocess (spawn + waitFor + fetch), and the HTML template
+ * carries the data-theme attribute + settings strip + theme CSS-var blocks.
+ */
+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 { dashboardHtml } from "./dashboard-server/html.js";
+import { setGameState, getGameState } from "../src/store/sqlite.js";
+const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
+function waitFor(cond, timeoutMs = 6000) {
+    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) {
+    return mkdtempSync(join(tmpdir(), prefix));
+}
+async function withServer(port, dir, fn) {
+    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 });
+    }
+}
+describe("S32 /api/game-state", () => {
+    test("GET returns the current game_state row (seeded via setGameState)", async () => {
+        const dir = freshDir("dash-gs-get-");
+        setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, dir);
+        await withServer("19330", dir, async (port) => {
+            const gs = (await fetch(`http://localhost:${port}/api/game-state`).then((r) => r.json()));
+            assert.equal(gs.game_mode_on, true);
+            assert.equal(gs.theme, "retro");
+            assert.equal(gs.tui_display_mode, "minimal");
+        });
+    });
+    test("PUT {theme:'retro'} -> 200 and getGameState(dir).theme === 'retro'", async () => {
+        const dir = freshDir("dash-gs-theme-");
+        await withServer("19331", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ theme: "retro" }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.theme, "retro");
+            // And the authoritative DB read reflects the write.
+            assert.equal(getGameState(dir).theme, "retro");
+        });
+    });
+    test("PUT invalid theme 'bogus' -> 400 and row unchanged", async () => {
+        const dir = freshDir("dash-gs-invalid-");
+        setGameState({ theme: "orange-bold" }, dir);
+        const before = getGameState(dir).theme;
+        await withServer("19332", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ theme: "bogus" }),
+            });
+            assert.equal(res.status, 400);
+        });
+        assert.equal(getGameState(dir).theme, before, "row unchanged after invalid PUT");
+    });
+    test("PUT body 'null' (valid-but-non-object JSON) -> 400, server stays up (audit P1)", async () => {
+        const dir = freshDir("dash-gs-nullobj-");
+        setGameState({ theme: "amber-mono" }, dir);
+        const before = getGameState(dir).theme;
+        await withServer("19335", dir, async (port) => {
+            // A valid-JSON-but-non-object body must NOT crash the detached server
+            // (audit P1: unhandled TypeError on patch.game_mode_on deref).
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(null),
+            });
+            assert.equal(res.status, 400, "non-object JSON -> 400, not a crash");
+            const body = (await res.json());
+            assert.equal(body.error, "invalid_patch_object");
+            // Server must still be up — a follow-up GET must succeed.
+            const follow = await fetch(`http://localhost:${port}/api/game-state`);
+            assert.equal(follow.status, 200, "server survived the non-object PUT");
+        });
+        assert.equal(getGameState(dir).theme, before, "row unchanged after non-object PUT");
+    });
+    test("PUT body '[]' (array) -> 400, server stays up", async () => {
+        const dir = freshDir("dash-gs-arr-");
+        await withServer("19336", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify([]),
+            });
+            assert.equal(res.status, 400);
+            const follow = await fetch(`http://localhost:${port}/api/game-state`);
+            assert.equal(follow.status, 200, "server survived the array PUT");
+        });
+    });
+    test("PUT {tui_display_mode:'minimal'} round-trips", async () => {
+        const dir = freshDir("dash-gs-tui-");
+        await withServer("19333", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ tui_display_mode: "minimal" }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.tui_display_mode, "minimal");
+            assert.equal(getGameState(dir).tui_display_mode, "minimal");
+        });
+    });
+    test("PUT {game_mode_on:true} round-trips", async () => {
+        const dir = freshDir("dash-gs-mode-");
+        await withServer("19334", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ game_mode_on: true }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.game_mode_on, true);
+            assert.equal(getGameState(dir).game_mode_on, true);
+        });
+    });
+});
+describe("S32 dashboard HTML skin", () => {
+    test("carries data-theme on <html> + settings strip + theme CSS-var blocks", () => {
+        const html = dashboardHtml("custom");
+        // default transparent theme attribute on <html>
+        assert.match(html, /<html lang="en" data-theme="transparent">/);
+        // settings strip with the three controls
+        assert.match(html, /<div class="settings-strip">/);
+        assert.match(html, /id="set-game-mode"/);
+        assert.match(html, /id="set-theme"/);
+        assert.match(html, /id="set-tui-mode"/);
+        // all 6 theme ids appear as :root[data-theme="<id>"] override blocks
+        for (const id of ["transparent", "retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
+            assert.ok(html.includes(`:root[data-theme="${id}"]{`), `${id} data-theme block present`);
+        }
+        // core CSS vars defined in the base :root
+        assert.match(html, /--bg: #0d1117;/);
+        assert.match(html, /--fg: #c9d1d9;/);
+        assert.match(html, /--accent: #3fb950;/);
+        assert.match(html, /--mega: #f0883e;/);
+        // body uses the themed var (not a hardcoded hex)
+        assert.match(html, /body\s*\{[^}]*background: var\(--bg\)/);
+    });
+});