@decentnetwork/beagle 0.1.57 → 0.1.59

package/dist/bridge-roster.d.ts

@@ -0,0 +1,20 @@
+export interface RosterPeer {
+    userid: string;
+    address: string | null;
+    name: string | null;
+    descr: string | null;
+    punk: number | null;
+    online: boolean;
+    lastSeen: number;
+}
+/** Who else is on this bridge. Null when the bridge speaks the older protocol
+ *  and never issues a ticket — an absence, not an error. */
+export declare function bridgeRoster(wsUrl: string, keyFile: string, profile: {
+    name?: string;
+    descr?: string;
+    address?: string;
+}): Promise<{
+    bridge: string;
+    online: number;
+    peers: RosterPeer[];
+} | null>;

package/dist/bridge-roster.js

@@ -0,0 +1,105 @@
+// Reading a bridge's roster without using the bridge.
+//
+// A browser peer gets the roster because it already holds a bridge ticket: the
+// ticket is issued during the WebSocket handshake it has to do anyway to reach
+// a relay. A desktop peer connects to relays directly and never handshakes
+// with a bridge, so it has no ticket and the venue is invisible to it.
+//
+// It does not have to stay that way. The handshake proves one thing — that we
+// hold the secret key for the userid we claim — and that proof is XEdDSA over
+// a nonce, which this process can produce from its own keyfile. So we open a
+// WebSocket purely to complete the handshake, take the ticket, and close it.
+// No relay traffic ever crosses that socket; the bridge is a directory here,
+// not a transport.
+//
+// The alternative is the directory peer (add it as a friend, message it), and
+// that one is better for a client with no public bridge at all. This exists so
+// the desktop and the browser can render the SAME roster from the same shape,
+// which is what lets discover.jsx be one file instead of two.
+import { readFileSync } from "node:fs";
+import WebSocket from "ws";
+import { signDetached } from "@decentnetwork/peer";
+const HANDSHAKE_MS = 12_000;
+/** Tickets outlive a single call; re-handshaking per poll would be absurd. */
+const tickets = new Map();
+const TICKET_TTL_MS = 60 * 60_000;
+const hex = (u8) => Buffer.from(u8).toString("hex");
+function loadKeys(keyFile) {
+    const raw = JSON.parse(readFileSync(keyFile, "utf-8"));
+    return { pk: raw.publicKey, sk: new Uint8Array(Buffer.from(raw.secretKey, "hex")) };
+}
+/** ws(s)://host/relay-ws → https://host */
+function httpBase(wsUrl) {
+    const u = new URL(wsUrl);
+    return `${u.protocol === "wss:" ? "https:" : "http:"}//${u.host}`;
+}
+/** Complete the handshake and return a ticket. Opens a socket to an
+ *  allowlisted relay because the bridge needs a target to accept the
+ *  connection at all — but nothing is ever sent over it. */
+function fetchTicket(wsUrl, keyFile, profile) {
+    return new Promise((resolve, reject) => {
+        const { pk, sk } = loadKeys(keyFile);
+        const ws = new WebSocket(`${wsUrl}?host=127.0.0.1&port=33445`);
+        const done = (err, ticket) => {
+            clearTimeout(timer);
+            try {
+                ws.close();
+            }
+            catch { /* already closing */ }
+            err ? reject(err) : resolve(ticket);
+        };
+        const timer = setTimeout(() => done(new Error("bridge handshake timed out")), HANDSHAKE_MS);
+        ws.on("open", () => ws.send(JSON.stringify({
+            t: "hello", ver: 1, tox: pk,
+            address: profile.address || undefined,
+            name: profile.name || undefined,
+            descr: profile.descr || undefined,
+        })));
+        ws.on("message", (data, isBinary) => {
+            if (isBinary)
+                return; // relay bytes: not ours
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (msg.t === "challenge") {
+                const message = new TextEncoder().encode(`decent-bridge\n${msg.origin}\n${msg.n}`);
+                ws.send(JSON.stringify({ t: "proof", sig: hex(signDetached(sk, message)) }));
+                return;
+            }
+            if (msg.t === "ticket" && msg.ticket)
+                done(null, msg.ticket);
+        });
+        ws.on("error", (e) => done(e));
+        ws.on("close", () => done(new Error("bridge closed before issuing a ticket")));
+    });
+}
+/** Who else is on this bridge. Null when the bridge speaks the older protocol
+ *  and never issues a ticket — an absence, not an error. */
+export async function bridgeRoster(wsUrl, keyFile, profile) {
+    const base = httpBase(wsUrl);
+    let cached = tickets.get(wsUrl);
+    if (cached && Date.now() - cached.at > TICKET_TTL_MS)
+        cached = undefined;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        if (!cached) {
+            const ticket = await fetchTicket(wsUrl, keyFile, profile);
+            cached = { ticket, at: Date.now() };
+            tickets.set(wsUrl, cached);
+        }
+        const res = await fetch(`${base}/roster`, { headers: { authorization: `Bearer ${cached.ticket}` } });
+        if (res.status === 401) { // stale ticket: re-handshake once
+            tickets.delete(wsUrl);
+            cached = undefined;
+            continue;
+        }
+        if (!res.ok)
+            throw new Error(`bridge roster ${res.status}`);
+        const d = (await res.json());
+        return { bridge: d.bridge || base, online: d.online ?? 0, peers: d.peers ?? [] };
+    }
+    return null;
+}

package/dist/cli.js

@@ -27,7 +27,9 @@ function parseArgs(argv) {
             "  --host <addr>      bind address (default 127.0.0.1)",
             "  --config-dir <p>   identity/config dir (default ~/.agentnet)",
             "  --dora-dir <p>     dora roster dir, if this machine runs a dora",
+            "  --bridge <wss>     bridge whose roster to show (default: bridge.beagle.chat)",
             "  --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);
@@ -39,7 +41,9 @@ function parseArgs(argv) {
         host: get("--host") ?? "127.0.0.1",
         configDir: get("--config-dir") ?? defaultConfigDir(),
         doraDir: get("--dora-dir"),
+        bridge: get("--bridge"),
         backend: get("--backend"),
+        waitDaemon: get("--wait-daemon"),
     };
 }
 const readJsonVer = (file) => {
@@ -109,6 +113,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) {
@@ -154,6 +159,10 @@ async function main() {
             keyFile: resolve(decentlanCarrierDir(args.configDir), "keypair.json"),
             bootstrapNodes,
         },
+        // The venue this node shows in Here. A default rather than a required flag:
+        // the roster is only useful if it is populated, and everyone starts on the
+        // same one until they have a reason not to.
+        bridgeWs: args.bridge || "wss://bridge.beagle.chat/relay-ws",
         meExtra: {
             // The panel reads "lan <x> · peer <y>". Report the real decentlan version
             // powering this backend, not beagle's own — conflating them made the