@decentnetwork/beagle 0.1.0

package/dist/index.js

@@ -0,0 +1,5 @@
+// Library surface. Beagle is normally run as a binary (`beagle`), but the
+// server and the backend abstraction are exported so it can be embedded.
+export { startBeagleServer } from "./server.js";
+export { openPeerHost, defaultConfigDir, decentlanCarrierDir } from "./peer-host.js";
+export { ipcCall, ipcSocketPath, daemonIsRunning } from "./ipc.js";

package/dist/ipc.d.ts

@@ -0,0 +1,41 @@
+/** Ops the daemon answers. Every one is peer-level — none of them needs the
+ *  TUN — which is what makes the beagle/decentlan split possible at all. */
+export type IpcOp = "ping" | "diag" | "friend-request" | "friends-pending" | "friends-accept" | "friends-reject" | "friends-list" | "friend-remove" | "friend-set-alias" | "friends-autoaccept" | "set-profile" | "sign" | "chat-send" | "chat-history" | "chat-log-local" | "chat-mark-read" | "file-send" | "file-delete" | "file-cancel" | "file-retry" | "file-log-local" | "call-signal" | "call-poll";
+export interface IpcRequest {
+    op: IpcOp;
+    address?: string;
+    hello?: string;
+    userid?: string;
+    text?: string;
+    alias?: string;
+    name?: string;
+    description?: string;
+    path?: string;
+    ids?: string[];
+    ts?: number;
+    since?: number;
+    limit?: number;
+    enabled?: boolean;
+    origin?: string;
+    nonce?: string;
+    signal?: unknown;
+    [key: string]: unknown;
+}
+export interface IpcResponseOk {
+    ok: true;
+    data?: Record<string, unknown>;
+}
+export interface IpcResponseErr {
+    ok: false;
+    error: string;
+}
+export type IpcResponse = IpcResponseOk | IpcResponseErr;
+/** Must match decentlan's ipcSocketPath() exactly — daemon and client have to
+ *  agree on this string or beagle silently finds no daemon. */
+export declare function ipcSocketPath(dataDir: string, platform?: NodeJS.Platform): string;
+/** fs.existsSync is meaningful for Unix-domain sockets but always false for
+ *  Windows named pipes, so on Windows we connect and let net report. */
+export declare function ipcSocketSupportsFsExistenceCheck(platform?: NodeJS.Platform): boolean;
+export declare function daemonIsRunning(dataDir: string): boolean;
+/** One request, one newline-delimited JSON response. */
+export declare function ipcCall(dataDir: string, req: IpcRequest, timeoutMs?: number): Promise<IpcResponse>;

package/dist/ipc.js

