pi-mega-compact 0.4.19 → 0.4.20

package/dist/extensions/dashboard-server.js

@@ -13,7 +13,8 @@
 import { createServer } from "node:http";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 // --- Multi-repo index (Phase 5b) ------------------------------------------------
 // The extension writes a machine-wide repo registry into a single SQLite DB
@@ -46,7 +47,7 @@ function readIndex() {
         const rows = db
             .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
             .all();
-        const repos = rows.map((r) => ({
+        const mapped = rows.map((r) => ({
             repoRoot: String(r.repo_root ?? ""),
             displayName: String(r.display_name ?? ""),
             checkpointCount: Number(r.checkpoint_count ?? 0),
@@ -60,6 +61,23 @@ function readIndex() {
             outputRate: r.output_rate ?? null,
             lastSeen: Number(r.last_seen ?? 0),
         }));
+        // Defensive display hygiene (belt-and-suspenders — the real fix is that
+        // tests now isolate via MEGACOMPACT_INDEX_DIR): drop transient test/temp
+        // paths that should never have been real repos, and collapse duplicate
+        // display names to the most-recently-seen row (rows are last_seen DESC, so
+        // the first occurrence wins). Keeps the All-repos list readable.
+        const isTransient = (p) => /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+            /\/mc-(ext|e2e|resume|recall)-/.test(p);
+        const seenName = new Set();
+        const repos = [];
+        for (const r of mapped) {
+            if (isTransient(r.repoRoot))
+                continue;
+            if (seenName.has(r.displayName))
+                continue;
+            seenName.add(r.displayName);
+            repos.push(r);
+        }
         const summary = {
             totalRepos: repos.length,
             totalCheckpoints: repos.reduce((a, r) => a + r.checkpointCount, 0),
@@ -634,6 +652,26 @@ function dashboardHtml(tierName) {
 // Server
 // ---------------------------------------------------------------------------
 export function launchDashboardServer(stateDir) {
+    // Our own package version — exposed at /api/version so the launcher can
+    // detect a stale server (started by an older build) and replace it on
+    // upgrade instead of reuse it.
+    let SERVER_VERSION = "0.0.0";
+    try {
+        // dashboard-server.js lives at <pkg>/dist/extensions/, so package.json is
+        // two levels up. Guard each candidate so a dev-checkout layout still works.
+        const here = dirname(fileURLToPath(import.meta.url));
+        const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+        for (const p of candidates) {
+            if (!existsSync(p))
+                continue;
+            const pkg = JSON.parse(readFileSync(p, "utf-8"));
+            if (pkg.version) {
+                SERVER_VERSION = pkg.version;
+                break;
+            }
+        }
+    }
+    catch { /* non-fatal */ }
     const portFile = join(stateDir, "port.pid");
     const snapshotPath = join(stateDir, "dashboard.json");
     const eventsPath = join(stateDir, "events.log");
@@ -674,6 +712,13 @@ export function launchDashboardServer(stateDir) {
             res.end(JSON.stringify(snap));
             return;
         }
+        // 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;
+        }
         // Multi-repo aggregate (Phase 5b): the machine-wide repo registry read
         // directly from SQLite (index.sqlite). Lets one dashboard show every repo's
         // checkpoints, tokens saved, and active model. Read-only.

package/dist/extensions/mega-compact.test.js

@@ -19,6 +19,9 @@ import { join } from "node:path";
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-ext-"));
+// Isolate the machine-wide repo index so test runs (which call bindRepo ->
+// upsertRepoRegistry) never pollute the developer's real ~/.mega-compact-index.
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
 let counter = 0;
 /** Build a mock pi + ctx and load the extension into them. */
 function harness(opts = {}) {
@@ -268,13 +271,14 @@ test("/dashboard-stop reports no server when pid file missing", async () => {
 test("/dashboard skips server spawn when already running", async () => {
     const h = harness();
     const confirms = [];
-    // Set up a fake HTTP server at a random port
+    // Set up a fake HTTP server on a port inside the dashboard's scan range
+    // (9320–9329) — isServerRunning() probes those ports, not the port.pid value.
     const { createServer } = await import("node:http");
     const server = createServer((_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test", version: 1, config: {}, session: {}, context: {}, trigger: {}, store: {} }));
     });
-    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    await new Promise((r) => server.listen(9320, "127.0.0.1", r));
     const addr = server.address();
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
@@ -295,7 +299,8 @@ test("/dashboard skips server spawn when already running", async () => {
 });
 test("/dashboard-status reports running after dashboard start", async () => {
     const h = harness();
-    // Write a fake port.pid with a real port (use a server we control)
+    // Write a fake port.pid; the server must listen inside the scan range
+    // (9320–9329) or isServerRunning() won't detect it.
     const { createServer } = await import("node:http");
     const { join: j } = await import("node:path");
     const { writeFileSync: wf } = await import("node:fs");
@@ -303,7 +308,7 @@ test("/dashboard-status reports running after dashboard start", async () => {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test" }));
     });
-    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    await new Promise((r) => server.listen(9321, "127.0.0.1", r));
     const addr = server.address();
     wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
     const ctx = h.ctx();

package/dist/extensions/mega-dashboard-cmds.js

@@ -32,7 +32,10 @@ export function registerDashboardCommands(pi, runtime) {
         }
         return null;
     }
-    /** Try to reach a running dashboard server. Returns { port, url } or null. */
+    /** Try to reach a running dashboard server. Returns details or null.
+     *  `hasPidFile` tells the caller whether this server was launched by us
+     *  (port.pid present) — a live server with NO pid file is an orphan from an
+     *  older/detached spawn that we should replace rather than reuse. */
     async function isServerRunning() {
         const port = await findLivePort();
         if (!port) {
@@ -45,7 +48,68 @@ export function registerDashboardCommands(pi, runtime) {
             }
             return null;
         }
-        return { port, url: `http://localhost:${port}` }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+        return { port, url: `http://localhost:${port}`, hasPidFile: existsSync(portFile) }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+    }
+    /** Version the running server on `port` reports, or null. */
+    async function serverVersion(port) {
+        try {
+            const res = await fetch(`http://localhost:${port}/api/version`, { signal: AbortSignal.timeout(800) }); // guardrails-allow PREVENT-PI-004: localhost version probe of the dashboard server this extension spawned
+            if (!res.ok)
+                return null;
+            const j = await res.json();
+            return j.version ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Version of THIS extension (read from its own package.json). */
+    function ownVersion() {
+        try {
+            const here = dirname(fileURLToPath(import.meta.url)); // .../extensions
+            const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf-8"));
+            return pkg.version ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** PID listening on 127.0.0.1:port (our own server), or null. Uses `ss`
+     *  (Linux/macOS) — best-effort, returns null if unavailable. */
+    function pidOnPort(port) {
+        try {
+            const { execSync } = require("node:child_process"); // guardrails-allow PREVENT-PI-004: localhost-only, reads our own dashboard port owner
+            const out = execSync(`ss -ltnp 2>/dev/null | grep ':${port} '`, { encoding: "utf-8" });
+            const m = out.match(/pid=(\d+)/);
+            return m ? Number(m[1]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Kill a running dashboard server (best-effort): read the pid from port.pid,
+     *  or — when there's no marker (an orphan) — from the port owner. Then remove
+     *  the marker so the next spawn starts fresh. */
+    function killServerOnPort(port) {
+        let pid = null;
+        try {
+            const info = JSON.parse(readFileSync(portFile, "utf-8"));
+            if (info && info.pid)
+                pid = info.pid;
+        }
+        catch { /* no marker */ }
+        if (pid == null)
+            pid = pidOnPort(port); // orphan with no pid.pid
+        if (pid != null) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already gone */ }
+        }
+        try {
+            unlinkSync(portFile);
+        }
+        catch { /* ignore */ }
     }
     /**
      * Resolve the launchable dashboard-server module.
@@ -119,11 +183,29 @@ export function registerDashboardCommands(pi, runtime) {
             runtime.bindRepo(ctx.cwd);
             let info = await isServerRunning();
             if (info) {
-                ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
-                const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
-                if (open)
-                    openBrowser(info.url);
-                return;
+                // Replace the server when it's stale: either (a) an orphan — a live
+                // server with no port.pid (e.g. left running from a detached spawn or a
+                // previous upgrade) that keeps serving old HTML from memory; or (b) a
+                // server that reports a different version than this extension (an older
+                // build). A live server WITH a matching pid file and version is reused.
+                const orphan = !info.hasPidFile;
+                const running = await serverVersion(info.port);
+                const want = ownVersion();
+                const stale = orphan || (want != null && running != null && running !== want);
+                if (stale) {
+                    ctx.ui.notify(orphan
+                        ? "[mega-compact] replacing orphaned dashboard server…"
+                        : `[mega-compact] replacing stale dashboard (${running} → ${want})…`);
+                    killServerOnPort(info.port);
+                    info = null;
+                }
+                else {
+                    ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
+                    const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
+                    if (open)
+                        openBrowser(info.url);
+                    return;
+                }
             }
             // Start the server
             ctx.ui.notify("[mega-compact] starting dashboard server…");

package/extensions/dashboard-server.ts

@@ -14,7 +14,8 @@
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 
 // --- Multi-repo index (Phase 5b) ------------------------------------------------
@@ -61,7 +62,7 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
     const rows = db
       .prepare("SELECT * FROM repo_registry ORDER BY last_seen DESC")
       .all() as Record<string, unknown>[];
-    const repos: IndexRepo[] = rows.map((r) => ({
+    const mapped: IndexRepo[] = rows.map((r) => ({
       repoRoot: String(r.repo_root ?? ""),
       displayName: String(r.display_name ?? ""),
       checkpointCount: Number(r.checkpoint_count ?? 0),
@@ -75,6 +76,22 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
       outputRate: (r.output_rate as number | null) ?? null,
       lastSeen: Number(r.last_seen ?? 0),
     }));
+    // Defensive display hygiene (belt-and-suspenders — the real fix is that
+    // tests now isolate via MEGACOMPACT_INDEX_DIR): drop transient test/temp
+    // paths that should never have been real repos, and collapse duplicate
+    // display names to the most-recently-seen row (rows are last_seen DESC, so
+    // the first occurrence wins). Keeps the All-repos list readable.
+    const isTransient = (p: string) =>
+      /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+      /\/mc-(ext|e2e|resume|recall)-/.test(p);
+    const seenName = new Set<string>();
+    const repos: IndexRepo[] = [];
+    for (const r of mapped) {
+      if (isTransient(r.repoRoot)) continue;
+      if (seenName.has(r.displayName)) continue;
+      seenName.add(r.displayName);
+      repos.push(r);
+    }
     const summary = {
       totalRepos: repos.length,
       totalCheckpoints: repos.reduce((a, r) => a + r.checkpointCount, 0),
@@ -722,6 +739,21 @@ function dashboardHtml(tierName: string): string {
 // ---------------------------------------------------------------------------
 
 export function launchDashboardServer(stateDir: string): Promise<{ port: number; url: string }> {
+  // Our own package version — exposed at /api/version so the launcher can
+  // detect a stale server (started by an older build) and replace it on
+  // upgrade instead of reuse it.
+  let SERVER_VERSION = "0.0.0";
+  try {
+    // dashboard-server.js lives at <pkg>/dist/extensions/, so package.json is
+    // two levels up. Guard each candidate so a dev-checkout layout still works.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+    for (const p of candidates) {
+      if (!existsSync(p)) continue;
+      const pkg = JSON.parse(readFileSync(p, "utf-8"));
+      if (pkg.version) { SERVER_VERSION = pkg.version; break; }
+    }
+  } catch { /* non-fatal */ }
   const portFile = join(stateDir, "port.pid");
   const snapshotPath = join(stateDir, "dashboard.json");
   const eventsPath = join(stateDir, "events.log");
@@ -769,6 +801,14 @@ export function launchDashboardServer(stateDir: string): Promise<{ port: number;
       return;
     }
 
+    // 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;
+    }
+
     // Multi-repo aggregate (Phase 5b): the machine-wide repo registry read
     // directly from SQLite (index.sqlite). Lets one dashboard show every repo's
     // checkpoints, tokens saved, and active model. Read-only.

package/extensions/mega-compact.test.ts

@@ -22,6 +22,9 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 
 const require = createRequire(import.meta.url);
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-ext-"));
+// Isolate the machine-wide repo index so test runs (which call bindRepo ->
+// upsertRepoRegistry) never pollute the developer's real ~/.mega-compact-index.
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
 let counter = 0;
 
 /** Build a mock pi + ctx and load the extension into them. */
@@ -297,13 +300,14 @@ test("/dashboard-stop reports no server when pid file missing", async () => {
 test("/dashboard skips server spawn when already running", async () => {
   const h = harness();
   const confirms: boolean[] = [];
-  // Set up a fake HTTP server at a random port
+  // Set up a fake HTTP server on a port inside the dashboard's scan range
+  // (9320–9329) — isServerRunning() probes those ports, not the port.pid value.
   const { createServer } = await import("node:http");
   const server = createServer((_req, res) => {
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test", version: 1, config: {}, session: {}, context: {}, trigger: {}, store: {} }));
   });
-  await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+  await new Promise<void>((r) => server.listen(9320, "127.0.0.1", r));
   const addr = server.address() as any;
   const { join: j } = await import("node:path");
   const { writeFileSync: wf } = await import("node:fs");
@@ -328,7 +332,8 @@ test("/dashboard skips server spawn when already running", async () => {
 
 test("/dashboard-status reports running after dashboard start", async () => {
   const h = harness();
-  // Write a fake port.pid with a real port (use a server we control)
+  // Write a fake port.pid; the server must listen inside the scan range
+  // (9320–9329) or isServerRunning() won't detect it.
   const { createServer } = await import("node:http");
   const { join: j } = await import("node:path");
   const { writeFileSync: wf } = await import("node:fs");
@@ -336,7 +341,7 @@ test("/dashboard-status reports running after dashboard start", async () => {
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ updatedAt: new Date().toISOString(), tier: "test" }));
   });
-  await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+  await new Promise<void>((r) => server.listen(9321, "127.0.0.1", r));
   const addr = server.address() as any;
   wf(j(h.stateDir, "port.pid"), JSON.stringify({ port: addr.port, pid: process.pid }));
 

package/extensions/mega-dashboard-cmds.ts

@@ -36,8 +36,11 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
     return null;
   }
 
-  /** Try to reach a running dashboard server. Returns { port, url } or null. */
-  async function isServerRunning(): Promise<{ port: number; url: string } | null> {
+  /** Try to reach a running dashboard server. Returns details or null.
+   *  `hasPidFile` tells the caller whether this server was launched by us
+   *  (port.pid present) — a live server with NO pid file is an orphan from an
+   *  older/detached spawn that we should replace rather than reuse. */
+  async function isServerRunning(): Promise<{ port: number; url: string; hasPidFile: boolean } | null> {
     const port = await findLivePort();
     if (!port) {
       // Stale marker with no live server behind it — clean up.
@@ -46,7 +49,59 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       }
       return null;
     }
-    return { port, url: `http://localhost:${port}` }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+    return { port, url: `http://localhost:${port}`, hasPidFile: existsSync(portFile) }; // guardrails-allow PREVENT-PI-004: localhost URL of the dashboard server this extension spawned
+  }
+
+  /** Version the running server on `port` reports, or null. */
+  async function serverVersion(port: number): Promise<string | null> {
+    try {
+      const res = await fetch(`http://localhost:${port}/api/version`, { signal: AbortSignal.timeout(800) }); // guardrails-allow PREVENT-PI-004: localhost version probe of the dashboard server this extension spawned
+      if (!res.ok) return null;
+      const j = await res.json() as { version?: string };
+      return j.version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Version of THIS extension (read from its own package.json). */
+  function ownVersion(): string | null {
+    try {
+      const here = dirname(fileURLToPath(import.meta.url)); // .../extensions
+      const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf-8"));
+      return pkg.version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** PID listening on 127.0.0.1:port (our own server), or null. Uses `ss`
+   *  (Linux/macOS) — best-effort, returns null if unavailable. */
+  function pidOnPort(port: number): number | null {
+    try {
+      const { execSync } = require("node:child_process"); // guardrails-allow PREVENT-PI-004: localhost-only, reads our own dashboard port owner
+      const out = execSync(`ss -ltnp 2>/dev/null | grep ':${port} '`, { encoding: "utf-8" });
+      const m = out.match(/pid=(\d+)/);
+      return m ? Number(m[1]) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Kill a running dashboard server (best-effort): read the pid from port.pid,
+   *  or — when there's no marker (an orphan) — from the port owner. Then remove
+   *  the marker so the next spawn starts fresh. */
+  function killServerOnPort(port: number): void {
+    let pid: number | null = null;
+    try {
+      const info = JSON.parse(readFileSync(portFile, "utf-8"));
+      if (info && info.pid) pid = info.pid;
+    } catch { /* no marker */ }
+    if (pid == null) pid = pidOnPort(port); // orphan with no pid.pid
+    if (pid != null) {
+      try { process.kill(pid, "SIGTERM"); } catch { /* already gone */ }
+    }
+    try { unlinkSync(portFile); } catch { /* ignore */ }
   }
 
   /**
@@ -122,10 +177,29 @@ export function registerDashboardCommands(pi: ExtensionAPI, runtime: MegaRuntime
       let info = await isServerRunning();
 
       if (info) {
-        ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
-        const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
-        if (open) openBrowser(info.url);
-        return;
+        // Replace the server when it's stale: either (a) an orphan — a live
+        // server with no port.pid (e.g. left running from a detached spawn or a
+        // previous upgrade) that keeps serving old HTML from memory; or (b) a
+        // server that reports a different version than this extension (an older
+        // build). A live server WITH a matching pid file and version is reused.
+        const orphan = !info.hasPidFile;
+        const running = await serverVersion(info.port);
+        const want = ownVersion();
+        const stale = orphan || (want != null && running != null && running !== want);
+        if (stale) {
+          ctx.ui.notify(
+            orphan
+              ? "[mega-compact] replacing orphaned dashboard server…"
+              : `[mega-compact] replacing stale dashboard (${running} → ${want})…`,
+          );
+          killServerOnPort(info.port);
+          info = null;
+        } else {
+          ctx.ui.notify(`[mega-compact] dashboard already running at ${info.url}`);
+          const open = await ctx.ui.confirm("mega-compact dashboard", `Open ${info.url} in browser?`);
+          if (open) openBrowser(info.url);
+          return;
+        }
       }
 
       // Start the server

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.4.19",
+  "version": "0.4.20",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",