@decentnetwork/beagle 0.1.3 → 0.1.4

package/dist/cli.js

@@ -9,7 +9,8 @@ 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 { openPeerHost, defaultConfigDir, decentlanCarrierDir, makeDaemonHost } from "./peer-host.js";
+import { SwitchablePeerHost } from "./lan-handoff.js";
 import { loadNodeConfig } from "./node-config.js";
 function parseArgs(argv) {
     const get = (flag) => {
@@ -72,6 +73,25 @@ async function main() {
         console.error(error.message);
         process.exit(1);
     }
+    // Wrap the chosen backend so it can be swapped at runtime: enabling the
+    // virtual LAN hands this identity to a decentlan daemon, and stopping that
+    // daemon hands it back. The server above keeps ONE reference — a backend
+    // change must not require restarting beagle.
+    const openEmbedded = async () => (await openPeerHost({
+        configDir: args.configDir,
+        bootstrapNodes,
+        expressNodes,
+        nickname,
+        statusMessage,
+        autoAcceptFriends: autoAccept,
+        force: "embedded",
+    })).host;
+    const lanHost = new SwitchablePeerHost(peerHost, {
+        dataDir: decentlanCarrierDir(args.configDir),
+        makeEmbedded: openEmbedded,
+        makeDaemon: () => makeDaemonHost(decentlanCarrierDir(args.configDir)),
+        onChange: (state) => console.log(`[LAN] backend is now: ${state}`),
+    });
     const moduleDir = dirname(fileURLToPath(import.meta.url));
     // Version lookup for the "my node" panel.
     //
@@ -122,7 +142,8 @@ async function main() {
     // 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),
+        call: (r) => lanHost.call(r),
+        lanHost,
         routesPath: resolve(args.configDir, "routes.yaml"),
         doraRosterPath,
         downloadsDir: resolve(args.configDir, "downloads"),

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.2";
+window.__DK_UI_VERSION="0.1.3";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
@@ -2291,7 +2291,111 @@ function ExitCard({ T, region, activeExit, onSetExit }) {
     return /* @__PURE__ */ React.createElement("div", { key: n.ip, style: { display: "flex", alignItems: "center", gap: 12, padding: "10px 14px", borderBottom: i < region.nodes.length - 1 ? "1px solid var(--line)" : "none", background: active ? "color-mix(in oklab, var(--accent), transparent 92%)" : "transparent" } }, /* @__PURE__ */ React.createElement(StatusDot, { online: n.reachable }), /* @__PURE__ */ React.createElement(Mono, { size: 13, copy: n.ip }, n.ip), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)" } }, n.host), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), n.reachable ? /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11.5, color: n.ping > 200 ? "var(--warn)" : "var(--dim)" } }, n.ping, "ms") : stuck ? /* @__PURE__ */ React.createElement(Tag, { tone: "warn", title: "Announces online but IP won't pass \u2014 session desync or NAT-blocked" }, "online \xB7 no route") : /* @__PURE__ */ React.createElement(Tag, { tone: "off" }, "offline"), active ? /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => onSetExit(null) }, T.routing) : /* @__PURE__ */ React.createElement(Btn, { size: "sm", icon: "route", onClick: () => n.reachable && onSetExit(n.ip), style: { opacity: n.reachable ? 1 : 0.4 } }, T.routeThru));
   })));
 }
