@decentnetwork/beagle 0.1.90 → 0.1.92

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.90";
+window.__DK_UI_VERSION="0.1.92";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -2443,7 +2443,7 @@ ${peer.address}`
     const register = () => {
       const l = label.trim();
       if (l)
-        post("/api/ens-register", { name: l, displayName: me.name });
+        post("/api/ens-register", { name: l, displayName: me.name, description: me.description || "" });
     };
     const bind = (chain, address) => post("/api/ens-bind-wallet", { chain, address });
     const bindEth = async () => {
@@ -4755,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:",
@@ -4937,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");
@@ -74,6 +75,29 @@ async function ensFetchJson(path) {
         clearTimeout(timer);
     }
 }
+/** The record beagle writes for its own name: what the profile page shows
+ *  (displayName, description) on top of whatever the record already held —
+ *  wallet binds, socials, avatar, referee — so a profile edit never strips a
+ *  bind. Shared by /api/ens-register and /api/set-profile; the two used to
+ *  build it separately, and only register did, which is why a status message
+ *  edited in Profile never reached https://app.beagle.chat/<name>. */
+function ensProfileRecord(identity, name, carried, displayName, description) {
+    return {
+        name,
+        owner: identity.userid,
+        addresses: carried?.addresses ?? {},
+        texts: {
+            ...(carried?.texts ?? {}),
+            description,
+            displayName,
+            carrierAddress: identity.address,
+            carrierUserId: identity.userid,
+        },
+        referee: carried?.referee ?? "",
+        nft: carried?.nft ?? "",
+        nftid: carried?.nftid ?? 0,
+    };
+}
 /** Sign a name record with the Carrier identity and POST it to the gateway.
  *  The record itself (as a JSON string) is what gets signed; the gateway
  *  re-parses `signature.message` and verifies against `owner` inside it. */
@@ -268,7 +292,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")))
@@ -1218,24 +1242,15 @@ export function startBeagleServer(opts) {
                 const mine = existing ?? (await ensFetchJson(`/getAddress/${encodeURIComponent(identity.userid)}`));
                 const carried = mine && mine.owner === identity.userid ? mine : null;
                 const displayName = (typeof body.displayName === "string" && body.displayName.trim().slice(0, 64)) || label;
+                // The description IS the Profile status message. It used to fall
+                // through to "<name>'s Beagle Chat Profile", a placeholder that then
+                // sat on the public page as if the person had written it.
+                const node = (diag.ok ? diag.data?.node : null) ?? {};
                 const description = (typeof body.description === "string" && body.description.trim().slice(0, 200)) ||
+                    (typeof node.statusMessage === "string" && node.statusMessage.trim().slice(0, 200)) ||
                     carried?.texts?.description ||
-                    `${displayName}'s Beagle Chat Profile`;
-                const r = await ensSignAndSet(opts.call, {
-                    name: fullName,
-                    owner: identity.userid,
-                    addresses: carried?.addresses ?? {},
-                    texts: {
-                        ...(carried?.texts ?? {}),
-                        description,
-                        displayName,
-                        carrierAddress: identity.address,
-                        carrierUserId: identity.userid,
-                    },
-                    referee: carried?.referee ?? "",
-                    nft: carried?.nft ?? "",
-                    nftid: carried?.nftid ?? 0,
-                });
+                    "";
+                const r = await ensSignAndSet(opts.call, ensProfileRecord({ userid: identity.userid, address: identity.address }, fullName, carried, displayName, description));
                 sendJson(res, r.ok ? 200 : 502, r.ok ? { ok: true, name: fullName } : { ok: false, error: r.error });
                 return;
             }
@@ -1796,10 +1811,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
@@ -2249,6 +2271,31 @@ export function startBeagleServer(opts) {
                 const { name, description, punkId } = await readBody(req);
                 const r = await opts.call({ op: "set-profile", name, description, punkId });
                 sendJson(res, r.ok ? 200 : 400, r);
+                // Also the public record, when this identity registered a beagles.eth
+                // name here: displayName and description on the record ARE the
+                // profile name and status message, and editing them in Profile used
+                // to change only what Carrier advertises, never the page. Best
+                // effort, after the reply: the gateway being down must not turn a
+                // profile save into a failure. A punk-only call (the avatar advertise
+                // on poll) carries neither field and leaves the record alone.
+                if (r.ok && (typeof name === "string" || typeof description === "string")) {
+                    void (async () => {
+                        const diag = await opts.call({ op: "diag" });
+                        const identity = (diag.ok ? diag.data?.identity : null) ?? {};
+                        if (!identity.userid || !identity.address)
+                            return;
+                        const mine = await ensFetchJson(`/getAddress/${encodeURIComponent(identity.userid)}`);
+                        if (!mine || mine.owner !== identity.userid)
+                            return; // not registered here — nothing to sign
+                        const displayName = (typeof name === "string" && name.trim().slice(0, 64)) ||
+                            mine.texts?.displayName ||
+                            mine.name.replace(/\.beagles\.eth$/, "");
+                        const desc = typeof description === "string" ? description.trim().slice(0, 200) : (mine.texts?.description ?? "");
+                        const w = await ensSignAndSet(opts.call, ensProfileRecord({ userid: identity.userid, address: identity.address }, mine.name, mine, displayName, desc));
+                        if (!w.ok)
+                            console.warn(`[ens] profile saved, but the ${mine.name} record was not updated: ${w.error}`);
+                    })().catch((e) => console.warn(`[ens] record update after profile save failed: ${e.message}`));
+                }
                 return;
             }
             if (req.method === "GET" && url === "/api/routes") {

package/package.json

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