@decentnetwork/beagle 0.1.89 → 0.1.91

package/dist/cli.js

@@ -8,7 +8,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { startBeagleServer } from "./server.js";
+import { startBeagleServer, installMode } from "./server.js";
+import { isSupervised, relaunchSelf, waitForPredecessor } from "./relaunch.js";
 import { openPeerHost, defaultConfigDir, decentlanCarrierDir, makeDaemonHost } from "./peer-host.js";
 import { SwitchablePeerHost } from "./lan-handoff.js";
 import { loadNodeConfig, saveAutoAccept } from "./node-config.js";
@@ -97,6 +98,9 @@ const resolveVer = (pkg) => {
 };
 async function main() {
     const args = parseArgs(process.argv.slice(2));
+    // Spawned by a predecessor restarting itself after an update: let it finish
+    // exiting before touching the identity lock or the port. No-op otherwise.
+    await waitForPredecessor();
     // Bootstrap list: prefer the user's decentlan config so both stacks agree on
     // the fleet, else fall back to the shipped defaults. A wrong list here is the
     // difference between "joins the network" and "silently alone".
@@ -189,6 +193,19 @@ async function main() {
         },
         listenHost: args.host,
         listenPort: args.port,
+        // After an update: stop the peer cleanly, then either let the supervisor
+        // relaunch us or, with none, spawn our own successor. The successor waits
+        // for this pid to be gone (waitForPredecessor above), so the identity
+        // lock and the port are free by the time it needs them.
+        onRestart: async () => {
+            await Promise.race([
+                peerHost.stop().catch(() => undefined),
+                new Promise((r) => setTimeout(r, 5000)),
+            ]);
+            if (!isSupervised())
+                relaunchSelf(installMode());
+            process.exit(0);
+        },
     });
     const shutdown = async () => {
         await peerHost.stop().catch(() => undefined);

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.89";
+window.__DK_UI_VERSION="0.1.91";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -380,11 +380,13 @@ window.__DK_UI_VERSION="0.1.89";
       const t = setInterval(refresh, 2500);
       return () => clearInterval(t);
     }, [refresh]);
