@decentnetwork/beagle 0.1.117 → 0.1.118

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.117";
+window.__DK_UI_VERSION="0.1.118";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -1340,7 +1340,9 @@ window.__DK_UI_VERSION="0.1.117";
     userId: ASSISTANT_ID,
     alias: "Beagle Assistant",
     address: "",
-    online: true,
+    // Not a peer, so not "online": there is no session, nothing to be present
+    // on, and no dot is drawn for an `app` row anywhere in the UI.
+    online: false,
     app: true,
     agent: false,
     pending: false,
@@ -1782,7 +1784,7 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       textOverflow: "ellipsis",
       flex: 1,
       minWidth: 0
-    } }, dkRowPreview(row.preview)))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", alignItems: "flex-end", gap: 4, flexShrink: 0 } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)" } }, row.lastTime), row.unread ? /* @__PURE__ */ React.createElement(Unread, { n: row.unread }) : peer.pending ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--warn, #d29922)", title: "friend request pending" }) : /* @__PURE__ */ React.createElement(StatusDot, { online: peer.online })));
+    } }, dkRowPreview(row.preview)))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", alignItems: "flex-end", gap: 4, flexShrink: 0 } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)" } }, row.lastTime), peer.app ? null : row.unread ? /* @__PURE__ */ React.createElement(Unread, { n: row.unread }) : peer.pending ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--warn, #d29922)", title: "friend request pending" }) : /* @__PURE__ */ React.createElement(StatusDot, { online: peer.online })));
   }
   function dkActivityTs(p, isProtocol, fix) {
     const row = rosterRow(p, isProtocol || (() => false), fix);
@@ -4387,6 +4389,8 @@ ${peer.address}`
   }
   function DkAvatar({ peer, size = 30, radius = 7, dot = true }) {
     const d = Math.max(8, size * 0.3);
+    if (peer && peer.app)
+      dot = false;
     return /* @__PURE__ */ React.createElement("div", { style: { position: "relative", width: size, height: size, flexShrink: 0 } }, peer.agent ? /* @__PURE__ */ React.createElement(DkBot, { seed: peer.id, size, radius }) : peer.avatarUrl ? /* @__PURE__ */ React.createElement(DkImgAvatar, { url: peer.avatarUrl, seed: peer.userId || peer.id, size, radius }) : peer.punkId != null ? /* @__PURE__ */ React.createElement(DkPunkAvatar, { id: peer.punkId, size, radius, fallbackSeed: peer.userId || peer.id }) : /* @__PURE__ */ React.createElement(DkIdenticon, { seed: peer.userId || peer.id, size, radius }), dot && /* @__PURE__ */ React.createElement("span", { style: {
       position: "absolute",
       right: -2,
@@ -6132,6 +6136,8 @@ ${peer.address}`
         return;
       const byId = /* @__PURE__ */ new Map();
       for (const p of peers || []) {
+        if (p && p.app)
+          continue;
         const dir = p.lastDir || (String(p.lastMsg || "").startsWith("you: ") ? "out" : "in");
         const quiet = typeof isProtocol === "function" && lastIsProtocol(p, isProtocol);
         byId.set(p.id, { ts: p.lastTs || 0, dir, quiet });

package/dist/discover-cache.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Cached fetches for the discovery directories (the leaderboard and the
+ * beagles.eth /names listing).
+ *
+ * This used to cache successes only. When the gateway was down every UI poll —
+ * one every 2.5 s, per open tab, per machine — started a fresh request, so the
+ * upstream got hammered exactly when it was least able to answer. On
+ * 2026-09-28 the beagle servers on one home network were about 82% of the
+ * gateway's traffic and the day's total reached 139k requests against a 100k
+ * free limit. A failing upstream must cost LESS traffic than a working one,
+ * not more.
+ *
+ * Three rules, and they are the whole module:
+ *   • a success is cached for `ttlMs` (5 minutes),
+ *   • a failure is remembered for `failTtlMs` (60 s) and nothing is refetched
+ *     inside that window — a stale body is served if we have one, because a
+ *     five-minute-old directory listing is worth more than an error,
+ *   • one in-flight request per URL, shared by every caller, so the poll that
+ *     arrives while a fetch is running joins it instead of starting another.
+ */
+export interface DiscoverFetchOptions {
+    /** How long a good answer stays good. */
+    ttlMs?: number;
+    /** How long a failure suppresses refetching. */
+    failTtlMs?: number;
+    /** Abort a request that takes longer than this. */
+    timeoutMs?: number;
+    /** Injected for tests. */
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}
+export declare const DISCOVER_TTL_MS: number;
+export declare const DISCOVER_FAIL_TTL_MS = 60000;
+export interface DiscoverFetch {
+    (url: string): Promise<unknown>;
+    /** Forget everything about this URL: the next call refetches. Used when we
+     *  KNOW the upstream changed (we just wrote a record), so the Names tab
+     *  reflects it now instead of in five minutes. A request already in flight
+     *  when this is called carries pre-change data, so its result is discarded
+     *  rather than cached. */
+    invalidate(url: string): void;
+}
+export declare function createDiscoverFetch(opts?: DiscoverFetchOptions): DiscoverFetch;

package/dist/discover-cache.js

@@ -0,0 +1,90 @@
+/**
+ * Cached fetches for the discovery directories (the leaderboard and the
+ * beagles.eth /names listing).
+ *
+ * This used to cache successes only. When the gateway was down every UI poll —
+ * one every 2.5 s, per open tab, per machine — started a fresh request, so the
+ * upstream got hammered exactly when it was least able to answer. On
+ * 2026-09-28 the beagle servers on one home network were about 82% of the
+ * gateway's traffic and the day's total reached 139k requests against a 100k
+ * free limit. A failing upstream must cost LESS traffic than a working one,
+ * not more.
+ *
+ * Three rules, and they are the whole module:
+ *   • a success is cached for `ttlMs` (5 minutes),
+ *   • a failure is remembered for `failTtlMs` (60 s) and nothing is refetched
+ *     inside that window — a stale body is served if we have one, because a
+ *     five-minute-old directory listing is worth more than an error,
+ *   • one in-flight request per URL, shared by every caller, so the poll that
+ *     arrives while a fetch is running joins it instead of starting another.
+ */
+export const DISCOVER_TTL_MS = 5 * 60_000;
+export const DISCOVER_FAIL_TTL_MS = 60_000;
+export function createDiscoverFetch(opts = {}) {
+    const ttlMs = opts.ttlMs ?? DISCOVER_TTL_MS;
+    const failTtlMs = opts.failTtlMs ?? DISCOVER_FAIL_TTL_MS;
+    const timeoutMs = opts.timeoutMs ?? 10_000;
+    const doFetch = opts.fetchImpl ?? fetch;
+    const now = opts.now ?? Date.now;
+    const cache = new Map();
+    const inFlight = new Map();
+    const generation = new Map();
+    const fetchDiscoverJson = async function fetchDiscoverJson(url) {
+        const hit = cache.get(url);
+        if (hit && hit.at !== undefined && now() - hit.at < ttlMs)
+            return hit.body;
+        // Someone is already asking. Join them rather than making it worse — under
+        // a slow upstream this is the difference between one request and one per
+        // poll per tab.
+        const running = inFlight.get(url);
+        if (running)
+            return running;
+        if (hit && hit.failedAt !== undefined && now() - hit.failedAt < failTtlMs) {
+            // Inside the failure window nothing is fetched. Stale beats nothing;
+            // with nothing to serve, the caller gets the error it would have got.
+            if (hit.at !== undefined)
+                return hit.body;
+            throw hit.error ?? new Error("upstream unavailable");
+        }
+        const gen = generation.get(url) ?? 0;
+        const attempt = (async () => {
+            const ctl = new AbortController();
+            const timer = setTimeout(() => ctl.abort(), timeoutMs);
+            try {
+                const r = await doFetch(url, { signal: ctl.signal });
+                if (!r.ok)
+                    throw new Error(`upstream ${r.status}`);
+                const body = await r.json();
+                if ((generation.get(url) ?? 0) === gen)
+                    cache.set(url, { body, at: now() });
+                return body;
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                const prev = cache.get(url);
+                // Keep whatever good body we had: it is what the next 60 s will serve.
+                if ((generation.get(url) ?? 0) === gen) {
+                    cache.set(url, { body: prev?.body, at: prev?.at, failedAt: now(), error: err });
+                }
+                if (prev && prev.at !== undefined)
+                    return prev.body;
+                throw err;
+            }
+            finally {
+                clearTimeout(timer);
+                // After an invalidate the entry is already gone and a newer request
+                // may own the slot; the generation says which of us this is.
+                if ((generation.get(url) ?? 0) === gen)
+                    inFlight.delete(url);
+            }
+        })();
+        inFlight.set(url, attempt);
+        return attempt;
+    };
+    fetchDiscoverJson.invalidate = (url) => {
+        cache.delete(url);
+        inFlight.delete(url);
+        generation.set(url, (generation.get(url) ?? 0) + 1);
+    };
+    return fetchDiscoverJson;
+}

package/dist/server.js

@@ -25,6 +25,7 @@ import * as peerAddr from "@decentnetwork/peer";
 import { bridgeRoster } from "./bridge-roster.js";
 import { isSupervised } from "./relaunch.js";
 import { historyStats } from "./assistant-stats.js";
+import { createDiscoverFetch } from "./discover-cache.js";
 // Directory holding the built desktop UI bundle (index.html, app.js, vendor/).
 // scripts/build-ui.mjs emits it next to this compiled module at dist/ui/desktop/.
 const DESKTOP_DIR = join(dirname(fileURLToPath(import.meta.url)), "desktop");
@@ -33,28 +34,10 @@ const DESKTOP_DIR = join(dirname(fileURLToPath(import.meta.url)), "desktop");
 // (which probes all exits on each poll) stays responsive over a lossy mesh.
 const EXIT_PROBE_PORT = 8888;
 const EXIT_PROBE_TIMEOUT_MS = 2000;
-/** Server-side fetch for the discovery directories (leaderboard / ENS names),
- *  with a small TTL cache so tab switches don't hammer the upstreams. */
-const DISCOVER_CACHE_TTL_MS = 5 * 60_000;
-const discoverCache = new Map();
-async function fetchDiscoverJson(url) {
-    const hit = discoverCache.get(url);
-    if (hit && Date.now() - hit.at < DISCOVER_CACHE_TTL_MS)
-        return hit.body;
-    const ctl = new AbortController();
-    const timer = setTimeout(() => ctl.abort(), 10_000);
-    try {
-        const r = await fetch(url, { signal: ctl.signal });
-        if (!r.ok)
-            throw new Error(`upstream ${r.status}`);
-        const body = await r.json();
-        discoverCache.set(url, { at: Date.now(), body });
-        return body;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
+/** Server-side fetch for the discovery directories (leaderboard / ENS names).
+ *  Successes are cached, FAILURES ARE TOO, and concurrent callers share one
+ *  request — see discover-cache.ts for the outage this comes from. */
+const fetchDiscoverJson = createDiscoverFetch();
 // ── beagles.eth names (ens-gateway worker) ──────────────────────────────────
 // The same registry the mobile apps register into. Web-side registration
 // signs the record with THIS node's Carrier identity (XEdDSA via the backend
@@ -190,7 +173,7 @@ async function ensSignAndSet(call, record) {
         }
         // The record changed — drop the cached /names listing so the Names tab
         // reflects it immediately instead of after the 5-min TTL.
-        discoverCache.delete(`${ENS_GATEWAY}/names`);
+        fetchDiscoverJson.invalidate(`${ENS_GATEWAY}/names`);
         return { ok: true };
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.117",
+  "version": "0.1.118",
   "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",
@@ -35,7 +35,7 @@
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@decentnetwork/beagle-ui": "^0.2.31",
+    "@decentnetwork/beagle-ui": "^0.2.32",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
     "@types/yargs": "^17.0.32",