@@ -0,0 +1,76 @@
+// The decentlan daemon IPC contract, from the client side.
+//
+// Deliberately a LOCAL copy rather than a deep import of
+// `@decentnetwork/lan/dist/daemon/ipc.js`: that package exports only ".", and
+// more importantly this is a wire protocol between two independently-released
+// programs. Beagle owns its own view of it, the same way any client owns its
+// view of a server's API — decentlan is free to add ops without beagle
+// rebuilding, and beagle never breaks because an internal lan module moved.
+//
+// Backend B of the PeerHost split (see docs/BEAGLE-SPLIT-PLAN.md in decentlan):
+// used when a decentlan daemon is already running. Backend A (an embedded Peer,
+// no daemon, no root) arrives in Phase 2.
+import { createConnection } from "node:net";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+/** Must match decentlan's ipcSocketPath() exactly — daemon and client have to
+ *  agree on this string or beagle silently finds no daemon. */
+export function ipcSocketPath(dataDir, platform = process.platform) {
+    if (platform === "win32") {
+        const id = createHash("sha256").update(dataDir.toLowerCase()).digest("hex").slice(0, 16);
+        return `\\\\.\\pipe\\agentnet-${id}`;
+    }
+    return `${dataDir.replace(/\/+$/, "")}/daemon.sock`;
+}
+/** fs.existsSync is meaningful for Unix-domain sockets but always false for
+ *  Windows named pipes, so on Windows we connect and let net report. */
+export function ipcSocketSupportsFsExistenceCheck(platform = process.platform) {
+    return platform !== "win32";
+}
+export function daemonIsRunning(dataDir) {
+    if (!ipcSocketSupportsFsExistenceCheck())
+        return true; // can't tell; try it
+    return existsSync(ipcSocketPath(dataDir));
+}
+/** One request, one newline-delimited JSON response. */
+export function ipcCall(dataDir, req, timeoutMs = 30_000) {
+    const sockPath = ipcSocketPath(dataDir);
+    if (ipcSocketSupportsFsExistenceCheck() && !existsSync(sockPath)) {
+        return Promise.reject(new Error(`Daemon socket not found at ${sockPath} — is the decentlan daemon running?`));
+    }
+    return new Promise((resolve, reject) => {
+        const sock = createConnection(sockPath);
+        let buf = "";
+        const timer = setTimeout(() => {
+            sock.destroy();
+            reject(new Error(`IPC timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const done = (fn) => {
+            clearTimeout(timer);
+            sock.destroy();
+            fn();
+        };
+        sock.on("connect", () => sock.write(JSON.stringify(req) + "\n"));
+        sock.on("data", (chunk) => {
+            buf += chunk.toString("utf-8");
+            const nl = buf.indexOf("\n");
+            if (nl < 0)
+                return;
+            const line = buf.slice(0, nl);
+            done(() => {
+                try {
+                    resolve(JSON.parse(line));
+                }
+                catch (error) {
+                    reject(new Error(`Bad IPC response: ${error.message}`));
+                }
+            });
+        });
+        sock.on("error", (error) => done(() => reject(error)));
+        sock.on("close", () => {
+            clearTimeout(timer);
+            if (!buf.includes("\n"))
+                reject(new Error("Daemon closed the connection without replying"));
+        });
+    });
+}

package/dist/logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Simple logging utility for Decent AgentNet
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+}
+export declare class Logger {
+    private levelStr;
+    private level;
+    private prefix;
+    constructor(options?: LoggerOptions);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    child(prefix: string): Logger;
+}
+export declare const globalLogger: Logger;

package/dist/logger.js

@@ -0,0 +1,43 @@
+/**
+ * Simple logging utility for Decent AgentNet
+ */
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+export class Logger {
+    levelStr;
+    level;
+    prefix;
+    constructor(options) {
+        this.levelStr = (options?.level || process.env.AGENTNET_LOG_LEVEL || "info");
+        this.level = LOG_LEVELS[this.levelStr] ?? LOG_LEVELS.info;
+        this.prefix = options?.prefix ? `[${options.prefix}] ` : "";
+    }
+    debug(message, ...args) {
+        if (this.level <= LOG_LEVELS.debug) {
+            console.debug(`${this.prefix}DEBUG: ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.level <= LOG_LEVELS.info) {
+            console.log(`${this.prefix}INFO: ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.level <= LOG_LEVELS.warn) {
+            console.warn(`${this.prefix}WARN: ${message}`, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.level <= LOG_LEVELS.error) {
+            console.error(`${this.prefix}ERROR: ${message}`, ...args);
+        }
+    }
+    child(prefix) {
+        return new Logger({ level: this.levelStr, prefix });
+    }
+}
+export const globalLogger = new Logger();

package/dist/message-store.d.ts

@@ -0,0 +1,104 @@
+/**
+ * On-disk chat message store. Replaces the previous in-memory-only chatLog so
+ * conversations survive a daemon restart (PRD-DESKTOP-UI §2.1).
+ *
+ * Format: a single JSON file at <configDir>/messages.json mapping
+ *   userid -> ChatMessage[]   (oldest first)
+ * Loaded fully into memory on start; writes are debounced and atomic
+ * (write tmp + rename). Text chat is low-volume, so a JSON file is plenty;
+ * swap for SQLite later if threads get large (PRD §9).
+ */
+export interface ChatMessage {
+    dir: "in" | "out";
+    text: string;
+    ts: number;
+    /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
+    id: string;
+    /** Outgoing-text delivery state. "queued" means the peer was offline when the
+     *  user hit send, so the daemon stored it and will deliver it (in order) the
+     *  moment the friend reconnects. Cleared once actually sent. */
+    status?: "queued" | "sent" | "failed";
+    /** How this message traversed the network, for the UI to distinguish at a
+     *  glance (different colors). "online" = live net_crypto session (direct/relay);
+     *  "offline" = express store-and-forward (the friend or we were offline). Lets
+     *  a user SEE when online delivery is silently failing and only offline lands. */
+    via?: "online" | "offline";
+    /** Present when this entry is a file transfer rather than a text message.
+     *  `name`/`size` describe the file; received files (dir:"in") are saved to
+     *  <configDir>/downloads/<name> and downloadable via the UI. For outgoing
+     *  files, `status` tracks delivery and `sent` is the acked byte count (live
+     *  progress) — the receiver confirms every byte before status becomes "sent".
+     *  "queued" mirrors text: the peer was offline, so the bytes live in
+     *  <configDir>/outbox/<id> until the friend reconnects. */
+    file?: {
+        name: string;
+        size: number;
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
+        sent?: number;
+        durationMs?: number;
+        avgKbps?: number;
+        kbps?: number;
+    };
+}
+export declare class MessageStore {
+    private path;
+    private byPeer;
+    private logger;
+    private saveTimer?;
+    private dirty;
+    private seq;
+    constructor(path: string);
+    private load;
+    /** Append a message and schedule a flush. Returns the stored message.
+     *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
+     *  receive — the daemon flushes it on reconnect. */
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
+    /** Set (or, with undefined, clear) the delivery status on a text message.
+     *  Used to flip a "queued" message to delivered once it's actually sent.
+     *  No-op if the id isn't found or is a file entry. Returns true if patched. */
+    setStatus(peer: string, id: string, status?: "queued" | "sent" | "failed"): boolean;
+    /** Outgoing messages still awaiting delivery (peer was offline), oldest
+     *  first — both queued text and queued file chips. The daemon drains this
+     *  on a friend's reconnect. */
+    queuedOutgoing(peer: string): ChatMessage[];
+    /** Append a file-transfer entry (shown as a file chip in the UI). */
+    appendFile(peer: string, dir: "in" | "out", file: {
+        name: string;
+        size: number;
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
+        sent?: number;
+    }, ts?: number): ChatMessage;
+    /** Patch an existing file message's transfer fields (status / sent bytes).
+     *  No-op if the id isn't found. Returns true if it patched. */
+    patchFile(peer: string, id: string, patch: {
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
+        sent?: number;
+        durationMs?: number;
+        avgKbps?: number;
+        kbps?: number;
+    }): boolean;
+    /** Look up one persisted message by its stable UI id. */
+    get(peer: string, id: string): ChatMessage | undefined;
+    /** Remove messages by id. Returns the removed ones so the caller can clean up
+     *  any on-disk file the chip pointed at. */
+    deleteMessages(peer: string, ids: string[]): ChatMessage[];
+    private push;
+    /**
+     * Return history. With no peer, returns every peer's full thread (the legacy
+     * chat-history shape). With a peer, supports pagination: `limit` newest
+     * messages, optionally those strictly older than `before` (ms) for "load
+     * earlier" scrolling.
+     */
+    history(peer?: string, opts?: {
+        before?: number;
+        limit?: number;
+    }): Record<string, ChatMessage[]>;
+    /** Most recent message per peer — for the friend-list preview/sort. */
+    lastMessages(): Map<string, ChatMessage>;
+    /** Count messages newer than `sinceTs` for a peer (unread badge). */
+    unreadCount(peer: string, sinceTs: number): number;
+    removePeer(peer: string): void;
+    private scheduleSave;
+    /** Force a synchronous flush (called on debounce + on daemon shutdown). */
+    flush(): void;
+}

package/dist/message-store.js

@@ -0,0 +1,201 @@
+/**
+ * On-disk chat message store. Replaces the previous in-memory-only chatLog so
+ * conversations survive a daemon restart (PRD-DESKTOP-UI §2.1).
+ *
+ * Format: a single JSON file at <configDir>/messages.json mapping
+ *   userid -> ChatMessage[]   (oldest first)
+ * Loaded fully into memory on start; writes are debounced and atomic
+ * (write tmp + rename). Text chat is low-volume, so a JSON file is plenty;
+ * swap for SQLite later if threads get large (PRD §9).
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { Logger } from "./logger.js";
+/** Keep at most this many messages per peer on disk; older ones roll off. */
+const MAX_PER_PEER = 2000;
+/** Debounce window for flushing to disk after a change. */
+const SAVE_DEBOUNCE_MS = 1000;
+export class MessageStore {
+    path;
+    byPeer = new Map();
+    logger = new Logger({ prefix: "MessageStore" });
+    saveTimer;
+    dirty = false;
+    seq = 0;
+    constructor(path) {
+        this.path = path;
+        this.load();
+    }
+    load() {
+        if (!existsSync(this.path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.path, "utf-8"));
+            let total = 0;
+            for (const [peer, msgs] of Object.entries(raw)) {
+                if (Array.isArray(msgs)) {
+                    this.byPeer.set(peer, msgs);
+                    total += msgs.length;
+                }
+            }
+            this.logger.info(`Loaded ${total} messages across ${this.byPeer.size} peers`);
+        }
+        catch (err) {
+            this.logger.warn(`Could not load ${this.path}: ${err}`);
+        }
+    }
+    /** Append a message and schedule a flush. Returns the stored message.
+     *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
+     *  receive — the daemon flushes it on reconnect. */
+    append(peer, dir, text, ts = Date.now(), status, via) {
+        const msg = { dir, text, ts, id: `${ts}-${this.seq++}` };
+        if (status)
+            msg.status = status;
+        if (via)
+            msg.via = via;
+        return this.push(peer, msg);
+    }
+    /** Set (or, with undefined, clear) the delivery status on a text message.
+     *  Used to flip a "queued" message to delivered once it's actually sent.
+     *  No-op if the id isn't found or is a file entry. Returns true if patched. */
+    setStatus(peer, id, status) {
+        const arr = this.byPeer.get(peer);
+        const msg = arr?.find((m) => m.id === id);
+        if (!msg || msg.file)
+            return false;
+        if (status)
+            msg.status = status;
+        else
+            delete msg.status;
+        this.scheduleSave();
+        return true;
+    }
+    /** Outgoing messages still awaiting delivery (peer was offline), oldest
+     *  first — both queued text and queued file chips. The daemon drains this
+     *  on a friend's reconnect. */
+    queuedOutgoing(peer) {
+        const arr = this.byPeer.get(peer) ?? [];
+        return arr.filter((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued"));
+    }
+    /** Append a file-transfer entry (shown as a file chip in the UI). */
+    appendFile(peer, dir, file, ts = Date.now()) {
+        return this.push(peer, { dir, text: "", ts, id: `${ts}-${this.seq++}`, file });
+    }
+    /** Patch an existing file message's transfer fields (status / sent bytes).
+     *  No-op if the id isn't found. Returns true if it patched. */
+    patchFile(peer, id, patch) {
+        const arr = this.byPeer.get(peer);
+        const msg = arr?.find((m) => m.id === id);
+        if (!msg || !msg.file)
+            return false;
+        msg.file = { ...msg.file, ...patch };
+        this.scheduleSave();
+        return true;
+    }
+    /** Look up one persisted message by its stable UI id. */
+    get(peer, id) {
+        return this.byPeer.get(peer)?.find((m) => m.id === id);
+    }
+    /** Remove messages by id. Returns the removed ones so the caller can clean up
+     *  any on-disk file the chip pointed at. */
+    deleteMessages(peer, ids) {
+        const arr = this.byPeer.get(peer);
+        if (!arr || !ids.length)
+            return [];
+        const want = new Set(ids);
+        const removed = [];
+        for (let i = arr.length - 1; i >= 0; i--) {
+            if (want.has(arr[i].id)) {
+                removed.push(arr[i]);
+                arr.splice(i, 1);
+            }
+        }
+        if (removed.length)
+            this.scheduleSave();
+        return removed;
+    }
+    push(peer, msg) {
+        let arr = this.byPeer.get(peer);
+        if (!arr) {
+            arr = [];
+            this.byPeer.set(peer, arr);
+        }
+        arr.push(msg);
+        if (arr.length > MAX_PER_PEER)
+            arr.splice(0, arr.length - MAX_PER_PEER);
+        this.scheduleSave();
+        return msg;
+    }
+    /**
+     * Return history. With no peer, returns every peer's full thread (the legacy
+     * chat-history shape). With a peer, supports pagination: `limit` newest
+     * messages, optionally those strictly older than `before` (ms) for "load
+     * earlier" scrolling.
+     */
+    history(peer, opts = {}) {
+        const out = {};
+        const peers = peer ? [peer] : [...this.byPeer.keys()];
+        for (const p of peers) {
+            let arr = this.byPeer.get(p) ?? [];
+            if (opts.before !== undefined)
+                arr = arr.filter((m) => m.ts < opts.before);
+            if (opts.limit !== undefined && arr.length > opts.limit)
+                arr = arr.slice(arr.length - opts.limit);
+            out[p] = arr;
+        }
+        return out;
+    }
+    /** Most recent message per peer — for the friend-list preview/sort. */
+    lastMessages() {
+        const out = new Map();
+        for (const [p, arr] of this.byPeer) {
+            if (arr.length)
+                out.set(p, arr[arr.length - 1]);
+        }
+        return out;
+    }
+    /** Count messages newer than `sinceTs` for a peer (unread badge). */
+    unreadCount(peer, sinceTs) {
+        const arr = this.byPeer.get(peer);
+        if (!arr)
+            return 0;
+        let n = 0;
+        for (let i = arr.length - 1; i >= 0; i--) {
+            if (arr[i].ts <= sinceTs)
+                break;
+            if (arr[i].dir === "in")
+                n++;
+        }
+        return n;
+    }
+    removePeer(peer) {
+        if (this.byPeer.delete(peer))
+            this.scheduleSave();
+    }
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.flush();
+        }, SAVE_DEBOUNCE_MS);
+        this.saveTimer.unref?.();
+    }
+    /** Force a synchronous flush (called on debounce + on daemon shutdown). */
+    flush() {
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        try {
+            const obj = {};
+            for (const [p, m] of this.byPeer)
+                obj[p] = m;
+            const tmp = `${this.path}.tmp`;
+            writeFileSync(tmp, JSON.stringify(obj), "utf-8");
+            renameSync(tmp, this.path);
+        }
+        catch (err) {
+            this.logger.warn(`Could not save ${this.path}: ${err}`);
+        }
+    }
+}

package/dist/node-config.d.ts

@@ -0,0 +1,16 @@
+export interface BootstrapNode {
+    host: string;
+    port: number;
+    pk: string;
+}
+export interface ExpressNode extends BootstrapNode {
+    tls?: boolean;
+}
+export interface NodeConfig {
+    bootstrapNodes: BootstrapNode[];
+    expressNodes?: ExpressNode[];
+    nickname?: string;
+    statusMessage?: string;
+    autoAccept: boolean;
+}
+export declare function loadNodeConfig(configDir: string): NodeConfig;

package/dist/node-config.js

@@ -0,0 +1,53 @@
+// Where beagle gets its network settings.
+//
+// Priority: the user's decentlan config.yaml if present, else shipped
+// defaults. Reading decentlan's file matters — on a machine that has been
+// running decentlan, beagle must join the SAME network with the SAME bootstrap
+// fleet, or it is a node that technically works and reaches nobody.
+//
+// The bootstrap list itself is data, not code, so it lives in config/ and can
+// be refreshed without a release (decentlan's `agentnet bootstrap update`
+// pulls the published feed the same way).
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import yaml from "js-yaml";
+function shippedBootstraps() {
+    try {
+        const file = resolve(dirname(fileURLToPath(import.meta.url)), "..", "config", "bootstrap-nodes.yaml");
+        const parsed = yaml.load(readFileSync(file, "utf-8"));
+        return (parsed?.bootstrapNodes ?? []).filter((n) => n?.host && n?.pk);
+    }
+    catch {
+        return [];
+    }
+}
+function valid(nodes) {
+    return Array.isArray(nodes) && nodes.length > 0 && nodes.every((n) => n && typeof n.host === "string" && typeof n.pk === "string");
+}
+export function loadNodeConfig(configDir) {
+    const shipped = shippedBootstraps();
+    const cfgPath = resolve(configDir, "config.yaml");
+    if (existsSync(cfgPath)) {
+        try {
+            const cfg = (yaml.load(readFileSync(cfgPath, "utf-8")) ?? {});
+            const fromFile = cfg.carrier?.bootstrapNodes;
+            // decentlan appends `extraBootstrapNodes` (nodes adopted from the
+            // published feed) to its built-in defaults at load time; mirror that so
+            // beagle sees the same fleet the daemon would.
+            const extra = cfg.carrier?.extraBootstrapNodes ?? [];
+            const merged = valid(fromFile) ? [...fromFile, ...extra] : shipped;
+            return {
+                bootstrapNodes: merged.length ? merged : shipped,
+                expressNodes: cfg.carrier?.expressNodes,
+                nickname: cfg.node?.name,
+                statusMessage: cfg.node?.statusMessage,
+                autoAccept: cfg.friends?.autoAccept ?? true,
+            };
+        }
+        catch {
+            // Malformed config must not stop the app — fall through to defaults.
+        }
+    }
+    return { bootstrapNodes: shipped, autoAccept: true };
+}

package/dist/peer-host.d.ts

@@ -0,0 +1,49 @@
+import { type IpcRequest, type IpcResponse } from "./ipc.js";
+export type BackendKind = "daemon" | "embedded";
+export interface PeerHost {
+    readonly kind: BackendKind;
+    /** True when this backend also provides the virtual LAN (TUN + exits), i.e.
+     *  when the network panel has anything to show. */
+    readonly hasVirtualLan: boolean;
+    call(req: IpcRequest): Promise<IpcResponse>;
+    stop(): Promise<void>;
+}
+/** 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 declare function decentlanCarrierDir(configDir: string): string;
+export declare function defaultConfigDir(): string;
+export interface OpenPeerHostResult {
+    host: PeerHost;
+    /** Human-readable reason for the choice, for the startup banner. */
+    why: string;
+}
+export interface OpenPeerHostOptions {
+    configDir: string;
+    bootstrapNodes: {
+        host: string;
+        port: number;
+        pk: string;
+    }[];
+    expressNodes?: {
+        host: string;
+        port: number;
+        pk: string;
+        tls?: boolean;
+    }[];
+    nickname?: string;
+    statusMessage?: string;
+    autoAcceptFriends?: boolean;
+    /** Force a backend instead of auto-detecting. Mainly for testing the
+     *  embedded path on a machine that also runs a daemon. */
+    force?: BackendKind;
+}
+/**
+ * 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 declare function openPeerHost(opts: OpenPeerHostOptions): Promise<OpenPeerHostResult>;