latticesql 3.4.6 → 3.4.7

package/dist/cli.js

@@ -56081,9 +56081,41 @@ var appJs = `
     }
     function reloadForUpdate(label) {
       if (reloadingForUpdate) return;
+      // Guard against an infinite reload loop. Reloading when the server version
+      // changes is the seamless-update trigger \u2014 but if the version the page was
+      // SERVED with keeps disagreeing with /api/version (e.g. a stale or duplicate
+      // server is holding the port and reporting a different version), every fresh
+      // page would reload again. That unbounded loop pegs memory and crashes the
+      // browser. Cap reloads to MAX within WINDOW; past that, stop and surface the
+      // mismatch instead of spinning. A genuine update reloads once and then the
+      // versions agree, which clears the counter (see checkServerVersion).
+      var KEY = 'lattice:updateReloads',
+        MAX = 3,
+        WINDOW = 60000,
+        now = Date.now(),
+        recent = [];
+      try {
+        recent = (JSON.parse(sessionStorage.getItem(KEY) || '[]') || []).filter(function (t) {
+          return now - t < WINDOW;
+        });
+      } catch (_) {
+        /* sessionStorage blocked \u2014 degrade to a single best-effort reload below */
+      }
+      if (recent.length >= MAX) {
+        showUpdatePill('Version mismatch \u2014 stopped auto-reloading. Reload manually if needed.');
+        return;
+      }
+      recent.push(now);
+      try {
+        sessionStorage.setItem(KEY, JSON.stringify(recent));
+      } catch (_) {
+        /* best-effort */
+      }
       reloadingForUpdate = true;
       showUpdatePill(label || 'Updated \u2014 reloading\u2026');
-      setTimeout(function () { location.reload(); }, 600);
+      setTimeout(function () {
+        location.reload();
+      }, 600);
     }
     // Manual upgrade fallback: show an "Update available \u2014 Upgrade" link next to
     // the version chip only when the server reports a newer, installable version.
@@ -56115,7 +56147,16 @@ var appJs = `
           var v = d && d.version ? String(d.version).replace(/^v/, '').trim() : '';
           if (!v) return;
           if (v !== BOOT_VERSION) reloadForUpdate('Updated to v' + v + ' \u2014 reloading\u2026');
-          else hideUpdatePill();
+          else {
+            hideUpdatePill();
+            // Versions agree \u2014 clear the reload-loop guard so a later genuine
+            // update can reload again from a clean slate.
+            try {
+              sessionStorage.removeItem('lattice:updateReloads');
+            } catch (_) {
+              /* best-effort */
+            }
+          }
         })
         .catch(function () { /* offline / mid-restart \u2014 the next reconnect retries */ });
       // Refresh the manual-upgrade link alongside the reconnect version check.
