@decentnetwork/beagle 0.1.61 → 0.1.64

package/dist/embedded-host.d.ts

@@ -18,6 +18,9 @@ export interface EmbeddedHostOptions {
     }[];
     nickname?: string;
     statusMessage?: string;
+    /** Our CryptoPunks id, advertised to friends in the userinfo `gender`
+     *  field — the only avatar path that does not need a server. */
+    punkId?: number;
     autoAcceptFriends: boolean;
     onProfileChange?: (info: {
         name?: string;

package/dist/embedded-host.js

@@ -138,6 +138,9 @@ export class EmbeddedHost {
             expressNodes: this.#opts.expressNodes,
             nickname: this.#opts.nickname,
             statusMessage: this.#opts.statusMessage,
+            // Advertised from startup, not only after a profile edit — otherwise a
+            // restart silently stops telling friends what our avatar is.
+            punkId: this.#opts.punkId,
             fileResumeDir: resolve(this.#opts.configDir, "file-resume"),
         });
         this.#wire();
@@ -402,7 +405,9 @@ export class EmbeddedHost {
                 const id = this.#node.identity();
                 return {
                     identity: id,
-                    node: { name: this.#opts.nickname ?? "", backend: "embedded", autoAccept: this.#autoAccept },
+                    // punkId so the UI can report what is actually being advertised,
+                    // which is not necessarily what beagles.eth says.
+                    node: { name: this.#opts.nickname ?? "", backend: "embedded", autoAccept: this.#autoAccept, punkId: this.#opts.punkId ?? null },
                     // No TUN in this backend — say so explicitly rather than omitting
                     // the key, so the UI can distinguish "no LAN" from "unknown".
                     tun: null,
@@ -448,6 +453,10 @@ export class EmbeddedHost {
                                 f.status === "online" ||
                                 this.#messages.hasInbound(f.carrierId),
                             lastSeen: f.acceptedAt,
+                            // The avatar they advertised over Carrier (userinfo `gender`).
+                            // Peer-to-peer, so it works for a friend who never registered a
+                            // beagles.eth name — until now that meant an identicon.
+                            punkId: f.punkId ?? null,
                             pinned: meta?.pinned ?? false,
                             lastMessage: lastMsg ? { dir: lastMsg.dir, text: lastMsg.text, ts: lastMsg.ts } : undefined,
                             unread: this.#messages.unreadCount(f.carrierId, meta?.lastReadTs ?? 0),
@@ -511,12 +520,21 @@ export class EmbeddedHost {
                 this.#meta.setAlias(uid, req.alias);
                 return {};
             case "set-profile": {
-                const info = { name: req.name, description: req.description };
+                const info = {
+                    name: req.name,
+                    description: req.description,
+                    // null clears, undefined leaves alone. setUserInfo re-sends the
+                    // profile to every established friend, so a new avatar lands now
+                    // rather than on their next reconnect.
+                    punkId: req.punkId === undefined ? undefined : (req.punkId === null ? null : Number(req.punkId)),
+                };
                 this.#node.setUserInfo(info);
                 if (info.name)
                     this.#opts.nickname = info.name;
                 if (info.description !== undefined)
                     this.#opts.statusMessage = info.description;
+                if (info.punkId !== undefined)
+                    this.#opts.punkId = info.punkId ?? undefined;
                 this.#opts.onProfileChange?.(info);
                 return {};
             }

package/dist/server.js

@@ -273,7 +273,14 @@ function installMode() {
         return "npx";
     if (BEAGLE_ROOT.includes(join("node_modules", "@decentnetwork", "beagle")))
         return "global";
-    return "dev";
+    // "dev" has to be PROVEN, not assumed. It used to be the fallthrough for
+    // any layout this function did not recognise, so a user with a perfectly
+    // ordinary install was told to run `git pull` — against a private repo they
+    // cannot clone, with no other option offered. A dead end presented as
+    // instructions.
+    if (existsSync(join(BEAGLE_ROOT, ".git")))
+        return "dev";
+    return "unknown";
 }
 async function npmLatest(pkg) {
     const ctl = new AbortController();
@@ -660,6 +667,10 @@ const fmtTime = (ts) => {
     return `${d.getDate()} ${["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getMonth()]}`;
 };
 const viaFromTransport = (t) => t === "udp" || t === "both" ? "direct" : t === "tcp-relay" ? "relay" : null;
+// What we last told the daemon to advertise. Module-scoped on purpose: the
+// value is per-process, and re-sending it on every /api/desktop poll would
+// re-push the profile to every friend several times a second.
+let lastAdvertisedPunk;
 export function startBeagleServer(opts) {
     const host = opts.listenHost ?? "127.0.0.1";
     const port = opts.listenPort ?? 8765;
@@ -685,6 +696,32 @@ export function startBeagleServer(opts) {
     const handler = async (req, res) => {
         try {
             const url = (req.url || "/").split("?")[0];
+            // Let Sign-in-with-Beagle pages (meet, billing, …) detect this daemon
+            // from a public https origin. Chrome Local Network Access blocks the
+            // probe unless we answer the private-network preflight.
+            const detect = url === "/api/state" || url === "/api/ping" || url === "/connect";
+            if (detect) {
+                const origin = String(req.headers.origin || "");
+                if (origin) {
+                    res.setHeader("Access-Control-Allow-Origin", origin);
+                    res.setHeader("Vary", "Origin");
+                }
+                else {
+                    res.setHeader("Access-Control-Allow-Origin", "*");
+                }
+                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                res.setHeader("Access-Control-Allow-Private-Network", "true");
+                if (req.method === "OPTIONS") {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+            }
+            if (req.method === "GET" && url === "/api/ping") {
+                sendJson(res, 200, { ok: true });
+                return;
+            }
             // Desktop UI bundle (the design). Falls back to the classic page when
             // the bundle hasn't been built (dist/ui/desktop missing).
             const desktopIndex = join(DESKTOP_DIR, "index.html");
@@ -739,7 +776,7 @@ export function startBeagleServer(opts) {
             // LOCALHOST-ONLY: the popup always runs in the local user's browser
             // (localhost), so binding the UI to a LAN IP must never let a remote
             // host request signatures with this identity.
-            if (url === "/connect" || url === "/api/connect-approve") {
+            if (url === "/connect" || url === "/api/connect-approve" || url === "/api/launch-token") {
                 if (!isLocalRequest(req)) {
                     res.writeHead(403, { "content-type": "text/plain" });
                     res.end("Sign in with Beagle is available only on this machine (localhost).");
@@ -804,6 +841,42 @@ export function startBeagleServer(opts) {
                 sendJson(res, 200, { ok: true, userid, address, sig: r.data?.sig ?? "", name, avatar, punkId });
                 return;
             }
+            // Mint the "launch an app as me" assertion the Apps tab puts in an app's
+            // URL fragment, so someone opening an app from their own client is not
+            // asked to sign in to it. LOCALHOST-ONLY like /connect: it is a
+            // signature with this identity.
+            if (req.method === "POST" && url === "/api/launch-token") {
+                const body = await readBody(req);
+                const target = validateOrigin(body.origin);
+                if (!target) {
+                    sendJson(res, 400, { ok: false, error: "invalid origin" });
+                    return;
+                }
+                const ts = Date.now();
+                // A DIFFERENT prefix from decent-auth on purpose: an assertion minted
+                // here must never be replayable as a "a site asked me to sign in"
+                // proof, nor the reverse.
+                const signed = await opts.call({ op: "sign", text: `decent-launch\n${target}\n${ts}` });
+                if (!signed.ok) {
+                    sendJson(res, 502, { ok: false, error: signed.error || "sign failed" });
+                    return;
+                }
+                const diag = await opts.call({ op: "diag" });
+                const d = (diag.ok ? diag.data : {}) ?? {};
+                const identity = d.identity ?? {};
+                const node = d.node ?? {};
+                sendJson(res, 200, {
+                    ok: true,
+                    v: 1,
+                    userid: signed.data?.userid ?? identity.userid ?? "",
+                    address: identity.address ?? "",
+                    name: node.name ?? "",
+                    punkId: null,
+                    ts,
+                    sig: signed.data?.sig ?? "",
+                });
+                return;
+            }
             // ── beagles.eth name registration ──
             // Register/update this node's *.beagles.eth name and bind wallet
             // addresses into the record. The write routes trigger identity
@@ -1530,6 +1603,11 @@ export function startBeagleServer(opts) {
                     ok: true,
                     checkedAt: Date.now(),
                     mode: installMode(),
+                    // WHO owns the peer version. With the daemon backend it is the
+                    // agentnet/lan process, not this app — so "update beagle" cannot
+                    // move that row, and telling someone to rebuild beagle (or pull the
+                    // peer repo) is the wrong remedy for it. The lan update is.
+                    peerOwner: (opts.lanHost?.kind ?? "embedded") === "daemon" ? "daemon" : "embedded",
                     updates: [
                         row(BEAGLE_PKG, beagleVersion(), beagleLatest),
                         // The peer the BACKEND is running — a daemon that has been updated
@@ -1567,6 +1645,10 @@ export function startBeagleServer(opts) {
                     sendJson(res, 400, { ok: false, error: "running from a source checkout — update with: git pull && npm run build" });
                     return;
                 }
+                // Layout we do not recognise: try the thing that works for almost
+                // everyone rather than refusing. If it genuinely cannot install, the
+                // npm error says so — which is still more use than a git command
+                // against a repo the user has no access to.
                 if (mode === "npx") {
                     // npx with @latest re-resolves on every launch: restarting IS the update.
                     sendJson(res, 200, { ok: true, npx: true });
@@ -1644,6 +1726,20 @@ export function startBeagleServer(opts) {
                 ]);
                 const d = (diag.ok ? diag.data : {}) ?? {};
                 const identity = d.identity ?? {};
+                // A desktop install has no locally-picked punk: its avatar is whatever
+                // it registered on beagles.eth. Advertise THAT over Carrier, so an iOS
+                // friend sees a picture instead of nothing. Sent only when the value
+                // CHANGES — set-profile re-pushes the profile to every established
+                // friend, and doing that on every poll would be a packet storm.
+                const myPunk = ensPub.get(identity.userid ?? "")?.punkId ?? null;
+                // Only ever PUSH a real punk, never a null. A null here means "nothing
+                // registered on beagles.eth", which is not the same as "no avatar" —
+                // pushing it wiped a punk set directly through /api/set-profile, on
+                // the very next poll. Registration seeds the avatar; it does not own it.
+                if (myPunk != null && myPunk !== lastAdvertisedPunk) {
+                    lastAdvertisedPunk = myPunk;
+                    void opts.call({ op: "set-profile", punkId: myPunk }).catch(() => undefined);
+                }
                 const tun = d.tun ?? {};
                 const node = d.node ?? {};
                 const diagFriends = d.friends ?? [];
@@ -1699,7 +1795,7 @@ export function startBeagleServer(opts) {
                     // toggle rather than showing a state it cannot know.
                     autoAccept: typeof node.autoAccept === "boolean" ? node.autoAccept : null,
                     avatarUrl: ensPub.get(identity.userid ?? "")?.avatarUrl ?? null,
-                    punkId: ensPub.get(identity.userid ?? "")?.punkId ?? null,
+                    punkId: myPunk ?? node.punkId ?? null,
                     // The UI compares this against its baked-in __DK_UI_VERSION and
                     // reloads itself when they differ — an open tab otherwise runs a
                     // stale bundle forever after a beagle update (multi-tab call fixes
@@ -1740,7 +1836,11 @@ export function startBeagleServer(opts) {
                         lastTs: lm?.ts ?? 0,
                         wire: "163",
                         avatarUrl: ensPub.get(uid)?.avatarUrl ?? null,
-                        punkId: ensPub.get(uid)?.punkId ?? null,
+                        // What they advertised over Carrier wins over the directory: it is
+                        // what they are using on their device right now, it needs no
+                        // gateway, and it is the only avatar a friend who never registered
+                        // a beagles.eth name will ever have.
+                        punkId: f.punkId ?? ensPub.get(uid)?.punkId ?? null,
                     };
                 });
                 const pend = pending.ok ? (pending.data?.pending ?? []) : [];
@@ -1973,8 +2073,10 @@ export function startBeagleServer(opts) {
                 return;
             }
             if (req.method === "POST" && url === "/api/set-profile") {
-                const { name, description } = await readBody(req);
-                const r = await opts.call({ op: "set-profile", name, description });
+                // punkId passes through so an avatar can be set without a beagles.eth
+                // registration — the daemon advertises it over Carrier either way.
+                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);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.61",
+  "version": "0.1.64",
   "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",
@@ -27,13 +27,13 @@
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.283",
-    "@decentnetwork/peer": "^0.1.141",
+    "@decentnetwork/peer": "0.1.143",
     "@decentnetwork/peer-webrtc": "^0.2.16",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@decentnetwork/beagle-ui": "0.1.2",
+    "@decentnetwork/beagle-ui": "0.2.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
     "@types/yargs": "^17.0.32",