+    const inFlight = React.useRef(/* @__PURE__ */ new Set());
     const loadThread = React.useCallback(async (peerId) => {
-      if (!peerId)
+      if (!peerId || inFlight.current.has(peerId))
         return;
+      inFlight.current.add(peerId);
       try {
-        const d = await dkGet("/api/chat-history?peer=" + encodeURIComponent(peerId));
+        const d = await dkGet("/api/chat-history?peer=" + encodeURIComponent(peerId) + "&limit=200");
         const arr = d.chats && d.chats[peerId] || [];
         await prefetchThreadFiles(arr);
         const msgs = arr.map((m) => ({
@@ -417,6 +419,8 @@ window.__DK_UI_VERSION="0.1.89";
         const withDay = msgs.length ? [{ day: dkDayLabel(arr[0].ts) }].concat(msgs) : [];
         setThreads((t) => Object.assign({}, t, { [peerId]: withDay }));
       } catch (e) {
+      } finally {
+        inFlight.current.delete(peerId);
       }
     }, []);
     return Object.assign({}, snap, { threads, refresh, loadThread });
@@ -4751,7 +4755,7 @@ ${peer.address}`
       updRestart: "Restart",
       updBusy: "Updating\u2026 (about a minute)",
       updDone: "Updated \u2014 restart to apply.",
-      updRestarting: "Restarting\u2026 this page reloads when it\u2019s back. (If beagle was started by hand in a terminal, run it again.)",
+      updRestarting: "Restarting\u2026 this page reloads when it\u2019s back. (If it has not come back after a minute, run beagle again.)",
       updNpx: "Running via npx \u2014 restarting picks up the latest version automatically.",
       updDev: "Running from a source checkout \u2014 update with:",
       updPeerDaemon: "The peer version belongs to the running agentnet daemon, not to this app. Update it with:",
@@ -4933,7 +4937,7 @@ ${peer.address}`
       updRestart: "\u91CD\u542F",
       updBusy: "\u66F4\u65B0\u4E2D\u2026(\u7EA6\u4E00\u5206\u949F)",
       updDone: "\u66F4\u65B0\u5B8C\u6210\u2014\u2014\u91CD\u542F\u540E\u751F\u6548\u3002",
-      updRestarting: "\u6B63\u5728\u91CD\u542F\u2026\u5B8C\u6210\u540E\u672C\u9875\u4F1A\u81EA\u52A8\u5237\u65B0\u3002(\u5982\u679C beagle \u662F\u5728\u7EC8\u7AEF\u91CC\u624B\u52A8\u542F\u52A8\u7684,\u8BF7\u91CD\u65B0\u8FD0\u884C\u4E00\u6B21\u3002)",
+      updRestarting: "\u6B63\u5728\u91CD\u542F\u2026\u5B8C\u6210\u540E\u672C\u9875\u4F1A\u81EA\u52A8\u5237\u65B0\u3002(\u5982\u679C\u4E00\u5206\u949F\u540E\u8FD8\u6CA1\u56DE\u6765,\u8BF7\u91CD\u65B0\u8FD0\u884C\u4E00\u6B21 beagle\u3002)",
       updNpx: "\u4F60\u662F\u7528 npx \u8FD0\u884C\u7684\u2014\u2014\u91CD\u542F\u5373\u81EA\u52A8\u83B7\u53D6\u6700\u65B0\u7248\u3002",
       updDev: "\u5F53\u524D\u4ECE\u6E90\u7801\u76EE\u5F55\u8FD0\u884C,\u8BF7\u624B\u52A8\u66F4\u65B0:",
       updPeerDaemon: "peer \u7684\u7248\u672C\u5C5E\u4E8E\u6B63\u5728\u8FD0\u884C\u7684 agentnet daemon,\u4E0D\u5C5E\u4E8E\u672C\u5E94\u7528\u3002\u8BF7\u7528\u8FD9\u6761\u547D\u4EE4\u66F4\u65B0:",

package/dist/relaunch.d.ts

@@ -0,0 +1,8 @@
+/** Something outside this process will restart it when it exits. */
+export declare function isSupervised(): boolean;
+/** Start the successor. Caller exits right after. */
+export declare function relaunchSelf(mode: "global" | "npx" | "dev" | "unknown"): void;
+/** In the successor: block until the process that spawned us has exited.
+ *  No-op when we were not spawned by relaunchSelf. Gives up after 20s rather
+ *  than hang forever behind a predecessor that will not die. */
+export declare function waitForPredecessor(): Promise<void>;

package/dist/relaunch.js

@@ -0,0 +1,85 @@
+// relaunch.ts — bring Beagle back after a self-update when nobody else will.
+//
+// "Restart" after an update used to be process.exit(0) and a hope: pm2,
+// launchd and systemd relaunch a process that exits, so under any of them
+// that was a restart. A `beagle` started by hand in a terminal has no such
+// minder — it exited and stayed exited, the page sat on "Restarting…"
+// forever, and the person had to notice and run it again (air-wli,
+// 2026-09-12). The dialog even admitted as much in parentheses.
+//
+// When no supervisor is detected, spawn our own successor before exiting:
+// the same node, the same script path (which after `npm i -g` now holds the
+// new version), the same arguments, detached so our exit does not take it
+// down. The successor is told our pid and waits for us to be gone before it
+// opens the peer or binds the port, so it never races us for the identity
+// lock or gets EADDRINUSE from a parent still shutting down.
+import { spawn } from "node:child_process";
+const WAIT_ENV = "BEAGLE_RELAUNCH_WAIT_PID";
+/** Set on a successor we spawned, and inherited by its successors in turn.
+ *  A detached child is reparented to pid 1, which looks exactly like a
+ *  launchd job — without this mark the SECOND update would have exited
+ *  and stayed exited, which is the bug this file exists to fix. */
+const SELF_ENV = "BEAGLE_SELF_RELAUNCHED";
+/** Something outside this process will restart it when it exits. */
+export function isSupervised() {
+    const env = process.env;
+    if (env[SELF_ENV])
+        return false; // we are our own minder
+    if (env.pm_id !== undefined)
+        return true; // pm2
+    if (env.INVOCATION_ID || env.JOURNAL_STREAM)
+        return true; // systemd
+    if (process.pid === 1)
+        return true; // a container with a restart policy
+    // launchd is the parent of every job it runs. A hand-started process in a
+    // terminal has the shell as its parent; only when that shell is gone does
+    // it get reparented to 1 — and then nobody was restarting it anyway, but a
+    // process that outlived its terminal is not one a person is watching, so
+    // exiting quietly is the lesser surprise.
+    if (process.platform === "darwin" && process.ppid === 1)
+        return true;
+    return false;
+}
+/** Start the successor. Caller exits right after. */
+export function relaunchSelf(mode) {
+    const args = process.argv.slice(2);
+    let cmd;
+    let cmdArgs;
+    if (mode === "npx") {
+        // argv[1] points into npx's cache of the OLD version. `@latest`
+        // re-resolves, which is the whole update for an npx user.
+        cmd = process.platform === "win32" ? "npx.cmd" : "npx";
+        cmdArgs = ["-y", "@decentnetwork/beagle@latest", ...args];
+    }
+    else {
+        cmd = process.execPath;
+        cmdArgs = [process.argv[1], ...args];
+    }
+    const child = spawn(cmd, cmdArgs, {
+        detached: true,
+        // Keep the terminal this was started from as the log, exactly as before.
+        stdio: "inherit",
+        env: { ...process.env, [WAIT_ENV]: String(process.pid), [SELF_ENV]: "1" },
+        shell: process.platform === "win32" && mode === "npx",
+    });
+    child.unref();
+}
+/** In the successor: block until the process that spawned us has exited.
+ *  No-op when we were not spawned by relaunchSelf. Gives up after 20s rather
+ *  than hang forever behind a predecessor that will not die. */
+export async function waitForPredecessor() {
+    const pid = Number(process.env[WAIT_ENV]);
+    delete process.env[WAIT_ENV];
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    const deadline = Date.now() + 20_000;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return; // ESRCH: gone. (EPERM cannot happen — same user, our own parent.)
+        }
+        await new Promise((r) => setTimeout(r, 100));
+    }
+}

package/dist/server.d.ts

@@ -1,4 +1,7 @@
 import type { IpcRequest, IpcResponse } from "./ipc.js";
+/** How this copy of beagle got onto disk — decides what "update" can do.
+ *  npx cache paths contain _npx AND node_modules, so test _npx first. */
+export declare function installMode(): "global" | "npx" | "dev" | "unknown";
 export interface BeagleServerOptions {
     /** Call the running daemon over IPC (injected so this module stays
      *  decoupled from the CLI's ipc client). */
@@ -35,6 +38,10 @@ export interface BeagleServerOptions {
         }>;
         cancelArm: () => Promise<string>;
     };
+    /** Called instead of process.exit(0) on /api/update-restart, so the
+     *  process that owns the peer can shut it down and relaunch itself when
+     *  no supervisor will (see relaunch.ts). */
+    onRestart?: () => void | Promise<void>;
     listenHost?: string;
     listenPort?: number;
     log?: (msg: string) => void;

package/dist/server.js

@@ -22,6 +22,7 @@ import yaml from "js-yaml";
 import { DEFAULT_EXITS } from "./exits.js";
 import * as peerAddr from "@decentnetwork/peer";
 import { bridgeRoster } from "./bridge-roster.js";
+import { isSupervised } from "./relaunch.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");
@@ -268,7 +269,7 @@ async function runningVersions(call) {
 }
 /** How this copy of beagle got onto disk — decides what "update" can do.
  *  npx cache paths contain _npx AND node_modules, so test _npx first. */
