@decentnetwork/beagle 0.1.56 → 0.1.58

package/dist/cli.js

@@ -28,6 +28,7 @@ function parseArgs(argv) {
             "  --config-dir <p>   identity/config dir (default ~/.agentnet)",
             "  --dora-dir <p>     dora roster dir, if this machine runs a dora",
             "  --backend <k>      force 'daemon' or 'embedded' (default: auto)",
+            "  --wait-daemon <s>  with --backend daemon, wait this long for it (default 60)",
             "  -h, --help         this text",
         ].join("\n"));
         process.exit(0);
@@ -40,6 +41,7 @@ function parseArgs(argv) {
         configDir: get("--config-dir") ?? defaultConfigDir(),
         doraDir: get("--dora-dir"),
         backend: get("--backend"),
+        waitDaemon: get("--wait-daemon"),
     };
 }
 const readJsonVer = (file) => {
@@ -109,6 +111,7 @@ async function main() {
             onAutoAcceptChange: (enabled) => saveAutoAccept(args.configDir, enabled),
             peerVersion: resolveVer("@decentnetwork/peer"),
             force: args.backend,
+            waitForDaemonMs: args.waitDaemon ? Number(args.waitDaemon) * 1000 : undefined,
         }));
     }
     catch (error) {

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.56";
+window.__DK_UI_VERSION="0.1.58";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
@@ -1275,9 +1275,39 @@ Object.assign(window, {
   TweakButton
 });
 function RequestsBlock({ T, requests, onAct }) {
-  if (!requests.length)
+  const [acted, setActed] = React.useState({});
+  const [failed, setFailed] = React.useState({});
+  const act = (r, kind) => {
+    if (acted[r.id])
+      return;
+    setActed((a) => ({ ...a, [r.id]: kind }));
+    setFailed((f) => {
+      const n = { ...f };
+      delete n[r.id];
+      return n;
+    });
+    Promise.resolve(onAct(r.id, kind)).then((res) => {
+      if (res && res.ok === false) {
+        setActed((a) => {
+          const n = { ...a };
+          delete n[r.id];
+          return n;
+        });
+        setFailed((f) => ({ ...f, [r.id]: res.error || "failed" }));
+      }
+    }).catch((e) => {
+      setActed((a) => {
+        const n = { ...a };
+        delete n[r.id];
+        return n;
+      });
+      setFailed((f) => ({ ...f, [r.id]: String(e && e.message || e) }));
+    });
+  };
+  const visible = requests.filter((r) => !acted[r.id]);
+  if (!visible.length)
     return null;
-  return /* @__PURE__ */ React.createElement("div", { style: { padding: "4px 0 8px" } }, /* @__PURE__ */ React.createElement(Section, { label: T.requests, count: requests.length, style: { margin: "4px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 6 } }, requests.map((r) => /* @__PURE__ */ React.createElement("div", { key: r.id, style: {
+  return /* @__PURE__ */ React.createElement("div", { style: { padding: "4px 0 8px" } }, /* @__PURE__ */ React.createElement(Section, { label: T.requests, count: visible.length, style: { margin: "4px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 6 } }, visible.map((r) => /* @__PURE__ */ React.createElement("div", { key: r.id, style: {
     padding: "9px 10px",
     borderRadius: 8,
     background: "var(--panel-2)",
@@ -1285,7 +1315,7 @@ function RequestsBlock({ T, requests, onAct }) {
     display: "flex",
     flexDirection: "column",
     gap: 8
-  } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkIdenticon, { seed: r.carrier, size: 26, radius: 6 }), /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement(Mono, { size: 12, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, "via ", r.via, " \xB7 ", r.time))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => onAct(r.id, "accept"), style: { flex: 1 } }, T.accept), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "x", size: "sm", onClick: () => onAct(r.id, "reject"), style: { flex: 1 } }, T.reject))))));
+  } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkIdenticon, { seed: r.carrier, size: 26, radius: 6 }), /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement(Mono, { size: 12, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, "via ", r.via, " \xB7 ", r.time))), failed[r.id] && /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 11, color: "var(--danger)" } }, failed[r.id]), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => act(r, "accept"), style: { flex: 1 } }, T.accept), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "x", size: "sm", onClick: () => act(r, "reject"), style: { flex: 1 } }, T.reject))))));
 }
 function PeerRow({ peer, T, active, onClick }) {
   const name = peer.alias || peer.userId;
@@ -5031,7 +5061,10 @@ function DkApp() {
   const onAct = (id, kind) => {
     const r = requests.find((x) => x.id === id);
     const uid = r && r.userid || id;
-    (kind === "accept" ? dkApi.accept(uid) : dkApi.reject(uid)).then(data.refresh);
+    return (kind === "accept" ? dkApi.accept(uid) : dkApi.reject(uid)).then((res) => {
+      data.refresh();
+      return res;
+    });
   };
   const onRemove = (peer) => {
     dkApi.remove(peer.id).then(data.refresh);

package/dist/embedded-host.js

@@ -62,6 +62,7 @@ export class EmbeddedHost {
      *  order, so a new message can never overtake an older one whose ACK is
      *  still pending. Entry removed when the chain drains. */
     #sendChains = new Map();
+    #sweepTimer = null;
     /** Friend requests held for manual accept when auto-accept is off. */
     #pending = new Map();
     /** Inbound call signals as a broadcast ring: every poller reads at its own
@@ -143,6 +144,50 @@ export class EmbeddedHost {
         await this.#node.start();
         await this.#node.join();
         await mkdir(this.downloadsDir, { recursive: true }).catch(() => undefined);
+        // The sweep is what actually makes "queued" resolve.
+        //
+        // Flushing only on the connected EDGE looked right and was not: if the
+        // peer was already connected when the message was queued, that edge had
+        // long since passed and nothing ever tried again — the message sat queued
+        // while the friend showed online. Ask it the other way round on a timer:
+        // who has mail waiting, and can we reach them now. Level-triggered, so a
+        // missed or early event costs one interval instead of the message.
+        this.#sweepTimer = setInterval(() => {
+            if (this.#sweeping)
+                return;
+            this.#sweeping = true;
+            void (async () => {
+                try {
+                    for (const uid of this.#messages.queuedPeers()) {
+                        if (this.#sessionUsable(uid))
+                            await this.#chainFlush(uid);
+                    }
+                }
+                finally {
+                    this.#sweeping = false;
+                }
+            })();
+        }, 8000);
+        this.#sweepTimer.unref?.();
+    }
+    #sweeping = false;
+    /** A session that can actually carry traffic right now. */
+    #sessionUsable(pubkey) {
+        try {
+            const st = this.#node.sessionStatus(pubkey);
+            return !!(st && st.established && (st.udpRemote || st.hasTcpRoute));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Queue a flush behind whatever that peer already has in flight, so a
+     *  sweep and a send can never interleave and reorder the outbox. */
+    #chainFlush(pubkey) {
+        const prev = this.#sendChains.get(pubkey) ?? Promise.resolve();
+        const job = prev.then(() => this.#flushOutbox(pubkey).catch(() => { }));
+        this.#sendChains.set(pubkey, job.catch(() => { }));
+        return job;
     }
     #wire() {
         this.#node.on("message", (pubkey, text, via) => {
@@ -152,6 +197,9 @@ export class EmbeddedHost {
             this.#messages.append(pubkey, "in", text, Date.now(), undefined, via);
             this.#meta.ensure(pubkey);
             this.#events.emit("event", { type: "chat", userid: pubkey, dir: "in" });
+            // Hearing from them proves the session carries traffic — better
+            // evidence than any status flag, so use it.
+            void this.#chainFlush(pubkey);
         });
         this.#node.on("friend-request", (req) => {
             const userid = req.userid ?? req.pubkey;
@@ -179,15 +227,8 @@ export class EmbeddedHost {
             // sat visibly stuck despite the peer being online. One delayed retry
             // covers that gap; the per-send chain and later reconnects cover the
             // rest.
-            if (e.status === "connected") {
-                void this.#flushOutbox(e.pubkey)
-                    .catch(() => { })
-                    .then(() => {
-                    if (this.#messages.queuedOutgoing(e.pubkey).length === 0)
-                        return;
-                    return new Promise((r) => setTimeout(r, 4000)).then(() => this.#flushOutbox(e.pubkey).catch(() => { }));
-                });
-            }
+            if (e.status === "connected")
+                void this.#chainFlush(e.pubkey); // fast path
         });
         this.#node.on("call-signal", (evt) => {
             this.#callLog.push({
@@ -322,6 +363,10 @@ export class EmbeddedHost {
         return () => this.#events.off("event", fn);
     }
     async stop() {
+        if (this.#sweepTimer) {
+            clearInterval(this.#sweepTimer);
+            this.#sweepTimer = null;
+        }
         // Stop the peer FIRST, then release the lock. The reverse order would open
         // a window where a daemon could start while our peer is still live.
         await this.#node.stop();
@@ -405,16 +450,38 @@ export class EmbeddedHost {
                     }),
                 };
             }
-            case "friend-request":
-                await this.#node.sendFriendRequest(String(req.address ?? ""), req.hello);
+            case "friend-request": {
+                // sendFriendRequest waits for our own announce to store and then walks
+                // the DHT toward the target — tens of seconds is normal. server.ts
+                // already races this with a 2.5s timer so the HTTP layer cannot hang,
+                // but a validation error has to come back fast to be useful, so do the
+                // cheap check here and let the slow part run unattended.
+                const address = String(req.address ?? "");
+                if (!address)
+                    throw new Error("friend-request requires an address");
+                void this.#node
+                    .sendFriendRequest(address, req.hello)
+                    .catch((e) => this.#logger.info(`friend-request to ${address.slice(0, 8)} failed: ${e.message}`));
                 return {};
+            }
             case "friends-pending":
                 return { pending: [...this.#pending.values()] };
             case "friends-accept": {
                 const entry = this.#pending.get(uid);
-                if (entry) {
+                if (!entry)
+                    return {};
+                // Drop it from pending BEFORE the node call, and answer without
+                // waiting on anything the network owns. The request card is rendered
+                // from a poll, so awaiting here left the user clicking Accept with
+                // nothing happening on screen at all — the same class of bug as
+                // chat-send's, which this file already fixed for messages.
+                this.#pending.delete(uid);
+                try {
                     await this.#node.acceptFriendRequest(entry.pubkey);
-                    this.#pending.delete(uid);
+                }
+                catch (e) {
+                    this.#pending.set(uid, entry); // refused: leave state as it was
+                    throw e;
                 }
                 return {};
             }

package/dist/message-store.d.ts

@@ -66,6 +66,9 @@ export declare class MessageStore {
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */
+    /** Every peer with outgoing mail still waiting, so the outbox sweep does
+     *  not have to ask per friend. */
+    queuedPeers(): string[];
     queuedOutgoing(peer: string): ChatMessage[];
     /** Append a file-transfer entry (shown as a file chip in the UI). */
     appendFile(peer: string, dir: "in" | "out", file: {

package/dist/message-store.js

@@ -83,6 +83,16 @@ export class MessageStore {
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */
+    /** Every peer with outgoing mail still waiting, so the outbox sweep does
+     *  not have to ask per friend. */
+    queuedPeers() {
+        const out = [];
+        for (const [peer, arr] of this.byPeer) {
+            if (arr.some((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued")))
+                out.push(peer);
+        }
+        return out;
+    }
     queuedOutgoing(peer) {
         const arr = this.byPeer.get(peer) ?? [];
         return arr.filter((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued"));

package/dist/peer-host.d.ts

@@ -46,6 +46,8 @@ export interface OpenPeerHostOptions {
     /** Force a backend instead of auto-detecting. Mainly for testing the
      *  embedded path on a machine that also runs a daemon. */
     force?: BackendKind;
+    /** How long `force: "daemon"` waits for the daemon socket. Default 60s. */
+    waitForDaemonMs?: number;
 }
 /**
  * Pick a backend.

package/dist/peer-host.js

@@ -77,7 +77,35 @@ export async function openPeerHost(opts) {
         return { host: new DaemonHost(dataDir), why: `decentlan daemon at ${dataDir}` };
     }
     if (opts.force === "daemon") {
-        throw new Error(`--backend daemon was requested but no decentlan daemon is running (looked for ${ipcSocketPath(dataDir)}).`);
+        // Wait rather than die.
+        //
+        // A supervised beagle (pm2, systemd) routinely starts BEFORE the daemon it
+        // is meant to attach to. Throwing there turned a boot-order race into a
+        // permanent problem: beagle fell back to embedded, took <dataDir>/daemon.pid,
+        // and from then on `agentnet service restart` refused to start the daemon
+        // because a live process already held the identity — which is why upgrading
+        // needed a pm2 stop / restart / pm2 start dance instead of one command.
+        //
+        // Explicit --backend daemon means "this box's identity belongs to the
+        // daemon". Honour that by waiting for it to appear.
+        const waitMs = Math.max(0, opts.waitForDaemonMs ?? 60_000);
+        const deadline = Date.now() + waitMs;
+        let waited = false;
+        while (!daemonIsRunning(dataDir)) {
+            if (Date.now() >= deadline) {
+                throw new Error(`--backend daemon was requested but no decentlan daemon appeared within ${Math.round(waitMs / 1000)}s ` +
+                    `(looked for ${ipcSocketPath(dataDir)}).`);
+            }
+            if (!waited) {
+                waited = true;
+                console.log(`waiting up to ${Math.round(waitMs / 1000)}s for the decentlan daemon at ${ipcSocketPath(dataDir)}…`);
+            }
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+        return {
+            host: new DaemonHost(dataDir),
+            why: waited ? `decentlan daemon at ${dataDir} (after waiting)` : `decentlan daemon at ${dataDir}`,
+        };
     }
     // Reuse decentlan's identity when it exists so friends carry over — this is
     // the same node, not a new one. The daemon is not running, so nothing else

package/dist/server.js

@@ -120,13 +120,43 @@ async function ensSignAndSet(call, record) {
 // nftid=<punk id> on the beagles.eth name. Proxied server-side (browser can't
 // reach the origin's port cross-origin reliably); NOTE the upstream's TLS cert
 // must be valid — renew it when these routes start failing.
-const PUNKS_API_URL = process.env.PUNKS_API_URL || "https://app.beagle.chat:1337";
+// api.beagle.chat/punksapi, NOT app.beagle.chat:1337. That name was repointed
+// to GitHub Pages when the browser client took it over, so this default aimed
+// at a host that serves nothing on 1337 and every punk avatar in the desktop
+// app silently fell back to an identicon. The service itself never moved — it
+// is the same box, now reached through Caddy on 443 instead of its own TLS
+// listener, so there is no second certificate to keep alive.
+// Endpoint of last resort. The real one comes from bgservers.json (punksApi)
+// via punksBase() below, so the host can move without shipping a new build —
+// which is the failure this whole comment exists because of: app.beagle.chat
+// :1337 was baked in here, the name was repointed at GitHub Pages, and every
+// punk avatar in the app quietly became an identicon.
+const PUNKS_API_URL = process.env.PUNKS_API_URL || "https://api.beagle.chat/punksapi";
+const BGSERVERS_URL = process.env.BGSERVERS_URL || "https://beagle.chat/assets/bgservers.json";
+let punksBaseCache = null;
+function punksBase() {
+    if (process.env.PUNKS_API_URL)
+        return Promise.resolve(process.env.PUNKS_API_URL);
+    if (!punksBaseCache) {
+        punksBaseCache = (async () => {
+            try {
+                const cfg = (await fetchDiscoverJson(BGSERVERS_URL));
+                const u = cfg?.punksApi?.[0]?.url;
+                if (typeof u === "string" && u)
+                    return u.replace(/\/+$/, "");
+            }
+            catch { /* fall through to the built-in default */ }
+            return PUNKS_API_URL;
+        })();
+    }
+    return punksBaseCache;
+}
 const punkCache = new Map(); // punk id → JSON; immutable set
 async function punksFetch(path) {
     const ctl = new AbortController();
     const timer = setTimeout(() => ctl.abort(), 10_000);
     try {
-        const r = await fetch(`${PUNKS_API_URL}${path}`, { signal: ctl.signal });
+        const r = await fetch(`${await punksBase()}${path}`, { signal: ctl.signal });
         if (!r.ok)
             throw new Error(`punks upstream ${r.status}`);
         return await r.json();

package/package.json

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