-function NetworkTab({ T, me, peers, exits, activeExit, reqCount, onSetExit, onOpenChat }) {
+function LanEnableCard({ backend, onArm, onCancel }) {
+  const [busy, setBusy] = React.useState(false);
+  const [copied, setCopied] = React.useState(false);
+  const releasing = backend.state === "releasing";
+  const cmd = backend.command || "sudo agentnet service install";
+  const copy = () => {
+    navigator.clipboard.writeText(cmd).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1600);
+    }).catch(() => {
+    });
+  };
+  return /* @__PURE__ */ React.createElement("div", { style: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 14,
+    padding: "20px 22px",
+    borderRadius: 12,
+    background: "var(--panel)",
+    border: "1px solid var(--line)"
+  } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 10, flexWrap: "wrap" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 15, fontWeight: 700, color: "var(--text)" } }, "\u865A\u62DF\u5C40\u57DF\u7F51 / Virtual LAN"), /* @__PURE__ */ React.createElement(Tag, { tone: "warn" }, "advanced \xB7 needs admin")), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 13, lineHeight: 1.6, color: "var(--dim)" } }, "\u804A\u5929\u3001\u6587\u4EF6\u3001\u901A\u8BDD\u90FD", /* @__PURE__ */ React.createElement("b", null, "\u4E0D\u9700\u8981"), "\u5B83 \u2014\u2014 \u90A3\u4E9B\u5DF2\u7ECF\u5728\u5DE5\u4F5C\u4E86\u3002\u865A\u62DF\u5C40\u57DF\u7F51\u989D\u5916\u63D0\u4F9B", /* @__PURE__ */ React.createElement("b", null, "\u79C1\u6709 IP \u4E92\u901A"), "\u548C", /* @__PURE__ */ React.createElement("b", null, "\u51FA\u53E3\u4EE3\u7406\u8DEF\u7531"), ",\u8981\u521B\u5EFA TUN \u8BBE\u5907,\u6240\u4EE5\u9700\u8981\u7BA1\u7406\u5458\u6743\u9650\u3002", /* @__PURE__ */ React.createElement("br", null), "Beagle \u4E0D\u4F1A\u66FF\u4F60\u63D0\u6743:\u547D\u4EE4\u7531\u4F60\u81EA\u5DF1\u8FD0\u884C,\u5BC6\u7801\u7531\u7CFB\u7EDF\u5411\u4F60\u8981\u3002"), !releasing ? /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 9 } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11.5, color: "var(--faint)", lineHeight: 1.5 } }, "\u7B2C 1 \u6B65 \xB7 Beagle \u5148\u4EA4\u51FA\u5F53\u524D\u8EAB\u4EFD \u2014\u2014 \u540C\u4E00\u8EAB\u4EFD\u4E0D\u80FD\u540C\u65F6\u8DD1\u4E24\u4E2A peer, \u6240\u4EE5\u8FD9\u4E00\u6B65\u4F1A\u8BA9\u6D88\u606F", /* @__PURE__ */ React.createElement("b", null, "\u77ED\u6682\u79BB\u7EBF"), "\u3002"), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: async () => {
+        setBusy(true);
+        try {
+          await onArm();
+        } finally {
+          setBusy(false);
+        }
+      },
+      disabled: busy,
+      style: {
+        alignSelf: "flex-start",
+        padding: "9px 16px",
+        borderRadius: 10,
+        border: "none",
+        cursor: busy ? "default" : "pointer",
+        background: "var(--accent)",
+        color: "#fff",
+        fontFamily: "var(--mono)",
+        fontSize: 13,
+        fontWeight: 700,
+        opacity: busy ? 0.6 : 1
+      }
+    },
+    busy ? "\u2026" : "\u542F\u7528\u865A\u62DF\u5C40\u57DF\u7F51"
+  )) : /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 10 } }, /* @__PURE__ */ React.createElement("div", { style: {
+    display: "flex",
+    alignItems: "center",
+    gap: 8,
+    padding: "9px 12px",
+    borderRadius: 9,
+    background: "rgba(245,158,11,0.14)",
+    border: "1px solid rgba(245,158,11,0.5)"
+  } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12, color: "var(--text)", lineHeight: 1.5 } }, "\u6D88\u606F\u5DF2\u79BB\u7EBF \u2014\u2014 \u8EAB\u4EFD\u5DF2\u4EA4\u51FA,\u7B49\u5F85\u5B88\u62A4\u8FDB\u7A0B\u63A5\u7BA1", backend.releaseSecondsLeft > 0 ? `(${Math.floor(backend.releaseSecondsLeft / 60)} \u5206 ${backend.releaseSecondsLeft % 60} \u79D2\u540E\u81EA\u52A8\u6062\u590D)` : "")), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11.5, color: "var(--faint)" } }, "\u7B2C 2 \u6B65 \xB7 \u5728\u7EC8\u7AEF\u91CC\u8FD0\u884C(\u7CFB\u7EDF\u4F1A\u5411\u4F60\u8981\u5BC6\u7801):"), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement("code", { style: {
+    flex: 1,
+    fontFamily: "var(--mono)",
+    fontSize: 13,
+    padding: "10px 12px",
+    borderRadius: 8,
+    background: "var(--panel-2)",
+    border: "1px solid var(--line)",
+    color: "var(--text)",
+    overflowX: "auto"
+  } }, cmd), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: copy,
+      style: {
+        flexShrink: 0,
+        padding: "9px 13px",
+        borderRadius: 8,
+        border: "1px solid var(--line)",
+        cursor: "pointer",
+        background: "var(--panel-2)",
+        color: "var(--text)",
+        fontFamily: "var(--mono)",
+        fontSize: 12
+      }
+    },
+    copied ? "\u5DF2\u590D\u5236" : "\u590D\u5236"
+  )), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11.5, color: "var(--faint)" } }, "\u7B2C 3 \u6B65 \xB7 \u5B88\u62A4\u8FDB\u7A0B\u4E00\u8D77\u6765,Beagle \u81EA\u5DF1\u5207\u8FC7\u53BB\u5E76\u6062\u590D\u6D88\u606F \u2014\u2014 \u4E0D\u7528\u91CD\u542F\u3002"), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: () => onCancel(),
+      style: {
+        alignSelf: "flex-start",
+        padding: "7px 13px",
+        borderRadius: 8,
+        border: "1px solid var(--line)",
+        cursor: "pointer",
+        background: "transparent",
+        color: "var(--dim)",
+        fontFamily: "var(--mono)",
+        fontSize: 12
+      }
+    },
+    "\u53D6\u6D88,\u6062\u590D\u6D88\u606F"
+  )));
+}
+function NetworkTab({ T, me, peers, exits, activeExit, reqCount, onSetExit, onOpenChat, backend, onArmLan, onCancelLan }) {
+  if (backend && backend.switchable && !backend.hasVirtualLan) {
+    return /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", background: "var(--bg)" } }, /* @__PURE__ */ React.createElement("div", { style: { maxWidth: 1040, margin: "0 auto", padding: "24px 28px 60px", display: "flex", flexDirection: "column", gap: 26 } }, /* @__PURE__ */ React.createElement(MyNode, { T, me, activeExit, peers, reqCount }), /* @__PURE__ */ React.createElement(LanEnableCard, { backend, onArm: onArmLan, onCancel: onCancelLan })));
+  }
   return /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", background: "var(--bg)" } }, /* @__PURE__ */ React.createElement("div", { style: { maxWidth: 1040, margin: "0 auto", padding: "24px 28px 60px", display: "flex", flexDirection: "column", gap: 26 } }, /* @__PURE__ */ React.createElement(MyNode, { T, me, activeExit, peers, reqCount }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 12 } }, /* @__PURE__ */ React.createElement(Section, { label: T.peerRouting, count: peers.length }), /* @__PURE__ */ React.createElement(PeerTable, { T, peers, onOpenChat })), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 12 } }, /* @__PURE__ */ React.createElement(Section, { label: T.exitNodes, trailing: /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { icon: "plus", size: "sm" }, T.addExit)) }), activeExit && /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 10, padding: "11px 14px", borderRadius: 10, background: "color-mix(in oklab, var(--warn), transparent 90%)", border: "1px solid color-mix(in oklab, var(--warn), transparent 70%)" } }, /* @__PURE__ */ React.createElement(Icon, { name: "route", size: 17, color: "var(--warn)", stroke: 2 }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12.5, color: "var(--text)" } }, T.egressVia), /* @__PURE__ */ React.createElement(Mono, { size: 13, copy: activeExit }, activeExit), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "unlink", size: "sm", onClick: () => onSetExit(null) }, T.stopRouting)), /* @__PURE__ */ React.createElement("div", { style: { display: "grid", gridTemplateColumns: "1fr 1fr", gap: 12 } }, exits.map((r) => /* @__PURE__ */ React.createElement(ExitCard, { key: r.region, T, region: r, activeExit, onSetExit }))))));
 }
 Object.assign(window, { NetworkTab });