-function installMode() {
+export function installMode() {
     if (BEAGLE_ROOT.includes("_npx"))
         return "npx";
     if (BEAGLE_ROOT.includes(join("node_modules", "@decentnetwork", "beagle")))
@@ -1796,10 +1797,17 @@ export function startBeagleServer(opts) {
                     sendJson(res, 403, { ok: false, error: "restart only from this machine (localhost)" });
                     return;
                 }
-                sendJson(res, 200, { ok: true });
-                // Let the response flush, then exit 0: pm2/launchd/systemd restart the
-                // process; a bare `beagle` in a terminal just exits (the UI says so).
-                setTimeout(() => process.exit(0), 400);
+                sendJson(res, 200, { ok: true, supervised: isSupervised() });
+                // Let the response flush, then hand over. Under pm2/launchd/systemd an
+                // exit IS the restart; a bare `beagle` in a terminal relaunches itself
+                // (cli.ts onRestart) — it used to just exit and stay exited.
+                setTimeout(() => {
+                    if (!opts.onRestart) {
+                        process.exit(0);
+                        return;
+                    }
+                    void Promise.resolve(opts.onRestart()).catch(() => process.exit(0));
+                }, 400);
                 return;
             }
             // Public profile card for any userid (friend or directory row): what
@@ -2106,8 +2114,25 @@ export function startBeagleServer(opts) {
                 return;
             }
             if (req.method === "GET" && url === "/api/chat-history") {
-                const peer = new URL(req.url || "/", "http://x").searchParams.get("peer") || undefined;
-                const r = await opts.call({ op: "chat-history", userid: peer });
+                const q = new URL(req.url || "/", "http://x").searchParams;
+                const peer = q.get("peer") || undefined;
+                // A PAGE, never the whole thread. The UI re-polls the open
+                // conversation every 2.5s, and this used to ask for everything each
+                // time: a group with 2000 six-kilobyte bot reports is 12 MB of JSON
+                // per poll per tab, which the daemon could not push over IPC inside
+                // the 30s call timeout. While it tried, its socket stopped answering
+                // the 400ms liveness probe, Beagle declared it gone and dropped the
+                // backend, and the peer list came back empty — a blank chat panel
+                // caused by one busy group. Default 200 is a full screen and then
+                // some; `before` pages further back; the cap keeps a hand-written
+                // URL from recreating the problem. Both `userid` and `peer` are sent:
+                // the daemon reads the first, the embedded host the second, and with
+                // only `userid` the embedded host returned every thread in the store.
+                const lim = Number(q.get("limit") ?? 200);
+                const limit = Number.isFinite(lim) && lim > 0 ? Math.min(lim, 1000) : 200;
+                const bef = Number(q.get("before"));
+                const before = Number.isFinite(bef) && bef > 0 ? bef : undefined;
+                const r = await opts.call({ op: "chat-history", userid: peer, peer, before, limit });
                 sendJson(res, 200, r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
                 return;
             }

package/package.json

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