@decentnetwork/beagle 0.1.0

package/dist/peer-host.js

@@ -0,0 +1,102 @@
+// PeerHost — the one abstraction the split turns on.
+//
+// Beagle needs a live Carrier identity to chat, send files and place calls.
+// There are two ways to have one, and they are mutually exclusive:
+//
+//   backend B (daemon)   — a decentlan daemon is already running; talk to it
+//                          over IPC. The user gets the virtual LAN too.
+//   backend A (embedded) — no daemon; beagle opens its own Peer in-process.
+//                          Plain user privilege, no TUN, no sudo. (Phase 2)
+//
+// The hard constraint that forces this shape: ONE identity must never have two
+// live Carrier peers. Two peers on the same keypair race on session
+// establishment and scramble each other's net_crypto state — decentlan has an
+// explicit refuse-second-peer guard for exactly this. So beagle picks a backend
+// and holds it; it never runs both, and switching is a sequenced handoff
+// (stop one, wait, start the other), never an overlap.
+//
+// Phase 1 ships backend B only. The interface is defined now so backend A can
+// drop in without touching the HTTP layer above it.
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import yaml from "js-yaml";
+import { daemonIsRunning, ipcCall, ipcSocketPath } from "./ipc.js";
+/** Where decentlan keeps its Carrier identity and daemon socket. Beagle reuses
+ *  this identity when it exists so a user's friends carry over — the whole
+ *  point of the split is that it is the same node, not a new one. */
+export function decentlanCarrierDir(configDir) {
+    const cfg = resolve(configDir, "config.yaml");
+    if (existsSync(cfg)) {
+        try {
+            const parsed = yaml.load(readFileSync(cfg, "utf-8"));
+            if (parsed?.carrier?.dataDir)
+                return parsed.carrier.dataDir;
+        }
+        catch {
+            // fall through to the conventional path
+        }
+    }
+    return resolve(configDir, "carrier");
+}
+export function defaultConfigDir() {
+    return process.env.AGENTNET_CONFIG_DIR || resolve(homedir(), ".agentnet");
+}
+/** Backend B: every op is forwarded to the running decentlan daemon. */
+class DaemonHost {
+    kind = "daemon";
+    hasVirtualLan = true;
+    #dataDir;
+    constructor(dataDir) {
+        this.#dataDir = dataDir;
+    }
+    call(req) {
+        return ipcCall(this.#dataDir, req);
+    }
+    async stop() {
+        // Nothing to tear down: we don't own the daemon's lifecycle. Beagle must
+        // never start or stop the user's daemon as a side effect.
+    }
+}
+/**
+ * Pick a backend.
+ *
+ * Daemon-first when one is running: it already holds this identity's Carrier
+ * peer, and starting a second peer on the same keypair is the one thing that
+ * must never happen. If there's no daemon, run the peer ourselves — no root,
+ * no TUN, just messaging.
+ */
+export async function openPeerHost(opts) {
+    const dataDir = decentlanCarrierDir(opts.configDir);
+    if (opts.force !== "embedded" && daemonIsRunning(dataDir)) {
+        return { host: new DaemonHost(dataDir), why: `decentlan daemon at ${dataDir}` };
+    }
+    if (opts.force === "daemon") {
+        throw new Error(`--backend daemon was requested but no decentlan daemon is running (looked for ${ipcSocketPath(dataDir)}).`);
+    }
+    // Reuse decentlan's identity when it exists so friends carry over — this is
+    // the same node, not a new one. The daemon is not running, so nothing else
+    // holds this keypair.
+    const keyFile = resolve(dataDir, "keypair.json");
+    // Sample this BEFORE start(): the SDK creates the keyfile on first run, so
+    // checking afterwards always reports "reusing" and the banner would claim we
+    // kept an identity we had in fact just minted.
+    const reusedIdentity = existsSync(keyFile);
+    const { EmbeddedHost } = await import("./embedded-host.js");
+    const host = new EmbeddedHost({
+        configDir: opts.configDir,
+        keyFile,
+        bootstrapNodes: opts.bootstrapNodes,
+        expressNodes: opts.expressNodes,
+        nickname: opts.nickname,
+        statusMessage: opts.statusMessage,
+        autoAcceptFriends: opts.autoAcceptFriends ?? true,
+    });
+    await host.start();
+    return {
+        host,
+        why: reusedIdentity
+            ? `embedded peer, reusing the identity in ${keyFile}`
+            : `embedded peer, new identity at ${keyFile}`,
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,29 @@
+import type { IpcRequest, IpcResponse } from "./ipc.js";
+export interface BeagleServerOptions {
+    /** Call the running daemon over IPC (injected so this module stays
+     *  decoupled from the CLI's ipc client). */
+    call: (req: IpcRequest) => Promise<IpcResponse>;
+    /** Path to ~/.agentnet/routes.yaml — the exit-routing table the UI edits. */
+    routesPath: string;
+    /** If this node also runs a dora server, the path to its roster.yaml — the
+     *  UI shows the allocation table (userid → IP → name). Undefined = no dora. */
+    doraRosterPath?: string;
+    /** Version/wire strings for the desktop "my node" panel — the daemon's diag
+     *  doesn't carry them, so the CLI reads them off the installed packages and
+     *  passes them in. */
+    meExtra?: {
+        lanVer?: string;
+        peerVer?: string;
+        wire?: string;
+        channel?: string;
+    };
+    /** Directory where the daemon saves received files (<configDir>/downloads).
+     *  Used to serve GET /api/file-download. Undefined disables downloads. */
+    downloadsDir?: string;
+    listenHost?: string;
+    listenPort?: number;
+    log?: (msg: string) => void;
+}
+export declare function startBeagleServer(opts: BeagleServerOptions): {
+    stop: () => void;
+};