@@ -3367,6 +3471,28 @@ function DkApp() {
   const [activeId, setActiveId] = React.useState(null);
   const data = useDaemonData();
   const me = data.me;
+  const [backend, setBackend] = React.useState(null);
+  const refreshBackend = React.useCallback(() => {
+    dkGet("/api/backend").then((b) => {
+      if (b && b.ok)
+        setBackend(b);
+    }).catch(() => {
+    });
+  }, []);
+  React.useEffect(() => {
+    refreshBackend();
+    const ms = backend && backend.state === "releasing" ? 1500 : 8e3;
+    const t2 = setInterval(refreshBackend, ms);
+    return () => clearInterval(t2);
+  }, [refreshBackend, backend && backend.state]);
+  const armLan = React.useCallback(async () => {
+    await dkPost("/api/lan-arm", {});
+    refreshBackend();
+  }, [refreshBackend]);
+  const cancelLan = React.useCallback(async () => {
+    await dkPost("/api/lan-cancel", {});
+    refreshBackend();
+  }, [refreshBackend]);
   React.useEffect(() => {
     const mine = window.__DK_UI_VERSION;
     const served = me && me.lanVer;
@@ -3516,7 +3642,7 @@ function DkApp() {
     { id: "network", icon: "network", label: T.network },
     { id: "profile", icon: "userRound", label: T.profile }
   ];
-  return /* @__PURE__ */ React.createElement("div", { style: { ...vars, "--row-pad": rowPad, position: "fixed", inset: 0, display: "flex", background: "var(--bg)", color: "var(--text)", fontFamily: "var(--ui)" } }, /* @__PURE__ */ React.createElement("div", { style: { width: 68, flexShrink: 0, borderRight: "1px solid var(--line)", background: "var(--rail)", display: "flex", flexDirection: "column", alignItems: "center", padding: "14px 0", gap: 8 } }, /* @__PURE__ */ React.createElement("div", { style: { width: 38, height: 38, borderRadius: 10, background: "var(--accent)", display: "flex", alignItems: "center", justifyContent: "center", marginBottom: 8 } }, /* @__PURE__ */ React.createElement(Icon, { name: "terminal", size: 20, color: "#fff", stroke: 2.2 })), nav.map((n) => /* @__PURE__ */ React.createElement(RailBtn, { key: n.id, icon: n.icon, label: n.label, active: tab === n.id, soon: n.soon, onClick: () => setTab(n.id) })), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), /* @__PURE__ */ React.createElement("div", { style: { position: "relative" } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer: { ...me, id: me.userId, agent: false }, size: 36, radius: 9 }))), /* @__PURE__ */ React.createElement("div", { style: { flex: 1, minWidth: 0, minHeight: 0, display: "flex", flexDirection: "column" } }, /* @__PURE__ */ React.createElement("div", { style: { height: 46, flexShrink: 0, borderBottom: "1px solid var(--line)", background: "var(--panel)", display: "flex", alignItems: "center", gap: 12, padding: "0 16px" } }, /* @__PURE__ */ React.createElement("svg", { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: "var(--accent)", strokeWidth: 2.2, strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block", flexShrink: 0 } }, /* @__PURE__ */ React.createElement("path", { d: "m4.5 17 6-6-6-6" }), /* @__PURE__ */ React.createElement("path", { d: "M12 18.5h7.5" })), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 14, fontWeight: 700, letterSpacing: -0.3, color: "var(--text)" } }, "beagle"), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12, color: "var(--faint)" } }, "\xB7 ", nav.find((n) => n.id === tab).label.toLowerCase()), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), /* @__PURE__ */ React.createElement(Tag, { tone: "accent" }, me.channel, " \xB7 lan ", me.lanVer), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 7, padding: "0 4px" } }, /* @__PURE__ */ React.createElement(StatusDot, { online: me.online }), /* @__PURE__ */ React.createElement(Mono, { size: 12.5, copy: me.ip }, me.ip)), /* @__PURE__ */ React.createElement("span", { style: { width: 1, height: 22, background: "var(--line)" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer: { ...me, id: me.userId, agent: false }, size: 26, radius: 7 }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: "var(--text)" } }, me.name))), tab === "chat" && /* @__PURE__ */ React.createElement(ChatTab, { T, lang: t.lang, peers, requests, activeId, thread: data.threads[activeId], onSelect, onAct, onAdd, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread: () => activeId && data.loadThread(activeId), prefillAddr: pendingAddr, onPrefillConsumed: () => setPendingAddr("") }), tab === "network" && /* @__PURE__ */ React.createElement(NetworkTab, { T, me, peers, exits, activeExit, reqCount: requests.length, onSetExit, onOpenChat }), tab === "profile" && /* @__PURE__ */ React.createElement(ProfileTab, { T, me, onEdit })), /* @__PURE__ */ React.createElement(TweaksPanel, null, /* @__PURE__ */ React.createElement(TweakSection, { label: t.lang === "zh" ? "\u5916\u89C2" : "Appearance" }), /* @__PURE__ */ React.createElement(
+  return /* @__PURE__ */ React.createElement("div", { style: { ...vars, "--row-pad": rowPad, position: "fixed", inset: 0, display: "flex", background: "var(--bg)", color: "var(--text)", fontFamily: "var(--ui)" } }, /* @__PURE__ */ React.createElement("div", { style: { width: 68, flexShrink: 0, borderRight: "1px solid var(--line)", background: "var(--rail)", display: "flex", flexDirection: "column", alignItems: "center", padding: "14px 0", gap: 8 } }, /* @__PURE__ */ React.createElement("div", { style: { width: 38, height: 38, borderRadius: 10, background: "var(--accent)", display: "flex", alignItems: "center", justifyContent: "center", marginBottom: 8 } }, /* @__PURE__ */ React.createElement(Icon, { name: "terminal", size: 20, color: "#fff", stroke: 2.2 })), nav.map((n) => /* @__PURE__ */ React.createElement(RailBtn, { key: n.id, icon: n.icon, label: n.label, active: tab === n.id, soon: n.soon, onClick: () => setTab(n.id) })), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), /* @__PURE__ */ React.createElement("div", { style: { position: "relative" } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer: { ...me, id: me.userId, agent: false }, size: 36, radius: 9 }))), /* @__PURE__ */ React.createElement("div", { style: { flex: 1, minWidth: 0, minHeight: 0, display: "flex", flexDirection: "column" } }, /* @__PURE__ */ React.createElement("div", { style: { height: 46, flexShrink: 0, borderBottom: "1px solid var(--line)", background: "var(--panel)", display: "flex", alignItems: "center", gap: 12, padding: "0 16px" } }, /* @__PURE__ */ React.createElement("svg", { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: "var(--accent)", strokeWidth: 2.2, strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block", flexShrink: 0 } }, /* @__PURE__ */ React.createElement("path", { d: "m4.5 17 6-6-6-6" }), /* @__PURE__ */ React.createElement("path", { d: "M12 18.5h7.5" })), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 14, fontWeight: 700, letterSpacing: -0.3, color: "var(--text)" } }, "beagle"), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12, color: "var(--faint)" } }, "\xB7 ", nav.find((n) => n.id === tab).label.toLowerCase()), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), /* @__PURE__ */ React.createElement(Tag, { tone: "accent" }, me.channel, " \xB7 lan ", me.lanVer), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 7, padding: "0 4px" } }, /* @__PURE__ */ React.createElement(StatusDot, { online: me.online }), /* @__PURE__ */ React.createElement(Mono, { size: 12.5, copy: me.ip }, me.ip)), /* @__PURE__ */ React.createElement("span", { style: { width: 1, height: 22, background: "var(--line)" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer: { ...me, id: me.userId, agent: false }, size: 26, radius: 7 }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: "var(--text)" } }, me.name))), tab === "chat" && /* @__PURE__ */ React.createElement(ChatTab, { T, lang: t.lang, peers, requests, activeId, thread: data.threads[activeId], onSelect, onAct, onAdd, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread: () => activeId && data.loadThread(activeId), prefillAddr: pendingAddr, onPrefillConsumed: () => setPendingAddr("") }), tab === "network" && /* @__PURE__ */ React.createElement(NetworkTab, { T, me, peers, exits, activeExit, reqCount: requests.length, onSetExit, onOpenChat, backend, onArmLan: armLan, onCancelLan: cancelLan }), tab === "profile" && /* @__PURE__ */ React.createElement(ProfileTab, { T, me, onEdit })), /* @__PURE__ */ React.createElement(TweaksPanel, null, /* @__PURE__ */ React.createElement(TweakSection, { label: t.lang === "zh" ? "\u5916\u89C2" : "Appearance" }), /* @__PURE__ */ React.createElement(
     TweakRadio,
     {
       label: t.lang === "zh" ? "\u4E3B\u9898" : "Theme",

package/dist/embedded-host.d.ts

@@ -3,6 +3,8 @@ import type { PeerHost } from "./peer-host.js";
 export interface EmbeddedHostOptions {
     configDir: string;
     keyFile: string;
+    /** Carrier data dir — where the identity and its lock live. */
+    dataDir: string;
     bootstrapNodes: {
         host: string;
         port: number;

package/dist/embedded-host.js

@@ -16,6 +16,7 @@ import { CarrierNode } from "./carrier-node.js";
 import { MessageStore } from "./message-store.js";
 import { FriendMetaStore } from "./friend-meta.js";
 import { Logger } from "./logger.js";
+import { acquireIdentityLock } from "./identity-lock.js";
 /** Files bigger than this are not queued for an offline friend — the bytes sit
  *  on disk until they reconnect, and an unbounded queue is how you fill a
  *  user's disk by accident. Live transfers have no such limit. */
@@ -54,6 +55,8 @@ export class EmbeddedHost {
     /** fileId -> which chat message it belongs to, so progress can patch it. */
     #activeSends = new Map();
     #autoAccept;
+    /** Released when this peer stops, so the daemon may take the identity. */
+    #releaseIdentity = null;
     constructor(opts) {
         this.#opts = opts;
         this.#autoAccept = opts.autoAcceptFriends;
@@ -67,6 +70,20 @@ export class EmbeddedHost {
         return resolve(this.#opts.configDir, "outbox");
     }
     async start() {
+        // Take the identity lock BEFORE creating the peer. decentlan's daemon
+        // checks this same file, so holding it is what stops `agentnet up` from
+        // starting a second peer on our keypair while we are live.
+        this.#releaseIdentity = acquireIdentityLock(this.#opts.dataDir);
+        try {
+            await this.#startPeer();
+        }
+        catch (err) {
+            this.#releaseIdentity?.();
+            this.#releaseIdentity = null;
+            throw err;
+        }
+    }
+    async #startPeer() {
         await this.#node.create({
             keyFile: this.#opts.keyFile,
             bootstrapNodes: this.#opts.bootstrapNodes,
@@ -225,7 +242,11 @@ export class EmbeddedHost {
         return () => this.#events.off("event", fn);
     }
     async stop() {
+        // Stop the peer FIRST, then release the lock. The reverse order would open
+        // a window where a daemon could start while our peer is still live.
         await this.#node.stop();
+        this.#releaseIdentity?.();
+        this.#releaseIdentity = null;
     }
     // -------------------------------------------------------------------------
     // The op surface — same contract as the daemon's IPC.

package/dist/identity-lock.d.ts

@@ -0,0 +1,18 @@
+/** Same path decentlan uses: `<carrier dataDir>/daemon.pid`. */
+export declare function identityLockPath(dataDir: string): string;
+/** The live pid holding this identity, or null when it is free. */
+export declare function identityLockHolder(dataDir: string): number | null;
+export declare class IdentityLockedError extends Error {
+    readonly holderPid: number;
+    constructor(holderPid: number);
+}
+/**
+ * Take the lock for this process. Throws {@link IdentityLockedError} when a
+ * live holder exists — refusing to start is always better than starting a
+ * second peer, because the damage from the latter shows up later, as
+ * unexplained message loss, rather than here as a clear error.
+ *
+ * A stale file (holder gone) is taken over silently: that is a crash we already
+ * survived, not a conflict.
+ */
+export declare function acquireIdentityLock(dataDir: string): () => void;

package/dist/identity-lock.js

@@ -0,0 +1,85 @@
+// The one hard constraint of the split: an identity must never have two live
+// Carrier peers. Two peers on one keypair scramble each other's net_crypto
+// sessions — the failure mode we have already paid for twice.
+//
+// decentlan enforces this with a pidfile next to the keypair
+// (<dataDir>/daemon.pid): its daemon refuses to start when that file names a
+// LIVE process. Beagle's embedded peer holds the same identity, so it must take
+// the same lock — otherwise `sudo agentnet service install` happily starts a
+// daemon alongside it and both are live on one keypair, which is exactly the
+// state the pidfile exists to prevent.
+//
+// So this is not beagle bookkeeping. It is beagle joining an existing mutual
+// exclusion protocol whose other participant we cannot modify (decentlan is
+// sealed) and must not fork.
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+/** Same path decentlan uses: `<carrier dataDir>/daemon.pid`. */
+export function identityLockPath(dataDir) {
+    return resolve(dataDir, "daemon.pid");
+}
+/** The live pid holding this identity, or null when it is free. */
+export function identityLockHolder(dataDir) {
+    const file = identityLockPath(dataDir);
+    if (!existsSync(file))
+        return null;
+    const pid = Number.parseInt(readFileSync(file, "utf-8").trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    try {
+        // Signal 0 tests for existence without touching the process.
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch (err) {
+        // EPERM means it exists but belongs to another user (a root-owned daemon,
+        // the normal case) — that still counts as held. ESRCH means it is gone.
+        return err.code === "EPERM" ? pid : null;
+    }
+}
+export class IdentityLockedError extends Error {
+    holderPid;
+    constructor(holderPid) {
+        super(`This identity is already in use by process ${holderPid} — probably the decentlan daemon. ` +
+            `Beagle will use it over IPC instead of starting a second peer.`);
+        this.name = "IdentityLockedError";
+        this.holderPid = holderPid;
+    }
+}
+/**
+ * Take the lock for this process. Throws {@link IdentityLockedError} when a
+ * live holder exists — refusing to start is always better than starting a
+ * second peer, because the damage from the latter shows up later, as
+ * unexplained message loss, rather than here as a clear error.
+ *
+ * A stale file (holder gone) is taken over silently: that is a crash we already
+ * survived, not a conflict.
+ */
+export function acquireIdentityLock(dataDir) {
+    const holder = identityLockHolder(dataDir);
+    if (holder !== null && holder !== process.pid)
+        throw new IdentityLockedError(holder);
+    // On a fresh install the data dir does not exist yet — the SDK creates it
+    // when it writes the keypair, which happens AFTER this point. We must take
+    // the lock before the peer starts, so we create the directory ourselves.
+    mkdirSync(dataDir, { recursive: true });
+    const file = identityLockPath(dataDir);
+    writeFileSync(file, String(process.pid), "utf-8");
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        // Only remove it if it is still OURS. A daemon may have taken over after we
+        // released the peer during the LAN handoff, and deleting its lock would
+        // silently re-open the door this whole module exists to keep shut.
+        try {
+            const now = Number.parseInt(readFileSync(file, "utf-8").trim(), 10);
+            if (now === process.pid)
+                unlinkSync(file);
+        }
+        catch {
+            // already gone, or unreadable — nothing to release
+        }
+    };
+}

package/dist/lan-handoff.d.ts

@@ -0,0 +1,48 @@
+import { type IpcRequest, type IpcResponse } from "./ipc.js";
+import { Logger } from "./logger.js";
+import type { PeerHost } from "./peer-host.js";
+export type HandoffState = "embedded" | "releasing" | "daemon";
+export interface SwitchableHostOptions {
+    dataDir: string;
+    /** Build a fresh embedded host. Called on first start and on every fallback,
+     *  because a stopped peer is not restartable — the SDK ties its lifetime to
+     *  the instance. */
+    makeEmbedded: () => Promise<PeerHost>;
+    makeDaemon: () => PeerHost;
+    onChange?: (state: HandoffState, host: PeerHost | null) => void;
+    log?: Logger;
+}
+/**
+ * A PeerHost whose backend can change under it.
+ *
+ * Everything above this (the HTTP server, the UI) keeps one reference and never
+ * learns that the peer was swapped — which is the point: a backend change must
+ * not be a restart.
+ */
+export declare class SwitchablePeerHost implements PeerHost {
+    #private;
+    constructor(initial: PeerHost, opts: SwitchableHostOptions);
+    get kind(): PeerHost["kind"];
+    get hasVirtualLan(): boolean;
+    get state(): HandoffState;
+    /** Seconds left before `releasing` gives up; 0 when not releasing. */
+    get releaseSecondsLeft(): number;
+    call(req: IpcRequest): Promise<IpcResponse>;
+    stop(): Promise<void>;
+    /**
+     * Step 1 of enabling: give up the identity so a daemon can take it.
+     *
+     * We do NOT run the installer. It needs root, and beagle escalating on the
+     * user's behalf — even via a prompt we trigger — is a privilege we do not
+     * want this app to have. The UI shows the command; the OS asks for the
+     * password; the user decides.
+     */
+    armForDaemon(): Promise<{
+        state: HandoffState;
+        command: string;
+    }>;
+    /** Abandon the handoff and bring the embedded peer back. */
+    cancelArm(): Promise<HandoffState>;
+}
+/** The command the user runs. Shown, never executed by us. */
+export declare const INSTALL_COMMAND = "sudo agentnet service install";

package/dist/lan-handoff.js

@@ -0,0 +1,171 @@
+// Phase 3 — turning the virtual LAN on, without ever having two live peers.
+//
+// Beagle runs its own Carrier peer when no decentlan daemon exists. Enabling
+// the LAN means a daemon takes over that identity. Those two cannot overlap
+// (see identity-lock.ts), and the daemon needs root, which beagle must never
+// acquire on the user's behalf. So the handoff is a SEQUENCE with a human step
+// in the middle, not a button that does everything:
+//
+//   embedded  --arm-->  releasing  --(user runs sudo)-->  daemon
+//      ^                                                     |
+//      +---------------- (daemon stops) ---------------------+
+//
+// `releasing` is the honest name for the middle state: our peer is down and the
+// daemon is not up yet, so messaging is offline and the UI must say so. Hiding
+// that gap would make dropped messages look like a network fault.
+import { daemonIsRunning } from "./ipc.js";
+import { Logger } from "./logger.js";
+/** How often we look for the daemon socket appearing or vanishing. */
+const WATCH_INTERVAL_MS = 1500;
+/** How long we stay in `releasing` before giving up and coming back. */
+const RELEASE_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * A PeerHost whose backend can change under it.
+ *
+ * Everything above this (the HTTP server, the UI) keeps one reference and never
+ * learns that the peer was swapped — which is the point: a backend change must
+ * not be a restart.
+ */
+export class SwitchablePeerHost {
+    #inner;
+    #state;
+    #opts;
+    #log;
+    #timer = null;
+    #releaseDeadline = 0;
+    #busy = false;
+    constructor(initial, opts) {
+        this.#inner = initial;
+        this.#state = initial.kind === "daemon" ? "daemon" : "embedded";
+        this.#opts = opts;
+        this.#log = opts.log ?? new Logger({ prefix: "LAN" });
+        this.#watch();
+    }
+    get kind() {
+        return this.#inner?.kind ?? "embedded";
+    }
+    get hasVirtualLan() {
+        return this.#inner?.hasVirtualLan ?? false;
+    }
+    get state() {
+        return this.#state;
+    }
+    /** Seconds left before `releasing` gives up; 0 when not releasing. */
+    get releaseSecondsLeft() {
+        if (this.#state !== "releasing")
+            return 0;
+        return Math.max(0, Math.round((this.#releaseDeadline - Date.now()) / 1000));
+    }
+    async call(req) {
+        if (!this.#inner) {
+            // Fail fast and say why. A hung call here would surface as the UI
+            // freezing, which reads as a bug rather than as "you have a step to do".
+            return {
+                ok: false,
+                error: "Beagle released its peer and is waiting for the decentlan daemon to start. Messaging resumes when it does.",
+            };
+        }
+        return this.#inner.call(req);
+    }
+    async stop() {
+        if (this.#timer)
+            clearInterval(this.#timer);
+        this.#timer = null;
+        await this.#inner?.stop();
+    }
+    /**
+     * Step 1 of enabling: give up the identity so a daemon can take it.
+     *
+     * We do NOT run the installer. It needs root, and beagle escalating on the
+     * user's behalf — even via a prompt we trigger — is a privilege we do not
+     * want this app to have. The UI shows the command; the OS asks for the
+     * password; the user decides.
+     */
+    async armForDaemon() {
+        if (this.#state === "daemon")
+            return { state: "daemon", command: INSTALL_COMMAND };
+        if (this.#busy)
+            return { state: this.#state, command: INSTALL_COMMAND };
+        this.#busy = true;
+        try {
+            this.#log.info("releasing the embedded peer so a daemon can take this identity");
+            const old = this.#inner;
+            this.#inner = null; // reject calls from here on, rather than racing a stopping peer
+            this.#setState("releasing");
+            this.#releaseDeadline = Date.now() + RELEASE_TIMEOUT_MS;
+            await old?.stop();
+            return { state: this.#state, command: INSTALL_COMMAND };
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    /** Abandon the handoff and bring the embedded peer back. */
+    async cancelArm() {
+        if (this.#state !== "releasing")
+            return this.#state;
+        await this.#backToEmbedded("cancelled by the user");
+        return this.#state;
+    }
+    #setState(next) {
+        if (this.#state === next)
+            return;
+        this.#state = next;
+        this.#opts.onChange?.(next, this.#inner);
+    }
+    #watch() {
+        this.#timer = setInterval(() => {
+            void this.#tick().catch((err) => this.#log.warn(`watch failed: ${err.message}`));
+        }, WATCH_INTERVAL_MS);
+        this.#timer.unref?.();
+    }
+    async #tick() {
+        if (this.#busy)
+            return;
+        const daemonUp = daemonIsRunning(this.#opts.dataDir);
+        if (this.#state === "releasing") {
+            if (daemonUp) {
+                this.#busy = true;
+                try {
+                    this.#log.info("daemon is up — switching to the IPC backend");
+                    this.#inner = this.#opts.makeDaemon();
+                    this.#setState("daemon");
+                }
+                finally {
+                    this.#busy = false;
+                }
+            }
+            else if (Date.now() > this.#releaseDeadline) {
+                await this.#backToEmbedded("timed out waiting for the daemon");
+            }
+            return;
+        }
+        // The daemon went away (stopped, uninstalled, crashed). Take the identity
+        // back so messaging keeps working — a user who stops the LAN service should
+        // not silently lose chat.
+        if (this.#state === "daemon" && !daemonUp) {
+            await this.#backToEmbedded("the daemon is no longer running");
+        }
+    }
+    async #backToEmbedded(why) {
+        if (this.#busy)
+            return;
+        this.#busy = true;
+        try {
+            this.#log.info(`falling back to the embedded peer: ${why}`);
+            this.#inner = null;
+            this.#inner = await this.#opts.makeEmbedded();
+            this.#setState("embedded");
+        }
+        catch (err) {
+            // Leaving #inner null is correct: call() then returns a clear error
+            // instead of pretending. The next tick retries.
+            this.#log.error(`could not restart the embedded peer: ${err.message}`);
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+}
+/** The command the user runs. Shown, never executed by us. */
+export const INSTALL_COMMAND = "sudo agentnet service install";

package/dist/peer-host.d.ts

@@ -13,6 +13,9 @@ export interface PeerHost {
  *  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;
+/** Build an IPC-backed host directly. Used by the LAN handoff, which knows a
+ *  daemon has appeared and needs to switch to it without re-running detection. */
+export declare function makeDaemonHost(dataDir: string): PeerHost;
 export interface OpenPeerHostResult {
     host: PeerHost;
     /** Human-readable reason for the choice, for the startup banner. */

package/dist/peer-host.js

@@ -58,6 +58,11 @@ class DaemonHost {
         // never start or stop the user's daemon as a side effect.
     }
 }
+/** Build an IPC-backed host directly. Used by the LAN handoff, which knows a
+ *  daemon has appeared and needs to switch to it without re-running detection. */
+export function makeDaemonHost(dataDir) {
+    return new DaemonHost(dataDir);
+}
 /**
  * Pick a backend.
  *
@@ -86,6 +91,7 @@ export async function openPeerHost(opts) {
     const host = new EmbeddedHost({
         configDir: opts.configDir,
         keyFile,
+        dataDir,
         bootstrapNodes: opts.bootstrapNodes,
         expressNodes: opts.expressNodes,
         nickname: opts.nickname,

package/dist/server.d.ts

@@ -20,6 +20,20 @@ export interface BeagleServerOptions {
     /** Directory where the daemon saves received files (<configDir>/downloads).
      *  Used to serve GET /api/file-download. Undefined disables downloads. */
     downloadsDir?: string;
+    /** The swappable backend, so the UI can show which one is live and drive the
+     *  LAN handoff. Optional: a caller that pins one backend just omits it and
+     *  the network panel falls back to "no virtual LAN here". */
+    lanHost?: {
+        readonly kind: string;
+        readonly hasVirtualLan: boolean;
+        readonly state: string;
+        readonly releaseSecondsLeft: number;
+        armForDaemon: () => Promise<{
+            state: string;
+            command: string;
+        }>;
+        cancelArm: () => Promise<string>;
+    };
     listenHost?: string;
     listenPort?: number;
     log?: (msg: string) => void;

package/dist/server.js

@@ -17,6 +17,7 @@ import net from "node:net";
 import { existsSync, readFileSync, writeFileSync, statSync, createReadStream } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
+import { INSTALL_COMMAND as LAN_INSTALL_COMMAND } from "./lan-handoff.js";
 import yaml from "js-yaml";
 import { DEFAULT_EXITS } from "./exits.js";
 // Directory holding the built desktop UI bundle (index.html, app.js, vendor/).
@@ -798,6 +799,41 @@ export function startBeagleServer(opts) {
             }
             // Brief 30: submit a rendered form. The values are the user's own input;
             // the host validates and bounds them before they hit the wire.
+            // Which backend is live, and where we are in the LAN handoff. Polled by
+            // the network panel, so it must be cheap and must never throw.
+            if (req.method === "GET" && url === "/api/backend") {
+                sendJson(res, 200, {
+                    ok: true,
+                    kind: opts.lanHost?.kind ?? "embedded",
+                    hasVirtualLan: opts.lanHost?.hasVirtualLan ?? false,
+                    state: opts.lanHost?.state ?? "embedded",
+                    releaseSecondsLeft: opts.lanHost?.releaseSecondsLeft ?? 0,
+                    command: LAN_INSTALL_COMMAND,
+                    switchable: Boolean(opts.lanHost),
+                });
+                return;
+            }
+            // Step 1 of enabling the LAN: release the identity. We stop our peer and
+            // then wait — we do NOT run the installer, because it needs root and
+            // beagle escalating for the user is a privilege this app should not have.
+            if (req.method === "POST" && url === "/api/lan-arm") {
+                if (!opts.lanHost) {
+                    sendJson(res, 400, { ok: false, error: "this backend cannot be switched" });
+                    return;
+                }
+                const r = await opts.lanHost.armForDaemon();
+                sendJson(res, 200, { ok: true, ...r });
+                return;
+            }
+            if (req.method === "POST" && url === "/api/lan-cancel") {
+                if (!opts.lanHost) {
+                    sendJson(res, 400, { ok: false, error: "this backend cannot be switched" });
+                    return;
+                }
+                const state = await opts.lanHost.cancelArm();
+                sendJson(res, 200, { ok: true, state });
+                return;
+            }
             if (req.method === "POST" && url === "/api/chat-send") {
                 const { userid, text } = await readBody(req);
                 const r = await opts.call({ op: "chat-send", userid, text });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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",