@decentnetwork/beagle 0.1.65 → 0.1.66

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.65";
+window.__DK_UI_VERSION="0.1.66";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js

package/dist/server.js

@@ -1582,15 +1582,28 @@ export function startBeagleServer(opts) {
             // ── self-update: check (cached), run (localhost), restart (localhost) ──
             if (req.method === "GET" && url === "/api/update-check") {
                 const force = new URL(req.url || "", "http://localhost").searchParams.get("force") === "1";
-                if (!force && updateCache && Date.now() - updateCache.at < UPDATE_TTL_MS) {
-                    sendJson(res, 200, updateCache.body);
-                    return;
-                }
-                const [beagleLatest, peerLatest, lanLatest] = await Promise.all([
-                    npmLatest(BEAGLE_PKG),
-                    npmLatest("@decentnetwork/peer"),
-                    npmLatest("@decentnetwork/lan"),
-                ]);
+                // Cache the REGISTRY lookups, never the answer. The whole body used to
+                // be cached for six hours, and it is only invalidated by updating
+                // THROUGH this app — so someone who ran the terminal command the card
+                // itself told them to run saw the same "update available" for the rest
+                // of the day, no matter how many times they ran it. The card sent
+                // people in a loop it was creating.
+                //
+                // What is actually slow and rate-limited is npm; the running versions
+                // come from the daemon and are already cached for 30s. So the rows are
+                // rebuilt every call and only `latest` is held.
+                if (force)
+                    updateCache = null;
+                const cachedLatest = updateCache && Date.now() - updateCache.at < UPDATE_TTL_MS
+                    ? updateCache.body.latest
+                    : undefined;
+                const [beagleLatest, peerLatest, lanLatest] = cachedLatest
+                    ? [cachedLatest.beagle ?? null, cachedLatest.peer ?? null, cachedLatest.lan ?? null]
+                    : await Promise.all([
+                        npmLatest(BEAGLE_PKG),
+                        npmLatest("@decentnetwork/peer"),
+                        npmLatest("@decentnetwork/lan"),
+                    ]);
                 const running = await runningVersions(opts.call);
                 const curLan = running.lanVer || (opts.meExtra?.lanVer ?? "");
                 const row = (pkg, current, latest) => ({
@@ -1617,7 +1630,15 @@ export function startBeagleServer(opts) {
                         ...(curLan && curLan !== "(none)" ? [row("@decentnetwork/lan", curLan, lanLatest)] : []),
                     ],
                 };
-                updateCache = { at: Date.now(), body };
+                // Keep only what npm told us, and only when it actually answered.
+                // Caching a failed lookup as "null" would pin the panel to "up to
+                // date" for six hours after one flaky request.
+                if (!cachedLatest && (beagleLatest || peerLatest || lanLatest)) {
+                    updateCache = {
+                        at: Date.now(),
+                        body: { latest: { beagle: beagleLatest, peer: peerLatest, lan: lanLatest } },
+                    };
+                }
                 sendJson(res, 200, body);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "Beagle — P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
   "type": "module",
   "main": "./dist/index.js",