@@ -70019,6 +70060,28 @@ ${e6.stack ?? ""}`
   };
 }
 
+// src/gui/probe-running.ts
+async function probeRunningGui(port, timeoutMs = 1e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const res = await fetch(`http://127.0.0.1:${String(port)}/api/version`, {
+      signal: controller.signal
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (typeof data !== "object" || data === null || !("version" in data)) return null;
+    const v2 = data.version;
+    return { version: typeof v2 === "string" ? v2 : "" };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/gui/supervisor.ts
 import { spawn as spawn3 } from "child_process";
 async function superviseGui(opts) {
@@ -70253,7 +70316,7 @@ function printHelp() {
   );
 }
 function getVersion() {
-  if (true) return "3.4.6";
+  if (true) return "3.4.7";
   try {
     const pkgPath = new URL("../package.json", import.meta.url).pathname;
     const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
@@ -70450,6 +70513,18 @@ async function runWatch(args) {
   process.on("SIGTERM", shutdown);
 }
 async function runGui(args) {
+  const port = args.port;
+  if (!process.env.LATTICE_GUI_SUPERVISED) {
+    const running = await probeRunningGui(port);
+    if (running) {
+      const url = `http://127.0.0.1:${String(port)}/`;
+      console.log(
+        `Lattice is already running at ${url}${running.version ? ` (v${running.version})` : ""} \u2014 opening it.`
+      );
+      if (!args.noOpen) openUrl(url);
+      return;
+    }
+  }
   if (!process.env.LATTICE_GUI_SUPERVISED && detectInstallContext().installable) {
     try {
       await superviseGui({
@@ -70477,7 +70552,7 @@ async function runGui(args) {
       configPath: boot.configPath,
       outputDir: boot.contextDir,
       latticeRoot: boot.root,
-      port: args.port,
+      port,
       openBrowser: !args.noOpen,
       autoRender: true,
       version: getVersion(),

package/dist/index.cjs

@@ -57959,9 +57959,41 @@ var appJs = `
     }
     function reloadForUpdate(label) {
       if (reloadingForUpdate) return;
+      // Guard against an infinite reload loop. Reloading when the server version
+      // changes is the seamless-update trigger \u2014 but if the version the page was
+      // SERVED with keeps disagreeing with /api/version (e.g. a stale or duplicate
+      // server is holding the port and reporting a different version), every fresh
+      // page would reload again. That unbounded loop pegs memory and crashes the
+      // browser. Cap reloads to MAX within WINDOW; past that, stop and surface the
+      // mismatch instead of spinning. A genuine update reloads once and then the
+      // versions agree, which clears the counter (see checkServerVersion).
+      var KEY = 'lattice:updateReloads',
+        MAX = 3,
+        WINDOW = 60000,
+        now = Date.now(),
+        recent = [];
+      try {
+        recent = (JSON.parse(sessionStorage.getItem(KEY) || '[]') || []).filter(function (t) {
+          return now - t < WINDOW;
+        });
+      } catch (_) {
+        /* sessionStorage blocked \u2014 degrade to a single best-effort reload below */
+      }
+      if (recent.length >= MAX) {
+        showUpdatePill('Version mismatch \u2014 stopped auto-reloading. Reload manually if needed.');
+        return;
+      }
+      recent.push(now);
+      try {
+        sessionStorage.setItem(KEY, JSON.stringify(recent));
+      } catch (_) {
+        /* best-effort */
+      }
       reloadingForUpdate = true;
       showUpdatePill(label || 'Updated \u2014 reloading\u2026');
-      setTimeout(function () { location.reload(); }, 600);
+      setTimeout(function () {
+        location.reload();
+      }, 600);
     }
     // Manual upgrade fallback: show an "Update available \u2014 Upgrade" link next to
     // the version chip only when the server reports a newer, installable version.
@@ -57993,7 +58025,16 @@ var appJs = `
           var v = d && d.version ? String(d.version).replace(/^v/, '').trim() : '';
           if (!v) return;
           if (v !== BOOT_VERSION) reloadForUpdate('Updated to v' + v + ' \u2014 reloading\u2026');
-          else hideUpdatePill();
+          else {
+            hideUpdatePill();
+            // Versions agree \u2014 clear the reload-loop guard so a later genuine
+            // update can reload again from a clean slate.
+            try {
+              sessionStorage.removeItem('lattice:updateReloads');
+            } catch (_) {
+              /* best-effort */
+            }
+          }
         })
         .catch(function () { /* offline / mid-restart \u2014 the next reconnect retries */ });
       // Refresh the manual-upgrade link alongside the reconnect version check.

package/dist/index.js

@@ -57784,9 +57784,41 @@ var appJs = `
     }
     function reloadForUpdate(label) {
       if (reloadingForUpdate) return;
+      // Guard against an infinite reload loop. Reloading when the server version
+      // changes is the seamless-update trigger \u2014 but if the version the page was
+      // SERVED with keeps disagreeing with /api/version (e.g. a stale or duplicate
+      // server is holding the port and reporting a different version), every fresh
+      // page would reload again. That unbounded loop pegs memory and crashes the
+      // browser. Cap reloads to MAX within WINDOW; past that, stop and surface the
+      // mismatch instead of spinning. A genuine update reloads once and then the
+      // versions agree, which clears the counter (see checkServerVersion).
+      var KEY = 'lattice:updateReloads',
+        MAX = 3,
+        WINDOW = 60000,
+        now = Date.now(),
+        recent = [];
+      try {
+        recent = (JSON.parse(sessionStorage.getItem(KEY) || '[]') || []).filter(function (t) {
+          return now - t < WINDOW;
+        });
+      } catch (_) {
+        /* sessionStorage blocked \u2014 degrade to a single best-effort reload below */
+      }
+      if (recent.length >= MAX) {
+        showUpdatePill('Version mismatch \u2014 stopped auto-reloading. Reload manually if needed.');
+        return;
+      }
+      recent.push(now);
+      try {
+        sessionStorage.setItem(KEY, JSON.stringify(recent));
+      } catch (_) {
+        /* best-effort */
+      }
       reloadingForUpdate = true;
       showUpdatePill(label || 'Updated \u2014 reloading\u2026');
-      setTimeout(function () { location.reload(); }, 600);
+      setTimeout(function () {
+        location.reload();
+      }, 600);
     }
     // Manual upgrade fallback: show an "Update available \u2014 Upgrade" link next to
     // the version chip only when the server reports a newer, installable version.
@@ -57818,7 +57850,16 @@ var appJs = `
           var v = d && d.version ? String(d.version).replace(/^v/, '').trim() : '';
           if (!v) return;
           if (v !== BOOT_VERSION) reloadForUpdate('Updated to v' + v + ' \u2014 reloading\u2026');
-          else hideUpdatePill();
+          else {
+            hideUpdatePill();
+            // Versions agree \u2014 clear the reload-loop guard so a later genuine
+            // update can reload again from a clean slate.
+            try {
+              sessionStorage.removeItem('lattice:updateReloads');
+            } catch (_) {
+              /* best-effort */
+            }
+          }
         })
         .catch(function () { /* offline / mid-restart \u2014 the next reconnect retries */ });
       // Refresh the manual-upgrade link alongside the reconnect version check.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latticesql",
-  "version": "3.4.6",
+  "version": "3.4.7",
   "description": "Persistent structured memory for AI agent systems — pluggable SQLite or Postgres backend, LLM context bridge",
   "type": "module",
   "main": "./dist/index.js",