@decentnetwork/beagle 0.1.67 → 0.1.69

package/config/bootstrap-nodes.yaml

@@ -48,3 +48,16 @@ bootstrapNodes:
   - host: 52.83.191.228
     port: 33445
     pk: 3khtxZo89SBScAMaHhTvD68pPHiKxgZT6hTCSZZVgNEm
+
+# Store-and-forward relays. Shipped for the same reason the bootstraps are:
+# without them a fresh install has no express client at all, so it never
+# collects offline mail and a friend request sent while it was away is never
+# seen. Previously these came only from config.yaml, which a new install does
+# not have — measured 2026-08-30: a browser posted a friend request to express
+# (recipient inbox grew 320 -> 672 bytes) and the recipient, a fresh desktop
+# install, never pulled it.
+expressNodes:
+  - host: lens.beagle.chat
+    port: 443
+    pk: ECbs4GxwGzxGerNkmqDJFibEmevu8jAXqAZtikccvD95
+    tls: true

package/dist/desktop/app.js

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

package/dist/lan-handoff.js

@@ -145,6 +145,43 @@ export class SwitchablePeerHost {
         // not silently lose chat.
         if (this.#state === "daemon" && !daemonUp) {
             await this.#backToEmbedded("the daemon is no longer running");
+            return;
+        }
+        // ...and the way back, which was missing. Every `agentnet restart` — an
+        // ordinary event, and exactly what an update tells you to run — took the
+        // daemon away for a second or two. This state machine fell back to the
+        // embedded peer and then had no transition to return, so beagle stayed
+        // demoted for the life of the process: the daemon it was meant to front
+        // was running the whole time, invisible to it. The version panel then
+        // reported the APP's peer as the daemon's, so an update that had actually
+        // landed looked like it had not.
+        if (this.#state === "embedded" && daemonUp) {
+            await this.#backToDaemon();
+        }
+    }
+    /** Hand the identity back to a daemon that has (re)appeared. */
+    async #backToDaemon() {
+        if (this.#busy)
+            return;
+        this.#busy = true;
+        try {
+            this.#log.info("the daemon is back — handing the identity over to it");
+            const old = this.#inner;
+            // Null first: reject calls rather than racing a peer that is stopping,
+            // the same order the manual release uses.
+            this.#inner = null;
+            await old?.stop();
+            this.#inner = this.#opts.makeDaemon();
+            this.#setState("daemon");
+        }
+        catch (err) {
+            // Could not stop cleanly — go back to embedded on the next tick rather
+            // than sitting with a null backend.
+            this.#log.error(`could not hand over to the daemon: ${err.message}`);
+            this.#setState("embedded");
+        }
+        finally {
+            this.#busy = false;
         }
     }
     async #backToEmbedded(why) {

package/dist/node-config.js

@@ -12,16 +12,26 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "node:path";
 import yaml from "js-yaml";
-function shippedBootstraps() {
+function shippedConfig() {
     try {
         const file = resolve(dirname(fileURLToPath(import.meta.url)), "..", "config", "bootstrap-nodes.yaml");
-        const parsed = yaml.load(readFileSync(file, "utf-8"));
-        return (parsed?.bootstrapNodes ?? []).filter((n) => n?.host && n?.pk);
+        return (yaml.load(readFileSync(file, "utf-8")) ?? {});
     }
     catch {
-        return [];
+        return {};
     }
 }
+function shippedBootstraps() {
+    return (shippedConfig().bootstrapNodes ?? []).filter((n) => n?.host && n?.pk);
+}
+/** Store-and-forward relays, shipped like the bootstraps.
+ *
+ *  These used to come ONLY from config.yaml, which a fresh install does not
+ *  have — so a new desktop had no express client, never pulled offline mail,
+ *  and silently missed every friend request sent while it was away. */
+function shippedExpress() {
+    return (shippedConfig().expressNodes ?? []).filter((n) => n?.host && n?.pk);
+}
 function valid(nodes) {
     return Array.isArray(nodes) && nodes.length > 0 && nodes.every((n) => n && typeof n.host === "string" && typeof n.pk === "string");
 }
@@ -39,7 +49,8 @@ export function loadNodeConfig(configDir) {
             const merged = valid(fromFile) ? [...fromFile, ...extra] : shipped;
             return {
                 bootstrapNodes: merged.length ? merged : shipped,
-                expressNodes: cfg.carrier?.expressNodes,
+                // Config first, shipped defaults when it says nothing.
+                expressNodes: cfg.carrier?.expressNodes?.length ? cfg.carrier.expressNodes : shippedExpress(),
                 nickname: cfg.node?.name,
                 statusMessage: cfg.node?.statusMessage,
                 autoAccept: cfg.friends?.autoAccept ?? true,
@@ -49,7 +60,9 @@ export function loadNodeConfig(configDir) {
             // Malformed config must not stop the app — fall through to defaults.
         }
     }
-    return { bootstrapNodes: shipped, autoAccept: true };
+    // No config.yaml at all — a fresh install. It still needs the express
+    // relays, or it will never collect a friend request sent while it was away.
+    return { bootstrapNodes: shipped, expressNodes: shippedExpress(), autoAccept: true };
 }
 /** Persist the auto-accept switch into config.yaml, preserving everything
  *  else in the file. Without this the runtime toggle lasted until the next

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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",