@decentnetwork/beagle 0.1.0

package/README.md

@@ -0,0 +1,64 @@
+# Beagle
+
+P2P chat, file transfer and calls over the [Decent Network](https://github.com/0xli/decentlan).
+No account, no server, no admin privilege — your identity is a keypair on your
+own machine, and messages go peer-to-peer.
+
+Beagle is the **application**. The protocol lives in `@decentnetwork/peer` (SDK)
+and the virtual-LAN layer in `@decentnetwork/lan` (decentlan, a developer and
+operator tool). Beagle iterates fast; those stay boring on purpose.
+
+## Run
+
+```bash
+npm install
+npm run build
+node dist/cli.js
+```
+
+Then open <http://localhost:8766>.
+
+```
+--port <n>         HTTP port (default 8766)
+--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
+```
+
+Port 8766 rather than decentlan's 8765, so during the transition the old
+`agentnet ui` and Beagle can run side by side on one machine.
+
+## Status: Phase 1
+
+Beagle picks a **backend** for its Carrier identity. Exactly one is ever live,
+because one identity must never run two Carrier peers at once — two peers on the
+same keypair race on session establishment and corrupt each other's state.
+
+| Backend | Status | Needs root | Virtual LAN |
+|---|---|---|---|
+| `daemon` — talks to a running decentlan daemon over IPC | **shipping** | no (the daemon does) | yes |
+| `embedded` — Beagle opens its own Peer in-process | Phase 2 | **no** | no |
+
+Today Beagle requires a decentlan daemon. Phase 2 adds the embedded backend, at
+which point Beagle runs standalone at ordinary user privilege and decentlan
+becomes the optional "I also want a virtual LAN" add-on.
+
+Identity is read from `~/.agentnet` by default, so a machine already running
+decentlan keeps the same userid and the same friends — it is the same node,
+not a new one.
+
+## Layout
+
+```
+src/
+├── cli.ts        # the `beagle` binary — argument parsing, startup
+├── peer-host.ts  # backend abstraction + selection (the split's hinge)
+├── ipc.ts        # decentlan daemon wire protocol, client side
+├── server.ts     # local HTTP server: /api/* + serves the UI bundle
+├── exits.ts      # official exit table (network panel only)
+└── desktop/      # the UI itself (JSX, concatenated + esbuild-transpiled)
+```
+
+`scripts/build-ui.mjs` bundles `src/desktop/*.jsx` into `dist/desktop/app.js`.
+The UI runs as one concatenated script sharing global scope with React (UMD) —
+no CDN, no in-browser Babel.

package/config/bootstrap-nodes.yaml

@@ -0,0 +1,50 @@
+# Carrier bootstrap fleet, mirrored from decentlan's shipped defaults
+# (US-verified hosts first — the SDK dials the first 3 in order, so
+# ordering decides which relays the whole fleet meets on).
+# Refresh from https://beagle.chat/assets/bgservers.json
+bootstrapNodes:
+  - host: 13.58.208.50
+    port: 33445
+    pk: 89vny8MrKdDKs7Uta9RdVmspPjnRMdwMmaiEW27pZ7gh
+  - host: 144.202.113.167
+    port: 33445
+    pk: EfT4YMq6qfHdDsCiBCgsEmA78E2NxVYVKVUS9bD6w9GH
+  - host: 149.28.98.141
+    port: 33445
+    pk: 81PPfuEyzSovgxymxr2ifiCWXdB5CGaiofx5MrxnhYV7
+  - host: 18.216.6.197
+    port: 33445
+    pk: H8sqhRrQuJZ6iLtP2wanxt4LzdNrN2NNFnpPdq1uJ9n2
+  - host: 52.57.248.163
+    port: 33445
+    pk: CfJLve8FNQPQJ9xYQ8oEVkPxeAPCN7iSdhnYFkWmWgLn
+  - host: 35.179.41.220
+    port: 33445
+    pk: 6u2vKadPa9wqDf531QaZy7FJN3c7Wzntm7dKXxXqvyNB
+  - host: 52.63.19.190
+    port: 33445
+    pk: EeNenbyS4sx3qtu82esT1V1NMe9dZib5LyQmYGM6fboK
+  - host: 47.100.103.201
+    port: 33445
+    pk: CX1XH419p4xJ5SV4KvDxBeKYSRdMJW9QpdWJY8owUxHd
+  - host: 139.129.193.117
+    port: 33445
+    pk: 67UQhssARwMky1YgFA2oDGZ1RiQYQmS6JqWFHxtopKq5
+  - host: 18.216.102.47
+    port: 33445
+    pk: G5z8MqiNDFTadFUPfMdYsYtkUDbX5mNCMVHMZtsCnFeb
+  - host: 54.193.141.205
+    port: 33445
+    pk: 7TfZWZNV8vnBxxWzJXuvKgX2QyKkLpg2oXx3LQ5tg8LW
+  - host: 154.64.235.176
+    port: 33445
+    pk: GdNtV2N74fZnLjhH7NhQ18nGdxb1k8jRM9dQaK7WnxmL
+  - host: 52.74.215.181
+    port: 33445
+    pk: Xv6d34WaUw9bPn7YihzVAFw7D2igbQJZ3jwmzzfYVFV
+  - host: 52.83.171.135
+    port: 443
+    pk: 5tuHgK1Q4CYf4K5PutsEPK5E3Z7cbtEBdx7LwmdzqXHL
+  - host: 52.83.191.228
+    port: 33445
+    pk: 3khtxZo89SBScAMaHhTvD68pPHiKxgZT6hTCSZZVgNEm

package/config/default-exits.yaml

@@ -0,0 +1,49 @@
+# Official exit / infrastructure nodes shipped with @decentnetwork/lan.
+#
+# A fresh install auto-friends ONLY the dora registries (config/default-doras.yaml)
+# and the exits listed here — NOT every machine that happens to be in the dora
+# roster. This keeps a new client's friend list to infrastructure (doras + exits)
+# instead of filling up with other people's personal/compute boxes.
+#
+# Each exit carries a `region`, so `agentnet proxy router` (with no routes.yaml)
+# auto-builds the routing table: China sites → china exits, Japan/Binance →
+# japan exit, Google/YouTube/GitHub/etc → us exits, everything else direct.
+#
+# Mechanism: these userids (plus the dora userids) become the default
+# `dora.autoFriend` whitelist for a freshly-initialised config. The client
+# still LEARNS every roster entry into IPAM (so names/IPs resolve), but only
+# proactively friends infrastructure. Exits still serve arbitrary clients
+# because the daemon auto-ACCEPTS incoming friend-requests — so hub-and-spoke
+# works without meshing every personal machine.
+#
+# To run a full mesh instead (friend everyone in the roster):
+#   agentnet dora autofriend all
+# To add/replace an exit: edit this file (data, not code) and republish, or
+# locally: agentnet dora autofriend allow <name|userid> ...
+#
+# `region` is one of: china | japan | us  (matches the router's built-in
+# domain lists; see BUILTIN_REGION_DOMAINS in src/proxy/multi-exit-router.ts).
+exits:
+  # --- China (China-only / GFW-blocked-from-outside sites) ---
+  - name: cn
+    userid: 5Aj6uQMd1cNRb9cGT4AwHCN4RdVZjfaGLtgKGhdP1LzN
+    virtual_ip: 10.86.1.15
+    region: china
+  - name: sh
+    userid: 6D1PLSVqbSpcxnDMAd8ZXLWycYveeP2hU4g3igDQEqA7
+    virtual_ip: 10.86.1.16
+    region: china
+  - name: callpass
+    userid: DZN2L9RV1YkHjqGHMTA6juZhskKA65AD2RyPt4umZVc7
+    virtual_ip: 10.86.1.17
+    region: china
+  # --- Japan (host "lico", dora name node-91) — Binance routes here ---
+  - name: tokyo
+    userid: 4uNnLnAQHVJ7td657MDaz4UnEuhnTW9sRAPSVeAEEQe4
+    virtual_ip: 10.86.68.90
+    region: japan
+  # --- US (Google, YouTube, GitHub, X/Twitter, LinkedIn, OpenAI) ---
+  - name: gojipower
+    userid: 2wErj1XreXt1UchE3FGhuvkZ4GoBpo8JGMn8X49nm2ec
+    virtual_ip: 10.86.166.16
+    region: us

package/dist/carrier-node.d.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from "node:events";
+export interface InlineFileEvent {
+    pubkey: string;
+    name: string;
+    fileType?: string;
+    data: Uint8Array;
+    via: "online" | "offline";
+}
+export interface InviteEvent {
+    pubkey: string;
+    ext?: string;
+    bundle?: string;
+    data: Uint8Array;
+}
+export interface FileOffer {
+    friendId: string;
+    fileNumber: number;
+    fileId: string;
+    name: string;
+    size: number;
+    kind: number;
+}
+export interface FileProgress {
+    friendId: string;
+    fileId: string;
+    received: number;
+    total: number;
+    /** True when this is OUR outgoing transfer, false/absent when receiving. */
+    sending?: boolean;
+}
+export interface FileComplete {
+    friendId: string;
+    fileId: string;
+    name: string;
+    size: number;
+    /** Present on the receiving side only. */
+    data?: Uint8Array;
+    sending?: boolean;
+}
+export interface FileCancel {
+    friendId: string;
+    fileId: string;
+    sending: boolean;
+}
+export interface CarrierNodeOptions {
+    keyFile: string;
+    bootstrapNodes: {
+        host: string;
+        port: number;
+        pk: string;
+    }[];
+    expressNodes?: {
+        host: string;
+        port: number;
+        pk: string;
+        tls?: boolean;
+    }[];
+    nickname?: string;
+    statusMessage?: string;
+    fileResumeDir?: string;
+}
+export interface FriendView {
+    pubkey: string;
+    carrierId: string;
+    name?: string;
+    status: "online" | "offline" | "requested";
+    address?: string;
+    acceptedAt?: number;
+    requestedAt?: number;
+}
+export declare class CarrierNode extends EventEmitter {
+    #private;
+    create(opts: CarrierNodeOptions): Promise<void>;
+    start(): Promise<void>;
+    /** Join the DHT and publish ourselves so peers can find us. Deliberately
+     *  fault-tolerant: a transient bootstrap timeout must not stop the app from
+     *  starting — friends on a relay path still reach us, and the retry loop
+     *  keeps trying in the background. */
+    join(): Promise<void>;
+    identity(): {
+        pubkey: string;
+        userid: string;
+        address: string;
+    };
+    friends(): FriendView[];
+    isFriendOnline(userid: string): boolean;
+    sessionStatus(pubkey: string): unknown;
+    dhtHealth(): unknown;
+    sendText(userid: string, text: string): Promise<void>;
+    sendFriendRequest(address: string, hello?: string): Promise<void>;
+    acceptFriendRequest(pubkey: string): Promise<void>;
+    removeFriend(userid: string): boolean;
+    setUserInfo(info: {
+        name?: string;
+        description?: string;
+    }): void;
+    sign(message: Uint8Array): Uint8Array;
+    sendFile(userid: string, data: Uint8Array, name: string): string | null;
+    cancelSend(userid: string, fileId: string): boolean;
+    acceptFile(userid: string, fileNumber: number): void;
+    sendInlineFile(userid: string, data: Uint8Array, name: string): Promise<void>;
+    sendCallSignal(userid: string, data: Uint8Array | string): Promise<void>;
+    /** Native (iOS/Android/C) friends can't see toxcore file transfer; they only
+     *  receive the inline FileModel envelope. decentlan detects this from the DHT
+     *  key signature — an internal we don't have here, so beagle probes the
+     *  capability and falls back rather than guessing wrong. */
+    stop(): Promise<void>;
+}

package/dist/carrier-node.js

@@ -0,0 +1,209 @@
+// CarrierNode — a messaging-only wrapper around @decentnetwork/peer.
+//
+// This is the deliberate opposite of decentlan's PeerManager (785 lines): that
+// one also owns packet sessions, frame codecs, the IP/dora/rate custom-packet
+// channels and the TUN plumbing. Beagle needs none of it. What a chat app
+// actually needs from Carrier is: an identity, a friend list, text, files,
+// and the invite channel that carries call signaling.
+//
+// Everything here runs at ordinary user privilege. Nothing opens a TUN, so
+// nothing needs root — which is the entire point of the embedded backend.
+import { EventEmitter } from "node:events";
+import { Logger } from "./logger.js";
+export class CarrierNode extends EventEmitter {
+    #peer;
+    #logger = new Logger({ prefix: "Carrier" });
+    #identity;
+    async create(opts) {
+        const mod = (await import("@decentnetwork/peer"));
+        this.#peer = await mod.Peer.create({
+            keyFile: opts.keyFile,
+            // "legacy" is what every other node on this network speaks — a beagle
+            // node that negotiated anything else would simply be invisible to the
+            // iOS/Android apps and to decentlan.
+            compatibilityMode: "legacy",
+            bootstrapNodes: opts.bootstrapNodes,
+            expressNodes: opts.expressNodes,
+            nickname: opts.nickname,
+            statusMessage: opts.statusMessage,
+            fileResumeDir: opts.fileResumeDir,
+            // NOTE: no bulkDataPacketId. decentlan registers the IP channel (163) as
+            // the SDK's bulk stream; beagle has no IP channel, so the SDK keeps its
+            // default and file transfer is unaffected.
+        });
+        this.#wireEvents();
+    }
+    async start() {
+        const peer = this.#require();
+        await peer.start();
+        // Identity only exists after start().
+        this.#identity = { pubkey: peer.pubkey(), userid: peer.userid(), address: peer.address() };
+        this.#logger.info(`identity ${this.#identity.address}`);
+    }
+    /** Join the DHT and publish ourselves so peers can find us. Deliberately
+     *  fault-tolerant: a transient bootstrap timeout must not stop the app from
+     *  starting — friends on a relay path still reach us, and the retry loop
+     *  keeps trying in the background. */
+    async join() {
+        const peer = this.#require();
+        try {
+            await peer.joinNetwork();
+        }
+        catch (error) {
+            this.#logger.warn(`joinNetwork failed (${error.message}) — retrying in background`);
+            void this.#retryJoin();
+            return;
+        }
+        void this.#announce();
+    }
+    async #retryJoin() {
+        const peer = this.#require();
+        for (let attempt = 1; attempt <= 60; attempt++) {
+            await new Promise((r) => setTimeout(r, 10_000));
+            try {
+                await peer.joinNetwork();
+                this.#logger.info(`joined after ${attempt} retries`);
+                void this.#announce();
+                return;
+            }
+            catch {
+                // keep trying
+            }
+        }
+    }
+    async #announce() {
+        const peer = this.#require();
+        for (let i = 0; i < 3; i++) {
+            try {
+                const stored = await peer.announceSelf(45_000);
+                if (stored?.length)
+                    break;
+            }
+            catch {
+                // announce is best-effort; relay paths still work without it
+            }
+        }
+        // Stay findable: re-announce on the same cadence peerd uses.
+        setInterval(() => {
+            void peer.announceSelf(20_000).catch(() => undefined);
+        }, 120_000).unref?.();
+    }
+    #require() {
+        if (!this.#peer)
+            throw new Error("CarrierNode not created");
+        return this.#peer;
+    }
+    #wireEvents() {
+        const peer = this.#require();
+        peer.onText((m) => {
+            // Empty texts are session keepalives, not messages.
+            if (!m.text.length)
+                return;
+            this.emit("message", m.pubkey, m.text, m.via);
+        });
+        peer.onFriendRequest((r) => this.emit("friend-request", r));
+        peer.onFriendConnection?.((e) => this.emit("friend-connection", e));
+        peer.onInlineFile?.((f) => this.emit("inline-file", f));
+        peer.onInvite?.((evt) => {
+            // Only the "carrier" extension carries call signaling; other extensions
+            // belong to other apps and must not be handed to the call engine.
+            if (evt.ext !== undefined && evt.ext !== "carrier")
+                return;
+            this.emit("call-signal", { pubkey: evt.pubkey, data: evt.data });
+        });
+        // Forwarded verbatim — the embedded host keys off friendId/fileId/sending.
+        peer.onFile?.((o) => this.emit("file-offer", o));
+        peer.onFileProgress?.((p) => this.emit("file-progress", p));
+        peer.onFileComplete?.((p) => this.emit("file-complete", p));
+        peer.onFileCancel?.((p) => this.emit("file-cancel", p));
+    }
+    identity() {
+        if (!this.#identity)
+            throw new Error("CarrierNode not started");
+        return this.#identity;
+    }
+    friends() {
+        return this.#require().friends().map((f) => ({
+            pubkey: f.pubkey,
+            carrierId: f.userid || f.pubkey,
+            name: f.name,
+            // Keep "requested" distinct from "offline": it answers "did my friend
+            // request get through?", which collapsing would hide.
+            status: f.status === "online" ? "online" : f.status === "requested" ? "requested" : "offline",
+            address: f.address,
+            acceptedAt: f.acceptedAt,
+            requestedAt: f.requestedAt,
+        }));
+    }
+    isFriendOnline(userid) {
+        return this.friends().some((f) => f.carrierId === userid && f.status === "online");
+    }
+    sessionStatus(pubkey) {
+        try {
+            return this.#require().sessionStatus(pubkey);
+        }
+        catch {
+            return null;
+        }
+    }
+    dhtHealth() {
+        try {
+            return this.#require().dhtHealth();
+        }
+        catch {
+            return null;
+        }
+    }
+    sendText(userid, text) {
+        return this.#require().sendText(userid, text);
+    }
+    sendFriendRequest(address, hello) {
+        return this.#require().sendFriendRequest(address, hello);
+    }
+    acceptFriendRequest(pubkey) {
+        return this.#require().acceptFriendRequest(pubkey);
+    }
+    removeFriend(userid) {
+        return this.#require().removeFriend(userid);
+    }
+    setUserInfo(info) {
+        this.#require().setUserInfo(info);
+    }
+    sign(message) {
+        return this.#require().sign(message);
+    }
+    sendFile(userid, data, name) {
+        return this.#require().sendFile(userid, data, { name });
+    }
+    cancelSend(userid, fileId) {
+        // isSending=true: we are the sender. Without it the SDK looks for an
+        // inbound transfer with that id and finds nothing.
+        return this.#require().cancelFileById?.(userid, fileId, true) ?? false;
+    }
+    acceptFile(userid, fileNumber) {
+        this.#require().acceptFile(userid, fileNumber);
+    }
+    async sendInlineFile(userid, data, name) {
+        const peer = this.#require();
+        if (!peer.sendInlineFile)
+            throw new Error("This peer SDK build has no inline-file support");
+        await peer.sendInlineFile(userid, { name, data });
+    }
+    async sendCallSignal(userid, data) {
+        const peer = this.#require();
+        if (!peer.sendInvite)
+            throw new Error("This peer SDK build has no invite channel (calls unavailable)");
+        // ext "carrier" is the channel iOS/Android Beagle listen on for calls.
+        await peer.sendInvite(userid, data, { ext: "carrier" });
+    }
+    /** Native (iOS/Android/C) friends can't see toxcore file transfer; they only
+     *  receive the inline FileModel envelope. decentlan detects this from the DHT
+     *  key signature — an internal we don't have here, so beagle probes the
+     *  capability and falls back rather than guessing wrong. */
+    async stop() {
+        if (!this.#peer)
+            return;
+        await this.#peer.stop().catch(() => undefined);
+        this.#peer = undefined;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// `beagle` — start the Beagle app: a local web UI for chat, files and calls.
+//
+// Deliberately NOT a subcommand tree. Beagle is a consumer app; the whole CLI
+// is "run it". Diagnostics and network administration stay in decentlan's
+// `agentnet` CLI, which is the developer/operator tool.
+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 { openPeerHost, defaultConfigDir } from "./peer-host.js";
+import { loadNodeConfig } from "./node-config.js";
+function parseArgs(argv) {
+    const get = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 ? argv[i + 1] : undefined;
+    };
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log([
+            "beagle — P2P chat, files and calls over the Decent Network",
+            "",
+            "Usage: beagle [options]",
+            "",
+            "  --port <n>         HTTP port (default 8766)",
+            "  --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",
+            "  --backend <k>      force 'daemon' or 'embedded' (default: auto)",
+            "  -h, --help         this text",
+        ].join("\n"));
+        process.exit(0);
+    }
+    return {
+        // 8766, not decentlan's 8765: during the transition both can run at once,
+        // so a user can compare old and new side by side without a port fight.
+        port: Number(get("--port") ?? process.env.BEAGLE_PORT ?? 8766),
+        host: get("--host") ?? "127.0.0.1",
+        configDir: get("--config-dir") ?? defaultConfigDir(),
+        doraDir: get("--dora-dir"),
+        backend: get("--backend"),
+    };
+}
+const readJsonVer = (file) => {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8")).version ?? "";
+    }
+    catch {
+        return "";
+    }
+};
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    // 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".
+    const { bootstrapNodes, expressNodes, nickname, statusMessage, autoAccept } = loadNodeConfig(args.configDir);
+    let peerHost;
+    let why = "";
+    try {
+        ({ host: peerHost, why } = await openPeerHost({
+            configDir: args.configDir,
+            bootstrapNodes,
+            expressNodes,
+            nickname,
+            statusMessage,
+            autoAcceptFriends: autoAccept,
+            force: args.backend,
+        }));
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    // Version lookup for the "my node" panel.
+    //
+    // NOT via createRequire().resolve(): peer and lan declare `exports` with an
+    // "import" condition only, so CJS resolution throws
+    // ERR_PACKAGE_PATH_NOT_EXPORTED for both the bare specifier and
+    // "<pkg>/package.json". (decentlan's own UI has the same call and has been
+    // silently showing an empty peer version because of it.) import.meta.resolve
+    // uses ESM resolution, which honours that condition.
+    const resolveVer = (pkg) => {
+        const manifestFrom = (start) => {
+            let dir = start;
+            for (let depth = 0; depth < 6; depth++) {
+                const manifest = join(dir, "package.json");
+                if (existsSync(manifest)) {
+                    try {
+                        const parsed = JSON.parse(readFileSync(manifest, "utf-8"));
+                        if (parsed.name === pkg)
+                            return parsed.version ?? "";
+                    }
+                    catch {
+                        // unreadable manifest — keep walking
+                    }
+                }
+                const up = dirname(dir);
+                if (up === dir)
+                    break;
+                dir = up;
+            }
+            return undefined;
+        };
+        try {
+            return manifestFrom(dirname(fileURLToPath(import.meta.resolve(pkg)))) ?? "";
+        }
+        catch {
+            // Fall back to a plain node_modules lookup beside this package, which
+            // also covers the case where the dependency is absent entirely.
+            return manifestFrom(join(moduleDir, "..", "node_modules", ...pkg.split("/"))) ?? "";
+        }
+    };
+    // If this machine also runs a dora, surface its allocation table.
+    const doraCandidates = args.doraDir
+        ? [resolve(args.doraDir, "roster.yaml")]
+        : [resolve(homedir(), ".dora-test", "roster.yaml"), resolve(homedir(), ".decent-registry", "roster.yaml")];
+    const doraRosterPath = doraCandidates.find((p) => existsSync(p));
+    console.log(`beagle ${readJsonVer(join(moduleDir, "..", "package.json"))} — backend: ${peerHost.kind} (${why})`);
+    // The "open <url>" line is printed by the server itself, once the socket is
+    // actually bound. Printing it here first meant a port clash left a bogus
+    // invitation on screen directly above the error explaining it was wrong.
+    startBeagleServer({
+        call: (r) => peerHost.call(r),
+        routesPath: resolve(args.configDir, "routes.yaml"),
+        doraRosterPath,
+        downloadsDir: resolve(args.configDir, "downloads"),
+        meExtra: {
+            // The panel reads "lan <x> · peer <y>". Report the real decentlan version
+            // powering this backend, not beagle's own — conflating them made the
+            // node look like it was running lan 0.1.0.
+            lanVer: resolveVer("@decentnetwork/lan") || "(none)",
+            peerVer: resolveVer("@decentnetwork/peer"),
+            wire: "163",
+            channel: "@next",
+        },
+        listenHost: args.host,
+        listenPort: args.port,
+    });
+    const shutdown = async () => {
+        await peerHost.stop().catch(() => undefined);
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => { }); // run until signalled
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});