@decentnetwork/beagle 0.1.126 → 0.1.128

package/dist/cli.js

@@ -173,6 +173,8 @@ async function main() {
         downloadsDir: resolve(args.configDir, "downloads"),
         messagesPath: resolve(args.configDir, "messages.json"),
         servicePeersPath: resolve(args.configDir, "service-peers-local.json"),
+        greetingsPath: resolve(args.configDir, "friend-greetings.json"),
+        exitStatePath: resolve(args.configDir, "beagle-exit-state.json"),
         callIce: {
             keyFile: resolve(decentlanCarrierDir(args.configDir), "keypair.json"),
             bootstrapNodes,

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.126";
+window.__DK_UI_VERSION="0.1.128";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -272,7 +272,7 @@ window.__DK_UI_VERSION="0.1.126";
     };
     (thread || []).forEach((m, i) => {
       const hit = m && !m.day ? isProto({ text: m.text, dir: m && m.from === "me" ? "out" : "in", ts: m && m.ts }) : false;
-      if (!hit || m && m.file) {
+      if (!hit || m && (m.file || m.kind === "friend-request")) {
         flush();
         out.push(m);
         return;
@@ -442,6 +442,10 @@ window.__DK_UI_VERSION="0.1.126";
     cancelSend: (userid, ids) => dkPost("/api/file-cancel", { userid, ids }),
     retrySend: (userid, ids) => dkPost("/api/file-retry", { userid, ids }),
     setProfile: (name, description) => dkPost("/api/set-profile", { name, description }),
+    // Probe a failed exit once, now (or every failed exit with all=true). Exits
+    // that failed three times in a row are never probed again on their own.
+    reconnectExit: (ip) => dkPost("/api/exits/reconnect", { ip }),
+    reconnectAllExits: () => dkPost("/api/exits/reconnect", { all: true }),
     // Used by the browser's welcome flow, which also picks an avatar and marks
     // first run done. Harmless where there is no welcome flow: nothing calls it.
     setProfileFull: (p) => dkPost("/api/set-profile", p),
@@ -529,7 +533,10 @@ window.__DK_UI_VERSION="0.1.126";
       // Brief 30: a validated component form, already whitelisted host-side.
       // Passed through untouched — the renderer treats every string as text,
       // never markup.
-      components: m.components
+      components: m.components,
+      // 'friend-request': the accepted request's greeting, merged in by the
+      // host (beagle's friend-greetings.ts); chat.jsx draws its own bubble.
+      kind: m.kind
     };
   }
   var DK_TAIL_MIN = 30;
@@ -574,22 +581,27 @@ window.__DK_UI_VERSION="0.1.126";
     }, [peers, isProtocol, enabled]);
     return fixes;
   }
-  function useDaemonData() {
+  function useDaemonData(opts) {
+    const wantExits = !!(opts && opts.exits);
+    const wantExitsRef = React.useRef(wantExits);
+    wantExitsRef.current = wantExits;
     const [snap, setSnap] = React.useState({
       me: DK_ME_FALLBACK,
       peers: [],
       requests: [],
       exits: [],
       activeExit: null,
+      exitFeature: null,
+      routeFallback: null,
       loaded: false,
       locked: false
     });
     const [threads, setThreads] = React.useState({});
     const refreshRef = React.useRef(null);
     const refresh = React.useCallback(async () => {
-      var _a;
+      var _a, _b, _c;
       try {
-        const d = await dkGet("/api/desktop");
+        const d = await dkGet(wantExitsRef.current ? "/api/desktop?exits=1" : "/api/desktop");
         if (d && d.locked) {
           setSnap((s) => ({ ...s, locked: true, loaded: true }));
           return;
@@ -607,6 +619,8 @@ window.__DK_UI_VERSION="0.1.126";
           requests: d.requests || [],
           exits: d.exits || [],
           activeExit: (_a = d.activeExit) != null ? _a : null,
+          exitFeature: (_b = d.exitFeature) != null ? _b : null,
+          routeFallback: (_c = d.routeFallback) != null ? _c : null,
           loaded: true
         });
       } catch (e) {
@@ -618,6 +632,10 @@ window.__DK_UI_VERSION="0.1.126";
       const t = setInterval(refresh, 2500);
       return () => clearInterval(t);
     }, [refresh]);
+    React.useEffect(() => {
+      if (wantExits)
+        refresh();
+    }, [wantExits, refresh]);
     const inFlight = React.useRef(/* @__PURE__ */ new Set());
     const cache = React.useRef({});
     const [earlier, setEarlier] = React.useState({});
@@ -626,15 +644,23 @@ window.__DK_UI_VERSION="0.1.126";
       if (!c)
         return;
       const arr = [...c.byId.values()].sort((a, b) => a.ts - b.ts);
-      const msgs = arr.map(dkThreadMsg);
-      const withDay = msgs.length ? [{ day: dkDayLabel(arr[0].ts) }].concat(msgs) : [];
+      const withDay = [];
+      let lastDay = null;
+      for (const m of arr) {
+        const day = dkDayLabel(m.ts);
+        if (day !== lastDay) {
+          withDay.push({ day });
+          lastDay = day;
+        }
+        withDay.push(dkThreadMsg(m));
+      }
       setThreads((t) => Object.assign({}, t, { [peerId]: withDay }));
       setEarlier((e) => e[peerId] === c.more ? e : Object.assign({}, e, { [peerId]: c.more }));
     }, []);
-    const loadThread = React.useCallback(async (peerId, opts) => {
+    const loadThread = React.useCallback(async (peerId, opts2) => {
       if (!peerId)
         return;
-      if (opts && opts.reset)
+      if (opts2 && opts2.reset)
         delete cache.current[peerId];
       if (inFlight.current.has(peerId))
         return;
@@ -1728,6 +1754,25 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       return { kind: "punk", id };
     return { kind: "ens" };
   }
+  var REQUEST_TRANSPORTS = ["lan", "carrier", "direct", "relay", "express", "webrtc", "online", "offline", "tcp", "udp", "p2p"];
+  function unquote(s) {
+    const m = /^"([\s\S]*)"$/.exec(s);
+    return m ? m[1] : s;
+  }
+  function requestGreeting(r) {
+    const hello = r && typeof r.hello === "string" ? r.hello.trim() : "";
+    const via = r && typeof r.via === "string" ? r.via.trim() : "";
+    const isTransport = !!via && REQUEST_TRANSPORTS.includes(via.toLowerCase());
+    const isName = !!via && !!r && typeof r.name === "string" && r.name.trim() === via;
+    return {
+      greeting: hello || (via && !isTransport && !isName ? unquote(via).trim() : ""),
+      transport: isTransport ? via : ""
+    };
+  }
+  var GREETING_KIND = "friend-request";
+  function isGreetingItem(m) {
+    return !!m && m.kind === GREETING_KIND;
+  }
   var DK_CMD_HIST_KEY = "beagle.assistant.history";
   var DK_CMD_HIST_MAX = 50;
   function RequestsBlock({ T, requests, onAct }) {
@@ -1779,7 +1824,7 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       overflow: "hidden",
       textOverflow: "ellipsis",
       whiteSpace: "nowrap"
-    } }, r.name) : /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)", fontStyle: "italic" } }, T.noName || "no name given"), /* @__PURE__ */ React.createElement(Mono, { size: 11, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, "via ", r.via, " \xB7 ", r.time))), r.descr && /* @__PURE__ */ React.createElement("div", { style: {
+    } }, r.name) : /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)", fontStyle: "italic" } }, T.noName || "no name given"), /* @__PURE__ */ React.createElement(Mono, { size: 11, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, requestGreeting(r).transport ? "via " + requestGreeting(r).transport + " \xB7 " : "", r.time))), /* @__PURE__ */ React.createElement(DkRequestGreeting, { T, text: requestGreeting(r).greeting }), r.descr && /* @__PURE__ */ React.createElement("div", { style: {
       fontFamily: "var(--ui)",
       fontSize: 12,
       color: "var(--dim, var(--faint))",
@@ -1788,6 +1833,76 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       paddingLeft: 8
     } }, r.descr), failed[r.id] && /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 11, color: "var(--danger)" } }, failed[r.id]), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => act(r, "accept"), style: { flex: 1 } }, T.accept), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "x", size: "sm", onClick: () => act(r, "reject"), style: { flex: 1 } }, T.reject))))));
   }
+  function DkRequestGreeting({ T, text }) {
+    const [open, setOpen] = React.useState(false);
+    const [clipped, setClipped] = React.useState(false);
+    const ref = React.useRef(null);
+    React.useLayoutEffect(() => {
+      const el = ref.current;
+      if (el && !open)
+        setClipped(el.scrollHeight > el.clientHeight + 1);
+    }, [text, open]);
+    if (!text)
+      return null;
+    const toggle = () => {
+      try {
+        const sel = window.getSelection && window.getSelection();
+        if (sel && String(sel).length)
+          return;
+      } catch (e) {
+      }
+      if (clipped || open)
+        setOpen((o) => !o);
+    };
+    return /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        onClick: toggle,
+        title: !open && clipped ? T.showAll || "show all" : void 0,
+        style: { cursor: clipped || open ? "pointer" : "text" }
+      },
+      /* @__PURE__ */ React.createElement("div", { style: { background: "var(--bub-them)", border: "1px solid var(--line)", borderRadius: 8, padding: "6px 9px" } }, /* @__PURE__ */ React.createElement("div", { ref, style: {
+        fontFamily: "var(--ui)",
+        fontSize: 12.5,
+        color: "var(--text)",
+        lineHeight: 1.45,
+        whiteSpace: "pre-wrap",
+        overflowWrap: "anywhere",
+        userSelect: "text",
+        WebkitUserSelect: "text",
+        ...open ? { maxHeight: 240, overflowY: "auto" } : { display: "-webkit-box", WebkitLineClamp: 2, WebkitBoxOrient: "vertical", overflow: "hidden" }
+      } }, text)),
+      (clipped || open) && /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 11, color: "var(--accent)", marginTop: 3 } }, open ? T.showLess || "show less" : T.showAll || "show all")
+    );
+  }
+  function DkGreetingMsg({ m, peer, T }) {
+    return /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: "flex-start", alignItems: "flex-end", gap: 8, margin: "3px 0 10px" } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer, size: 24, radius: 6, dot: false }), /* @__PURE__ */ React.createElement("div", { style: {
+      maxWidth: "75%",
+      padding: "8px 12px",
+      borderRadius: 12,
+      borderBottomLeftRadius: 4,
+      background: "var(--panel-2)",
+      border: "1px dashed var(--accent)",
+      color: "var(--text)"
+    } }, /* @__PURE__ */ React.createElement("div", { style: {
+      display: "flex",
+      alignItems: "center",
+      gap: 6,
+      marginBottom: 4,
+      fontFamily: "var(--mono)",
+      fontSize: 10.5,
+      color: "var(--accent)",
+      fontWeight: 600
+    } }, /* @__PURE__ */ React.createElement(Icon, { name: "userPlus", size: 12, stroke: 2.2, color: "var(--accent)" }), /* @__PURE__ */ React.createElement("span", null, T.friendRequestItem || "Friend request"), /* @__PURE__ */ React.createElement("span", { style: { color: "var(--faint)", fontWeight: 400 } }, "\xB7 ", m.time)), /* @__PURE__ */ React.createElement("div", { style: {
+      fontFamily: "var(--ui)",
+      fontSize: 13.5,
+      lineHeight: 1.5,
+      whiteSpace: "pre-wrap",
+      overflowWrap: "anywhere",
+      userSelect: "text",
+      WebkitUserSelect: "text"
+    } }, m.text)));
+  }
   function DkRequestAvatar({ r, size, radius }) {
     const [urlBroken, setUrlBroken] = React.useState(false);
     const url = requestAvatarUrl(r);
@@ -2562,7 +2677,12 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       return null;
     }), err && /* @__PURE__ */ React.createElement("div", { style: { color: "var(--danger, #ff6b6b)", fontSize: 11.5, fontFamily: "var(--mono)" } }, err));
   }
-  function Msg({ m, peer, T, lang, onTheater, onDelete, onCancel, onRetry, onRetryMsg, onReveal, onOpenFile, onCall, onFormSubmit, onNameCard, onAssistantRemove, onAssistantAdopt, answered, selMode, selected, onToggleSel, busy, isGroup }) {
+  function Msg(props) {
+    if (isGreetingItem(props.m))
+      return /* @__PURE__ */ React.createElement(DkGreetingMsg, { m: props.m, peer: props.peer, T: props.T });
+    return /* @__PURE__ */ React.createElement(DkMsgBody, { ...props });
+  }
+  function DkMsgBody({ m, peer, T, lang, onTheater, onDelete, onCancel, onRetry, onRetryMsg, onReveal, onOpenFile, onCall, onFormSubmit, onNameCard, onAssistantRemove, onAssistantAdopt, answered, selMode, selected, onToggleSel, busy, isGroup }) {
     const mine = m.from === "me";
     const nativeMedia = !m.file ? dkNativeMediaFromText(m.text) : null;
     const grp = isGroup && m.dir !== "out" && !m.file && !nativeMedia ? dkGroupParse(m.text) : null;
@@ -6016,15 +6136,40 @@ ${peer.address}`
       borderBottom: i < peers.length - 1 ? "1px solid var(--line)" : "none"
     } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 10, minWidth: 0 } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer: p, size: 26, radius: 6 }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: p.alias ? "var(--ui)" : "var(--mono)", fontSize: 13, fontWeight: 600, color: "var(--text)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, p.alias || shortKey(p.userId, 8, 5)), p.agent && /* @__PURE__ */ React.createElement(Icon, { name: "bot", size: 12, color: "var(--faint)", stroke: 2 })), /* @__PURE__ */ React.createElement(Mono, { size: 12.5, dim: true, copy: p.ip }, p.ip), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(RouteTag, { peer: p })), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11.5, color: p.wire === "64" ? "var(--warn)" : "var(--dim)" } }, p.wire === "64" ? "old\xB764" : "new\xB7163"), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: "flex-end", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { icon: "message", size: "sm", title: T.openChat, onClick: () => onOpenChat(p.id) }), /* @__PURE__ */ React.createElement(Btn, { icon: "signal", size: "sm", title: T.ping })))));
   }
-  function ExitCard({ T, region, activeExit, onSetExit }) {
+  function ReconnectBtn({ T, ip, onReconnect, label, icon = "refresh" }) {
+    const [busy, setBusy] = React.useState(false);
+    return /* @__PURE__ */ React.createElement(
+      Btn,
+      {
+        size: "sm",
+        icon,
+        disabled: busy,
+        onClick: async () => {
+          if (busy || !onReconnect)
+            return;
+          setBusy(true);
+          try {
+            await onReconnect(ip);
+          } finally {
+            setBusy(false);
+          }
+        }
+      },
+      busy ? T.exitChecking || "checking\u2026" : label || T.exitReconnect || "Reconnect"
+    );
+  }
+  function ExitCard({ T, region, activeExit, onSetExit, onReconnect, featureOn }) {
     return /* @__PURE__ */ React.createElement("div", { style: { borderRadius: 11, border: "1px solid var(--line)", overflow: "hidden", background: "var(--panel)" } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 10, padding: "11px 14px", borderBottom: "1px solid var(--line)", background: "var(--panel-2)" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, fontWeight: 700, letterSpacing: 0.5, padding: "2px 7px", borderRadius: 5, background: "var(--chip)", color: "var(--dim)" } }, region.flag), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--ui)", fontSize: 13.5, fontWeight: 600, color: "var(--text)" } }, region.label), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), (() => {
       const reach = region.nodes.filter((n) => n.reachable).length;
-      const down = region.nodes.length - reach;
-      return /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, color: down > 0 ? "var(--warn)" : "var(--faint)" } }, reach, "/", region.nodes.length, " ", T.up, down > 0 ? ` \xB7 ${down} down` : "");
+      const failed = region.nodes.filter((n) => n.status === "failed").length;
+      const down = region.nodes.length - reach - failed;
+      return /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, color: down + failed > 0 ? "var(--warn)" : "var(--faint)" } }, reach, "/", region.nodes.length, " ", T.up, failed > 0 ? ` \xB7 ${failed} ${T.exitFailed || "failed"}` : "", down > 0 ? ` \xB7 ${down} down` : "");
     })()), /* @__PURE__ */ React.createElement("div", null, region.nodes.map((n, i) => {
       const active = n.ip === activeExit;
       const stuck = n.online && !n.reachable;
-      return /* @__PURE__ */ React.createElement("div", { key: n.ip, className: "dk-wrap", style: { display: "flex", alignItems: "center", gap: 12, rowGap: 6, 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));
+      const failed = n.status === "failed";
+      const usable = n.reachable && featureOn !== false;
+      return /* @__PURE__ */ React.createElement("div", { key: n.ip, className: "dk-wrap", style: { display: "flex", alignItems: "center", gap: 12, rowGap: 6, 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") : failed ? /* @__PURE__ */ React.createElement(Tag, { tone: "danger", title: "Failed 3 checks in a row \u2014 no longer checked automatically" }, T.exitFailed || "failed") : n.status === "unknown" ? /* @__PURE__ */ React.createElement(Tag, { tone: "off" }, T.exitNotChecked || "not checked") : 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") : n.status === "retrying" ? /* @__PURE__ */ React.createElement(Tag, { tone: "warn", title: "No answer \u2014 will try again shortly" }, T.exitRetrying || "retrying", " \xB7 ", n.fails, "/3") : /* @__PURE__ */ React.createElement(Tag, { tone: "off" }, "offline"), failed ? /* @__PURE__ */ React.createElement(ReconnectBtn, { T, ip: n.ip, onReconnect }) : active ? /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => onSetExit(null) }, T.routing) : /* @__PURE__ */ React.createElement(Btn, { size: "sm", icon: "route", disabled: !usable, onClick: () => usable && onSetExit(n.ip), style: { opacity: usable ? 1 : 0.4 } }, T.routeThru));
     })));
   }
   function LanEnableCard({ backend, onArm, onCancel }) {
@@ -6128,12 +6273,14 @@ ${peer.address}`
       "\u53D6\u6D88,\u6062\u590D\u6D88\u606F"
     )));
   }
-  function NetworkTab({ T, me, peers, exits, activeExit, reqCount, onSetExit, onOpenChat, backend, onArmLan, onCancelLan }) {
+  function NetworkTab({ T, me, peers, exits, activeExit, exitFeature, routeFallback, onReconnectExit, reqCount, onSetExit, onOpenChat, backend, onArmLan, onCancelLan }) {
+    const featureOn = !exitFeature || exitFeature.available !== false;
+    const anyFailed = (exits || []).some((r) => (r.nodes || []).some((n) => n.status === "failed"));
     if (backend && backend.switchable && !backend.hasVirtualLan) {
       return /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", background: "var(--bg)" } }, /* @__PURE__ */ React.createElement("div", { className: "dk-page", 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 })));
     }
     const lanless = !!backend && backend.hasVirtualLan === false;
-    return /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", background: "var(--bg)" } }, /* @__PURE__ */ React.createElement("div", { className: "dk-page", 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 }), !peers.length && /* @__PURE__ */ React.createElement("div", { style: { padding: "14px 16px", borderRadius: 11, border: "1px dashed var(--line)", fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)" } }, T.noPeersYet || "No friends yet \u2014 add one from Chat and it shows up here with its route.")), lanless ? null : /* @__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", { className: "dk-grid1", style: { display: "grid", gridTemplateColumns: "1fr 1fr", gap: 12 } }, exits.map((r) => /* @__PURE__ */ React.createElement(ExitCard, { key: r.region, T, region: r, activeExit, onSetExit }))))));
+    return /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", background: "var(--bg)" } }, /* @__PURE__ */ React.createElement("div", { className: "dk-page", 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 }), !peers.length && /* @__PURE__ */ React.createElement("div", { style: { padding: "14px 16px", borderRadius: 11, border: "1px dashed var(--line)", fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)" } }, T.noPeersYet || "No friends yet \u2014 add one from Chat and it shows up here with its route.")), lanless ? null : /* @__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 } }, anyFailed && onReconnectExit && /* @__PURE__ */ React.createElement(ReconnectBtn, { T, ip: null, onReconnect: onReconnectExit, label: T.exitReconnectAll || "Reconnect all" }), /* @__PURE__ */ React.createElement(Btn, { icon: "plus", size: "sm" }, T.addExit)) }), !featureOn && /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 4, padding: "11px 14px", borderRadius: 10, background: "var(--panel-2)", border: "1px dashed var(--line)" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 700, color: "var(--text)" } }, T.noExitAvailable || "No exit available \u2014 routing and proxy are off."), anyFailed && /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--ui)", fontSize: 12, color: "var(--dim)" } }, T.noExitHint || "Every exit failed 3 times and is no longer checked automatically. Press Reconnect to try one again.")), routeFallback && routeFallback.from && /* @__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.routeFellBack || "Routing fell back to direct: every exit it used failed. Reconnect one to route through it again.")), 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", { className: "dk-grid1", style: { display: "grid", gridTemplateColumns: "1fr 1fr", gap: 12 } }, exits.map((r) => /* @__PURE__ */ React.createElement(ExitCard, { key: r.region, T, region: r, activeExit, onSetExit, onReconnect: onReconnectExit, featureOn }))))));
   }
   Object.assign(window, { NetworkTab });
   var dkAudioCtx = null;
@@ -6468,6 +6615,9 @@ ${peer.address}`
       dirSearch: "search name / userid\u2026",
       dirLoading: "loading directory\u2026",
       noName: "no name given",
+      friendRequestItem: "Friend request",
+      showAll: "show all",
+      showLess: "show less",
       dirEmpty: "nobody matches",
       dirError: "Could not load the directory:",
       bridgeEmpty: "Nobody else is listed on this bridge yet. You are the first.",
@@ -6542,6 +6692,15 @@ ${peer.address}`
       routeThru: "route",
       egressVia: "all egress routed via",
       stopRouting: "stop",
+      exitFailed: "failed",
+      exitReconnect: "Reconnect",
+      exitReconnectAll: "Reconnect all",
+      exitChecking: "checking\u2026",
+      exitNotChecked: "not checked",
+      exitRetrying: "retrying",
+      noExitAvailable: "No exit available \u2014 routing and proxy are off.",
+      noExitHint: "Every exit failed 3 times and is no longer checked automatically. Press Reconnect to try one again.",
+      routeFellBack: "Routing fell back to direct: every exit it used failed. Reconnect one to route through it again.",
       identity: "Identity",
       userId: "user id",
       carrierAddr: "carrier address",
@@ -6667,6 +6826,9 @@ ${peer.address}`
       dirSearch: "\u641C\u7D22\u540D\u5B57 / userid\u2026",
       dirLoading: "\u6B63\u5728\u52A0\u8F7D\u540D\u5355\u2026",
       noName: "\u5BF9\u65B9\u6CA1\u6709\u586B\u540D\u5B57",
+      friendRequestItem: "\u597D\u53CB\u8BF7\u6C42",
+      showAll: "\u5C55\u5F00\u5168\u6587",
+      showLess: "\u6536\u8D77",
       dirEmpty: "\u6CA1\u6709\u5339\u914D\u7684\u4EBA",
       dirError: "\u540D\u5355\u52A0\u8F7D\u5931\u8D25\uFF1A",
       bridgeEmpty: "\u8FD9\u4E2A bridge \u4E0A\u8FD8\u6CA1\u6709\u522B\u4EBA\uFF0C\u4F60\u662F\u7B2C\u4E00\u4E2A\u3002",
@@ -6741,6 +6903,15 @@ ${peer.address}`
       routeThru: "\u8DEF\u7531",
       egressVia: "\u5168\u90E8\u51FA\u53E3\u6D41\u91CF\u7ECF\u7531",
       stopRouting: "\u505C\u6B62",
+      exitFailed: "\u5DF2\u5931\u8D25",
+      exitReconnect: "\u91CD\u65B0\u8FDE\u63A5",
+      exitReconnectAll: "\u5168\u90E8\u91CD\u8FDE",
+      exitChecking: "\u68C0\u6D4B\u4E2D\u2026",
+      exitNotChecked: "\u672A\u68C0\u6D4B",
+      exitRetrying: "\u91CD\u8BD5\u4E2D",
+      noExitAvailable: "\u6CA1\u6709\u53EF\u7528\u7684\u51FA\u53E3 \u2014\u2014 \u8DEF\u7531\u548C\u4EE3\u7406\u5DF2\u5173\u95ED\u3002",
+      noExitHint: "\u6240\u6709\u51FA\u53E3\u90FD\u8FDE\u7EED\u5931\u8D25 3 \u6B21,\u5DF2\u4E0D\u518D\u81EA\u52A8\u68C0\u6D4B\u3002\u70B9\u300C\u91CD\u65B0\u8FDE\u63A5\u300D\u518D\u8BD5\u4E00\u6B21\u3002",
+      routeFellBack: "\u8DEF\u7531\u5DF2\u6539\u56DE\u76F4\u8FDE:\u5B83\u4F7F\u7528\u7684\u51FA\u53E3\u5168\u90E8\u5931\u8D25\u3002\u91CD\u65B0\u8FDE\u63A5\u5176\u4E2D\u4E00\u4E2A\u5373\u53EF\u6062\u590D\u3002",
       identity: "\u8EAB\u4EFD",
       userId: "\u7528\u6237 ID",
       carrierAddr: "Carrier \u5730\u5740",
@@ -7035,7 +7206,7 @@ ${peer.address}`
       return hasTab(tabs, want) || DK_PEOPLE_TABS.includes(want) && showPeople ? want : firstTab;
     });
     const [activeId, setActiveId] = React.useState(null);
-    const data = useDaemonData();
+    const data = useDaemonData({ exits: tab === "network" });
     const me = data.me;
     const [upd, setUpd] = React.useState(null);
     React.useEffect(() => {
@@ -7398,6 +7569,10 @@ ${peer.address}`
     const onEdit = (name, description) => dkApi.setProfile(name, description).then(data.refresh);
     const onSetExit = () => {
     };
+    const onReconnectExit = (ip) => (ip ? dkApi.reconnectExit(ip) : dkApi.reconnectAllExits()).then((r) => {
+      data.refresh();
+      return r;
+    });
     const onOpenChat = (id) => {
       setTab("chat");
       openConversation(id);
@@ -7477,7 +7652,7 @@ ${peer.address}`
       fontWeight: 600,
       background: tab === n.id ? "var(--accent)" : "transparent",
       color: tab === n.id ? "#fff" : "var(--dim)"
-    } }, /* @__PURE__ */ React.createElement(Icon, { name: n.icon, size: 14, stroke: 2, color: tab === n.id ? "#fff" : "var(--dim)" }), n.label))), tab === "chat" && /* @__PURE__ */ React.createElement(ChatTab, { T, lang: t.lang, phone, isProtocol, protocolFix, onBack: closeConversation, peers, requests, activeId, thread: activeId === ASSISTANT_ID ? assistant.thread : data.threads[activeId], onSelect, onAct, onAdd, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread: () => activeId && data.loadThread(activeId), hasEarlier: !!(activeId && activeId !== ASSISTANT_ID && data.earlier[activeId]), onAssistantRemove: activeId === ASSISTANT_ID ? assistant.removeFriends : null, onAssistantAdopt: activeId === ASSISTANT_ID ? assistant.adoptServicePeers : null, onLoadEarlier: () => activeId && data.loadEarlier(activeId), prefillAddr: pendingAddr, onPrefillConsumed: () => setPendingAddr(""), muted: mutedIds, onToggleMute }), tab === "here" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "bridge", peers, meId: me.userId, onAdd, onOpenChat }), tab === "recommended" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "recommended", peers, meId: me.userId, onAdd, onOpenChat }), tab === "registered" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "registered", peers, meId: me.userId, onAdd, onOpenChat }), tab === "network" && /* @__PURE__ */ React.createElement(NetworkTab, { T, me, peers, exits, activeExit, reqCount: requests.length, onSetExit, onOpenChat, backend, onArmLan: armLan, onCancelLan: cancelLan }), tab === "apps" && /* @__PURE__ */ React.createElement(AppsTab, { T, t, me, peers, phone, setTab }), tabs.map((x) => x.kind === "host" && tab === x.id ? /* @__PURE__ */ React.createElement(HostTabPane, { key: x.id, tab: x, props: { T, t, me, peers, phone, setTab }, lang: t.lang }) : null), tab === "profile" && /* @__PURE__ */ React.createElement(
+    } }, /* @__PURE__ */ React.createElement(Icon, { name: n.icon, size: 14, stroke: 2, color: tab === n.id ? "#fff" : "var(--dim)" }), n.label))), tab === "chat" && /* @__PURE__ */ React.createElement(ChatTab, { T, lang: t.lang, phone, isProtocol, protocolFix, onBack: closeConversation, peers, requests, activeId, thread: activeId === ASSISTANT_ID ? assistant.thread : data.threads[activeId], onSelect, onAct, onAdd, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread: () => activeId && data.loadThread(activeId), hasEarlier: !!(activeId && activeId !== ASSISTANT_ID && data.earlier[activeId]), onAssistantRemove: activeId === ASSISTANT_ID ? assistant.removeFriends : null, onAssistantAdopt: activeId === ASSISTANT_ID ? assistant.adoptServicePeers : null, onLoadEarlier: () => activeId && data.loadEarlier(activeId), prefillAddr: pendingAddr, onPrefillConsumed: () => setPendingAddr(""), muted: mutedIds, onToggleMute }), tab === "here" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "bridge", peers, meId: me.userId, onAdd, onOpenChat }), tab === "recommended" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "recommended", peers, meId: me.userId, onAdd, onOpenChat }), tab === "registered" && /* @__PURE__ */ React.createElement(DiscoverTab, { T, kind: "registered", peers, meId: me.userId, onAdd, onOpenChat }), tab === "network" && /* @__PURE__ */ React.createElement(NetworkTab, { T, me, peers, exits, activeExit, exitFeature: data.exitFeature, routeFallback: data.routeFallback, onReconnectExit, reqCount: requests.length, onSetExit, onOpenChat, backend, onArmLan: armLan, onCancelLan: cancelLan }), tab === "apps" && /* @__PURE__ */ React.createElement(AppsTab, { T, t, me, peers, phone, setTab }), tabs.map((x) => x.kind === "host" && tab === x.id ? /* @__PURE__ */ React.createElement(HostTabPane, { key: x.id, tab: x, props: { T, t, me, peers, phone, setTab }, lang: t.lang }) : null), tab === "profile" && /* @__PURE__ */ React.createElement(
       ProfileTab,
       {
         T,

package/dist/exit-probe.d.ts

@@ -0,0 +1,81 @@
+export declare const EXIT_PROBE_PORT = 8888;
+export declare const EXIT_PROBE_TIMEOUT_MS = 2000;
+/** Consecutive failed probes after which an exit is `failed`. */
+export declare const EXIT_MAX_FAILS = 3;
+/** Wait after the 1st and 2nd failure before the next automatic try. */
+export declare const EXIT_RETRY_BACKOFF_MS: number[];
+/** How long a successful probe is trusted before the next one. */
+export declare const EXIT_OK_CACHE_MS = 60000;
+export type ExitStatus = "unknown" | "ok" | "retrying" | "failed";
+export interface ExitRecord {
+    /** Consecutive failed probes (reset by a success). */
+    fails: number;
+    failed: boolean;
+    reachable: boolean;
+    ping: number | null;
+    lastProbeAt: number;
+    /** No automatic probe before this time. */
+    nextProbeAt: number;
+}
+export interface ExitView {
+    ip: string;
+    status: ExitStatus;
+    reachable: boolean;
+    ping: number | null;
+    fails: number;
+    checkedAt: number | null;
+}
+/** Routing that was switched to direct because its exits all failed. */
+export interface RouteFallback {
+    from: string;
+    at: number;
+}
+export type ProbeFn = (ip: string) => Promise<{
+    ok: boolean;
+    ping: number | null;
+}>;
+/** One TCP handshake to the exit's CONNECT-proxy port. A completed handshake
+ *  proves the mesh path and the exit process are both live. ECONNREFUSED means
+ *  the host answered (L3 reachable) but nothing listens — still reachable for
+ *  triage; a timeout / no route is the real "can't connect". */
+export declare function tcpProbe(ip: string, port?: number, timeoutMs?: number): Promise<{
+    ok: boolean;
+    ping: number | null;
+}>;
+export declare class ExitProber {
+    #private;
+    constructor(opts?: {
+        path?: string;
+        probe?: ProbeFn;
+        now?: () => number;
+    });
+    view(ip: string): ExitView;
+    isFailed(ip: string): boolean;
+    /** True while at least one of `ips` is not failed — i.e. there is an exit
+     *  the route/proxy feature could still use. None configured = false. */
+    usable(ips: string[]): boolean;
+    /** Is an automatic probe of `ip` due now? Failed exits never are. */
+    due(ip: string): boolean;
+    /** Probe every exit in `ips` that is due (never a failed one, never one
+     *  already being probed). Resolves when those probes are done. */
+    refresh(ips: string[]): Promise<void>;
+    /** The Reconnect button: one probe now, whatever the state. Success makes
+     *  the exit normal again; a failure leaves a failed exit failed. */
+    reconnect(ip: string): Promise<ExitView>;
+    get fallback(): RouteFallback | null;
+    setFallback(f: RouteFallback | null): void;
+}
+/** The exits a routes.yaml `default` sends traffic through: an exit ip names
+ *  itself, a region name names its routes.yaml exits plus the shipped exits of
+ *  that region. "direct" / empty → none. */
+export declare function exitsForTarget(target: string | undefined | null, regions: Array<{
+    name: string;
+    exits?: string[];
+}>, shipped: Array<{
+    virtual_ip?: string;
+    region?: string;
+}>, knownIps: Iterable<string>): string[];
+/** routes.yaml text with its top-level `default:` set to `value`, keeping
+ *  every other line (and comment) as written. Returns null when there is no
+ *  top-level `default:` line to change. */
+export declare function setRoutesDefault(text: string, value: string): string | null;

package/dist/exit-probe.js

@@ -0,0 +1,228 @@
+// Exit reachability, with memory — written from the 2026-11-03 MacBook Air
+// battery drain.
+//
+// The network panel used to TCP-probe every exit's :8888 from scratch on every
+// /api/desktop poll (one every 2.5s per open tab), with no record of what had
+// already failed. On the Air every exit was dead, so the daemon sat in a loop
+// of SYNs to seven hosts that never answered — whether or not routing used an
+// exit and whether or not anyone was looking at the panel.
+//
+// The rules this file holds:
+//   - a probe result is cached (a good one for OK_CACHE_MS, a bad one until
+//     its backoff runs out);
+//   - an exit that fails MAX_FAILS probes in a row is `failed` and is never
+//     probed automatically again — only `reconnect()` (a button press) does;
+//   - the record lives on disk, so a restart does not start the loop over.
+import net from "node:net";
+import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+export const EXIT_PROBE_PORT = 8888;
+export const EXIT_PROBE_TIMEOUT_MS = 2000;
+/** Consecutive failed probes after which an exit is `failed`. */
+export const EXIT_MAX_FAILS = 3;
+/** Wait after the 1st and 2nd failure before the next automatic try. */
+export const EXIT_RETRY_BACKOFF_MS = [30_000, 120_000];
+/** How long a successful probe is trusted before the next one. */
+export const EXIT_OK_CACHE_MS = 60_000;
+/** One TCP handshake to the exit's CONNECT-proxy port. A completed handshake
+ *  proves the mesh path and the exit process are both live. ECONNREFUSED means
+ *  the host answered (L3 reachable) but nothing listens — still reachable for
+ *  triage; a timeout / no route is the real "can't connect". */
+export function tcpProbe(ip, port = EXIT_PROBE_PORT, timeoutMs = EXIT_PROBE_TIMEOUT_MS) {
+    return new Promise((done) => {
+        const t0 = Date.now();
+        let settled = false;
+        let sock;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                sock?.destroy();
+            }
+            catch { /* already gone */ }
+            done({ ok, ping: ok ? Date.now() - t0 : null });
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        try {
+            sock = net.connect({ host: ip, port });
+        }
+        catch {
+            finish(false);
+            return;
+        }
+        sock.once("connect", () => finish(true));
+        sock.once("error", (e) => finish(e.code === "ECONNREFUSED"));
+    });
+}
+export class ExitProber {
+    #path;
+    #probe;
+    #now;
+    #exits = new Map();
+    #fallback = null;
+    #inFlight = new Map();
+    constructor(opts = {}) {
+        this.#path = opts.path;
+        this.#probe = opts.probe ?? ((ip) => tcpProbe(ip));
+        this.#now = opts.now ?? Date.now;
+        this.#load();
+    }
+    #load() {
+        if (!this.#path || !existsSync(this.#path))
+            return;
+        try {
+            const f = JSON.parse(readFileSync(this.#path, "utf-8"));
+            for (const [ip, r] of Object.entries(f?.exits ?? {})) {
+                if (!r || typeof r !== "object")
+                    continue;
+                this.#exits.set(ip, {
+                    fails: Number(r.fails) || 0,
+                    failed: !!r.failed,
+                    reachable: !!r.reachable,
+                    ping: typeof r.ping === "number" ? r.ping : null,
+                    lastProbeAt: Number(r.lastProbeAt) || 0,
+                    nextProbeAt: Number(r.nextProbeAt) || 0,
+                });
+            }
+            this.#fallback = f?.fallback && typeof f.fallback.from === "string" ? f.fallback : null;
+        }
+        catch {
+            // A broken state file costs at most three probes per exit, never the app.
+        }
+    }
+    #save() {
+        if (!this.#path)
+            return;
+        const body = { version: 1, exits: Object.fromEntries(this.#exits), fallback: this.#fallback };
+        try {
+            const tmp = `${this.#path}.tmp`;
+            writeFileSync(tmp, JSON.stringify(body, null, 2) + "\n");
+            renameSync(tmp, this.#path);
+        }
+        catch {
+            // Not persisting only means a restart re-learns; keep serving.
+        }
+    }
+    #record(ip) {
+        let r = this.#exits.get(ip);
+        if (!r) {
+            r = { fails: 0, failed: false, reachable: false, ping: null, lastProbeAt: 0, nextProbeAt: 0 };
+            this.#exits.set(ip, r);
+        }
+        return r;
+    }
+    view(ip) {
+        const r = this.#exits.get(ip);
+        if (!r || !r.lastProbeAt) {
+            return { ip, status: r?.failed ? "failed" : "unknown", reachable: false, ping: null, fails: r?.fails ?? 0, checkedAt: null };
+        }
+        const status = r.failed ? "failed" : r.reachable ? "ok" : r.fails > 0 ? "retrying" : "unknown";
+        return { ip, status, reachable: !r.failed && r.reachable, ping: r.failed ? null : r.ping, fails: r.fails, checkedAt: r.lastProbeAt };
+    }
+    isFailed(ip) {
+        return !!this.#exits.get(ip)?.failed;
+    }
+    /** True while at least one of `ips` is not failed — i.e. there is an exit
+     *  the route/proxy feature could still use. None configured = false. */
+    usable(ips) {
+        return ips.some((ip) => !this.isFailed(ip));
+    }
+    /** Is an automatic probe of `ip` due now? Failed exits never are. */
+    due(ip) {
+        const r = this.#exits.get(ip);
+        if (!r)
+            return true;
+        if (r.failed)
+            return false;
+        return this.#now() >= r.nextProbeAt;
+    }
+    #apply(ip, ok, ping, manual) {
+        const r = this.#record(ip);
+        const now = this.#now();
+        r.lastProbeAt = now;
+        if (ok) {
+            r.fails = 0;
+            r.failed = false;
+            r.reachable = true;
+            r.ping = ping;
+            r.nextProbeAt = now + EXIT_OK_CACHE_MS;
+        }
+        else {
+            r.reachable = false;
+            r.ping = null;
+            if (manual && r.failed) {
+                // A failed Reconnect leaves it failed; it does not start a new cycle.
+            }
+            else {
+                r.fails += 1;
+                if (r.fails >= EXIT_MAX_FAILS)
+                    r.failed = true;
+            }
+            r.nextProbeAt = r.failed ? Number.MAX_SAFE_INTEGER : now + EXIT_RETRY_BACKOFF_MS[Math.min(r.fails - 1, EXIT_RETRY_BACKOFF_MS.length - 1)];
+        }
+        this.#save();
+    }
+    #run(ip, manual) {
+        const running = this.#inFlight.get(ip);
+        if (running)
+            return running;
+        const p = this.#probe(ip)
+            .catch(() => ({ ok: false, ping: null }))
+            .then(({ ok, ping }) => this.#apply(ip, ok, ping, manual))
+            .finally(() => this.#inFlight.delete(ip));
+        this.#inFlight.set(ip, p);
+        return p;
+    }
+    /** Probe every exit in `ips` that is due (never a failed one, never one
+     *  already being probed). Resolves when those probes are done. */
+    async refresh(ips) {
+        const due = [...new Set(ips)].filter((ip) => !this.#inFlight.has(ip) && this.due(ip));
+        await Promise.all(due.map((ip) => this.#run(ip, false)));
+    }
+    /** The Reconnect button: one probe now, whatever the state. Success makes
+     *  the exit normal again; a failure leaves a failed exit failed. */
+    async reconnect(ip) {
+        const running = this.#inFlight.get(ip);
+        if (running)
+            await running;
+        if (!this.view(ip).reachable)
+            await this.#run(ip, true);
+        return this.view(ip);
+    }
+    get fallback() {
+        return this.#fallback;
+    }
+    setFallback(f) {
+        this.#fallback = f;
+        this.#save();
+    }
+}
+/** The exits a routes.yaml `default` sends traffic through: an exit ip names
+ *  itself, a region name names its routes.yaml exits plus the shipped exits of
+ *  that region. "direct" / empty → none. */
+export function exitsForTarget(target, regions, shipped, knownIps) {
+    if (!target || target === "direct")
+        return [];
+    const out = new Set();
+    for (const ip of knownIps)
+        if (ip === target)
+            out.add(ip);
+    for (const r of regions)
+        if (r.name === target)
+            for (const ip of r.exits ?? [])
+                out.add(ip);
+    for (const e of shipped)
+        if (e.region === target && e.virtual_ip)
+            out.add(e.virtual_ip);
+    return [...out];
+}
+/** routes.yaml text with its top-level `default:` set to `value`, keeping
+ *  every other line (and comment) as written. Returns null when there is no
+ *  top-level `default:` line to change. */
+export function setRoutesDefault(text, value) {
+    const re = /^default:[^\n]*$/m;
+    if (!re.test(text))
+        return null;
+    return text.replace(re, `default: ${value}`);
+}

package/dist/friend-greetings.d.ts

@@ -0,0 +1,45 @@
+export declare const GREETING_KIND = "friend-request";
+/** One greeting as stored, per friend. */
+export interface StoredGreeting {
+    text: string;
+    /** When the request arrived (ms). The item is dated here, not at accept. */
+    ts: number;
+}
+/** The shape merged into a /api/chat-history page — a raw store record with
+ *  `kind` so beagle-ui draws the distinct bubble. */
+export interface GreetingItem {
+    id: string;
+    dir: "in";
+    text: string;
+    ts: number;
+    kind: typeof GREETING_KIND;
+}
+/** A request's arrival time in ms. The embedded host stores a number, the lan
+ *  daemon an ISO string. Undefined when neither parses. */
+export declare function arrivalMs(v: unknown): number | undefined;
+export declare class GreetingStore {
+    #private;
+    constructor(path: string);
+    /** Keep the greeting of an accepted request. Skips an empty / whitespace
+     *  greeting, and a repeat request carrying the same text (one item per
+     *  request, not one per click). Returns whether an item was added. */
+    record(peer: string, hello: unknown, arrivedAt: unknown, now?: number): boolean;
+    /** The items for one conversation, oldest first. */
+    items(peer: string): GreetingItem[];
+    /** Forget a friend's greetings (friend removed together with the chat). */
+    remove(peer: string): void;
+}
+/** Merge greeting items into one /api/chat-history page (oldest first).
+ *
+ *  A greeting belongs on a page when it is older than `before` (if given)
+ *  and, when the page is full (`limit` records — there are older ones the
+ *  page left out), no older than the page's oldest record; otherwise it is
+ *  shown when the user loads earlier and reaches it. Already-present ids are
+ *  not added twice. Returns a new array. */
+export declare function mergeGreetings<M extends {
+    ts?: number;
+    id?: string;
+}>(page: readonly M[], greetings: readonly GreetingItem[], opts?: {
+    before?: number;
+    limit?: number;
+}): Array<M | GreetingItem>;

package/dist/friend-greetings.js

@@ -0,0 +1,119 @@
+// The greeting a requester typed into a friend request, kept after accept.
+//
+// Before this, the greeting lived only in the pending list: readable while the
+// request was open (and drawn as "via <greeting>"), gone the moment it was
+// accepted. On accept beagle now writes it into that friend's conversation as
+// an incoming "friend request" item, dated at the request time.
+//
+// Local only — nothing is sent. Stored in beagle's own file, not in
+// messages.json: with the daemon backend that file belongs to the agentnet
+// daemon, which holds it in memory and would overwrite anything we wrote.
+// /api/chat-history merges these items into the page it returns, so the
+// daemon's unread counts and last-message preview never see them (spec:
+// not unread, no notification, not the "last message" over newer ones).
+// See decent-hq docs/tasks/TASK-2026-11-04-friend-request-greeting.md.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+export const GREETING_KIND = "friend-request";
+/** A request's arrival time in ms. The embedded host stores a number, the lan
+ *  daemon an ISO string. Undefined when neither parses. */
+export function arrivalMs(v) {
+    if (typeof v === "number" && Number.isFinite(v) && v > 0)
+        return v;
+    if (typeof v === "string" && v) {
+        const n = Date.parse(v);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return undefined;
+}
+export class GreetingStore {
+    #path;
+    #byPeer = {};
+    constructor(path) {
+        this.#path = path;
+        try {
+            if (existsSync(path)) {
+                const raw = JSON.parse(readFileSync(path, "utf-8"));
+                for (const [peer, list] of Object.entries(raw?.byPeer ?? {})) {
+                    if (!Array.isArray(list))
+                        continue;
+                    const ok = list.filter((g) => !!g && typeof g.text === "string" && typeof g.ts === "number");
+                    if (ok.length)
+                        this.#byPeer[peer] = ok;
+                }
+            }
+        }
+        catch {
+            // A corrupt file loses the greetings, never the chat: start empty.
+            this.#byPeer = {};
+        }
+    }
+    /** Keep the greeting of an accepted request. Skips an empty / whitespace
+     *  greeting, and a repeat request carrying the same text (one item per
+     *  request, not one per click). Returns whether an item was added. */
+    record(peer, hello, arrivedAt, now = Date.now()) {
+        if (!peer || typeof hello !== "string")
+            return false;
+        const text = hello.trim();
+        if (!text)
+            return false;
+        const list = this.#byPeer[peer] ?? [];
+        if (list.some((g) => g.text.trim() === text))
+            return false;
+        list.push({ text, ts: arrivalMs(arrivedAt) ?? now });
+        list.sort((a, b) => a.ts - b.ts);
+        this.#byPeer[peer] = list;
+        this.#save();
+        return true;
+    }
+    /** The items for one conversation, oldest first. */
+    items(peer) {
+        return (this.#byPeer[peer] ?? []).map((g) => ({
+            id: `${GREETING_KIND}:${g.ts}`,
+            dir: "in",
+            text: g.text,
+            ts: g.ts,
+            kind: GREETING_KIND,
+        }));
+    }
+    /** Forget a friend's greetings (friend removed together with the chat). */
+    remove(peer) {
+        if (!this.#byPeer[peer])
+            return;
+        delete this.#byPeer[peer];
+        this.#save();
+    }
+    #save() {
+        try {
+            mkdirSync(dirname(this.#path), { recursive: true });
+            const tmp = `${this.#path}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify({ version: 1, byPeer: this.#byPeer }, null, 2), "utf-8");
+            renameSync(tmp, this.#path);
+        }
+        catch {
+            // Not fatal: the greeting stays for this run and the chat is unaffected.
+        }
+    }
+}
+/** Merge greeting items into one /api/chat-history page (oldest first).
+ *
+ *  A greeting belongs on a page when it is older than `before` (if given)
+ *  and, when the page is full (`limit` records — there are older ones the
+ *  page left out), no older than the page's oldest record; otherwise it is
+ *  shown when the user loads earlier and reaches it. Already-present ids are
+ *  not added twice. Returns a new array. */
+export function mergeGreetings(page, greetings, opts = {}) {
+    if (!greetings.length)
+        return page.slice();
+    const full = opts.limit !== undefined && page.length >= opts.limit;
+    const oldest = page.length ? Math.min(...page.map((m) => (typeof m.ts === "number" ? m.ts : Infinity))) : Infinity;
+    const have = new Set(page.map((m) => m.id).filter(Boolean));
+    const add = greetings.filter((g) => !have.has(g.id) &&
+        (opts.before === undefined || g.ts < opts.before) &&
+        (!full || g.ts >= oldest));
+    if (!add.length)
+        return page.slice();
+    // Stable: a greeting sorts before a message with the same timestamp.
+    return [...add, ...page].sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+}

package/dist/pending-requests.d.ts

@@ -26,3 +26,6 @@ export declare function refreshPendingAvatars<E extends {
  *  the same convention as `peers[]` — and the card then falls back to the
  *  beagles.eth lookup and a generated picture. */
 export declare function desktopRequestRow(p: Record<string, unknown>, i: number, fmtTime: (ts?: number) => string): Record<string, unknown>;
+/** The pending entry the UI's Accept refers to: the card's id is the userid,
+ *  or the address when the request carried no userid. */
+export declare function findPending(pending: ReadonlyArray<Record<string, unknown>>, id: unknown): Record<string, unknown> | undefined;

package/dist/pending-requests.js

@@ -60,10 +60,22 @@ export function desktopRequestRow(p, i, fmtTime) {
         // was nothing to decide on.
         name: p.name || "",
         descr: p.descr || "",
-        via: p.hello || "lan",
+        // The greeting the requester typed. It used to ride in `via`, so the card
+        // drew it as "via <greeting>" — mislabeled, and gone after accept.
+        // beagle-ui >= 0.2.36 reads `hello`; for an older UI, `via` stays the
+        // transport word it always fell back to.
+        hello: typeof p.hello === "string" ? p.hello : "",
+        via: p.via || "lan",
         time: fmtTime(p.arrivedAt),
         // The requester's avatar, drawn before accept: URL first, then punk.
         punkId: a.punkId ?? null,
         avatarUrl: a.avatarUrl ?? null,
     };
 }
+/** The pending entry the UI's Accept refers to: the card's id is the userid,
+ *  or the address when the request carried no userid. */
+export function findPending(pending, id) {
+    if (typeof id !== "string" || !id)
+        return undefined;
+    return pending.find((p) => p.userid === id || p.address === id || p.pubkey === id);
+}

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import { type IpcRequest, type IpcResponse } from "./ipc.js";
+import { type ProbeFn } from "./exit-probe.js";
 /** How this copy of beagle got onto disk — decides what "update" can do.
  *  npx cache paths contain _npx AND node_modules, so test _npx first. */
 export declare function installMode(): "global" | "npx" | "dev" | "unknown";
@@ -32,6 +33,16 @@ export interface BeagleServerOptions {
      *  service peers on top of the list shipped in the app. Written only by the
      *  Assistant's `/nodes refresh`, and only after the user ticks the rows. */
     servicePeersPath?: string;
+    /** <configDir>/friend-greetings.json — the greetings of accepted friend
+     *  requests, shown as the first item of that chat. Beagle's own file (see
+     *  friend-greetings.ts). Undefined = greetings are not kept. */
+    greetingsPath?: string;
+    /** Where the exit probe state (failure counts, failed exits) is kept.
+     *  Default: beagle-exit-state.json next to routes.yaml. */
+    exitStatePath?: string;
+    /** How an exit is probed. Default: a TCP handshake to its :8888. Tests
+     *  inject a counter here. */
+    exitProbe?: ProbeFn;
     /** 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". */

package/dist/server.js

@@ -13,7 +13,6 @@
 // empty because the daemon accepts immediately.
 //
 import http from "node:http";
-import net from "node:net";
 import { existsSync, readFileSync, writeFileSync, statSync, createReadStream, realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
@@ -21,12 +20,14 @@ import { INSTALL_COMMAND as LAN_INSTALL_COMMAND } from "./lan-handoff.js";
 import yaml from "js-yaml";
 import { probeDaemon } from "./ipc.js";
 import { DEFAULT_EXITS } from "./exits.js";
+import { ExitProber, exitsForTarget, setRoutesDefault } from "./exit-probe.js";
 import * as peerAddr from "@decentnetwork/peer";
 import { bridgeRoster } from "./bridge-roster.js";
 import { isSupervised } from "./relaunch.js";
 import { historyStats } from "./assistant-stats.js";
 import { readFriendStore, pickPunk } from "./friend-store.js";
-import { desktopRequestRow } from "./pending-requests.js";
+import { desktopRequestRow, findPending } from "./pending-requests.js";
+import { GreetingStore, mergeGreetings } from "./friend-greetings.js";
 import { createDiscoverFetch } from "./discover-cache.js";
 import { applyWalletBind } from "@decentnetwork/beagle-ui/wallet-proof";
 import { settleUpload } from "./upload-settle.js";
@@ -34,11 +35,22 @@ import { globalPrefixOf } from "./global-prefix.js";
 // Directory holding the built desktop UI bundle (index.html, app.js, vendor/).
 // scripts/build-ui.mjs emits it next to this compiled module at dist/ui/desktop/.
 const DESKTOP_DIR = join(dirname(fileURLToPath(import.meta.url)), "desktop");
-// Exit reachability probe: the CONNECT-proxy port every exit runs, and how long
-// to wait before calling an exit unreachable. Kept short so the network panel
-// (which probes all exits on each poll) stays responsive over a lossy mesh.
-const EXIT_PROBE_PORT = 8888;
-const EXIT_PROBE_TIMEOUT_MS = 2000;
+/** Set routes.yaml's top-level `default:` to `value`, keeping the rest of the
+ *  file as written. False when there is no file or no such line to change. */
+function writeRoutesDefault(path, value) {
+    try {
+        if (!existsSync(path))
+            return false;
+        const next = setRoutesDefault(readFileSync(path, "utf-8"), value);
+        if (next === null)
+            return false;
+        writeFileSync(path, next, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Server-side fetch for the discovery directories (leaderboard / ENS names).
  *  Successes are cached, FAILURES ARE TOO, and concurrent callers share one
  *  request — see discover-cache.ts for the outage this comes from. */
@@ -947,6 +959,13 @@ export function startBeagleServer(opts) {
     const host = opts.listenHost ?? "127.0.0.1";
     const port = opts.listenPort ?? 8765;
     const log = opts.log ?? ((s) => console.log(s));
+    const greetings = opts.greetingsPath ? new GreetingStore(opts.greetingsPath) : null;
+    // Exit reachability with memory (see exit-probe.ts). One per server, state
+    // kept next to routes.yaml so a restart does not re-probe dead exits.
+    const exitProber = new ExitProber({
+        path: opts.exitStatePath ?? join(dirname(opts.routesPath), "beagle-exit-state.json"),
+        probe: opts.exitProbe,
+    });
     const sendJson = (res, code, body) => {
         res.writeHead(code, { "content-type": "application/json" });
         res.end(JSON.stringify(body));
@@ -2238,31 +2257,46 @@ export function startBeagleServer(opts) {
                 // REACHABILITY (data plane): presence "online" only means the peer is
                 // announcing on the DHT — it does NOT mean IP packets get through (a
                 // desynced/NAT-blocked exit shows "online" while `ping 10.86.x` times out,
-                // e.g. GFAX). Actively probe each exit's CONNECT-proxy port over the mesh:
-                // a completed TCP handshake proves the L3 path + the exit process are both
-                // live. Probed in parallel with a short timeout so the panel stays snappy.
+                // e.g. GFAX). The proof is a TCP handshake to the exit's CONNECT-proxy
+                // port — but see exit-probe.ts: probes are cached and backed off, a dead
+                // exit goes `failed` after three tries and is never probed again on its
+                // own, and nothing is probed at all unless the network panel is open
+                // (?exits=1) or routing actually goes through an exit.
                 const allNodes = [...byRegion.values()].flat();
-                await Promise.all(allNodes.map((n) => new Promise((done) => {
-                    const t0 = Date.now();
-                    const sock = net.connect({ host: n.ip, port: EXIT_PROBE_PORT });
-                    let settled = false;
-                    const finish = (ok) => {
-                        if (settled)
-                            return;
-                        settled = true;
-                        clearTimeout(timer);
-                        sock.destroy();
-                        n.reachable = ok;
-                        n.ping = ok ? Date.now() - t0 : null;
-                        done();
-                    };
-                    const timer = setTimeout(() => finish(false), EXIT_PROBE_TIMEOUT_MS);
-                    sock.once("connect", () => finish(true));
-                    // ECONNREFUSED means the host answered (L3 reachable) but the proxy
-                    // isn't listening — still "reachable" for triage; a timeout/no-route is
-                    // the real "can't connect".
-                    sock.once("error", (e) => finish(e.code === "ECONNREFUSED"));
-                })));
+                const allIps = allNodes.map((n) => n.ip);
+                const qs = new URL(req.url || "", "http://localhost").searchParams;
+                const panelOpen = qs.get("exits") === "1";
+                const routeTarget = routes.default && routes.default !== "direct" ? routes.default : null;
+                if (panelOpen || routeTarget)
+                    await exitProber.refresh(allIps);
+                const views = new Map(allIps.map((ip) => [ip, exitProber.view(ip)]));
+                for (const n of allNodes) {
+                    const v = views.get(n.ip);
+                    Object.assign(n, { reachable: v.reachable, ping: v.ping, status: v.status, fails: v.fails, checkedAt: v.checkedAt });
+                }
+                // routes.default on an exit whose every node failed would black-hole
+                // the traffic it sends there: switch the default to direct (and say so)
+                // until a Reconnect brings one of them back.
+                let activeExit = routeTarget;
+                if (routeTarget) {
+                    const targetIps = exitsForTarget(routeTarget, routes.regions ?? [], DEFAULT_EXITS, allIps);
+                    if (targetIps.length && targetIps.every((ip) => exitProber.isFailed(ip))) {
+                        if (writeRoutesDefault(opts.routesPath, "direct")) {
+                            exitProber.setFallback({ from: routeTarget, at: Date.now() });
+                            log(`[exits] every exit of routes.default "${routeTarget}" failed — default set to direct`);
+                            activeExit = null;
+                        }
+                    }
+                }
+                // The user (or a Reconnect) put routing back on an exit: the old
+                // "fell back to direct" notice no longer describes anything.
+                if (activeExit && exitProber.fallback)
+                    exitProber.setFallback(null);
+                const usable = exitProber.usable(allIps);
+                const exitFeature = {
+                    available: usable,
+                    reason: usable ? null : allIps.length ? "No exit available — every exit failed. Reconnect one to use routing." : "No exit available",
+                };
                 const exits = [...byRegion.entries()].map(([region, nodes]) => ({
                     region,
                     flag: regionMeta[region]?.flag ?? region.slice(0, 2).toUpperCase(),
@@ -2270,9 +2304,9 @@ export function startBeagleServer(opts) {
                     nodes,
                     reachableCount: nodes.filter((n) => n.reachable).length,
                     unreachableCount: nodes.filter((n) => !n.reachable).length,
+                    failedCount: nodes.filter((n) => n.status === "failed").length,
                 }));
-                const activeExit = routes.default && routes.default !== "direct" ? routes.default : null;
-                sendJson(res, 200, { me, peers, requests, exits, activeExit });
+                sendJson(res, 200, { me, peers, requests, exits, activeExit, exitFeature, routeFallback: exitProber.fallback });
                 return;
             }
             // The locally adopted service peers: the app ships a list, and this is
@@ -2436,7 +2470,18 @@ export function startBeagleServer(opts) {
                 const bef = Number(q.get("before"));
                 const before = Number.isFinite(bef) && bef > 0 ? bef : undefined;
                 const r = await opts.call({ op: "chat-history", userid: peer, peer, before, limit });
-                sendJson(res, 200, r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
+                const data = (r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
+                // The greeting of the accepted friend request, as the chat's first
+                // item (friend-greetings.ts). Merged here, never written to the
+                // daemon's store, so it is not unread and not the roster preview.
+                if (greetings && peer) {
+                    const items = greetings.items(peer);
+                    if (items.length) {
+                        data.chats = data.chats ?? {};
+                        data.chats[peer] = mergeGreetings(data.chats[peer] ?? [], items, { before, limit });
+                    }
+                }
+                sendJson(res, 200, data);
                 return;
             }
             // Brief 30: submit a rendered form. The values are the user's own input;
@@ -2556,6 +2601,8 @@ export function startBeagleServer(opts) {
             if (req.method === "POST" && url === "/api/friend-remove") {
                 const { userid } = await readBody(req);
                 const r = await opts.call({ op: "friend-remove", userid });
+                if (r.ok)
+                    greetings?.remove(userid);
                 sendJson(res, r.ok ? 200 : 400, r);
                 return;
             }
@@ -2598,6 +2645,42 @@ export function startBeagleServer(opts) {
                 }
                 return;
             }
+            // The network panel's Reconnect: probe a failed exit once, now. Only the
+            // exits this node knows about — the page does not get to make the daemon
+            // dial arbitrary hosts. {all:true} = every failed exit.
+            if (req.method === "POST" && url === "/api/exits/reconnect") {
+                const body = (await readBody(req));
+                let routes = { regions: [], default: "direct" };
+                if (existsSync(opts.routesPath)) {
+                    try {
+                        routes = yaml.load(readFileSync(opts.routesPath, "utf-8")) ?? routes;
+                    }
+                    catch { /* keep direct */ }
+                }
+                const known = new Set(DEFAULT_EXITS.flatMap((e) => (e.virtual_ip ? [e.virtual_ip] : [])));
+                for (const r of routes.regions ?? [])
+                    for (const ip of r.exits ?? [])
+                        known.add(ip);
+                const targets = body.all
+                    ? [...known].filter((ip) => exitProber.isFailed(ip))
+                    : typeof body.ip === "string" && known.has(body.ip) ? [body.ip] : [];
+                if (!body.all && !targets.length)
+                    return sendJson(res, 400, { ok: false, error: "unknown exit" });
+                const results = await Promise.all(targets.map((ip) => exitProber.reconnect(ip)));
+                // Routing that fell back to direct goes back once one of its exits works.
+                const fb = exitProber.fallback;
+                let restored = null;
+                if (fb) {
+                    const fbIps = exitsForTarget(fb.from, routes.regions ?? [], DEFAULT_EXITS, known);
+                    if (fbIps.some((ip) => exitProber.view(ip).reachable)) {
+                        if ((routes.default ?? "direct") === "direct" && writeRoutesDefault(opts.routesPath, fb.from))
+                            restored = fb.from;
+                        exitProber.setFallback(null);
+                    }
+                }
+                sendJson(res, 200, { ok: true, exits: results, restored, available: exitProber.usable([...known]) });
+                return;
+            }
             if (req.method === "GET" && url === "/api/routes") {
                 let routes = { regions: [], default: "direct" };
                 if (existsSync(opts.routesPath)) {
@@ -2637,7 +2720,21 @@ export function startBeagleServer(opts) {
             }
             if (req.method === "POST" && url === "/api/accept") {
                 const { userid } = await readBody(req);
+                // Read the request BEFORE accepting: accept drops it from pending, and
+                // with it the greeting the requester typed.
+                let entry;
+                if (greetings) {
+                    try {
+                        const pend = await opts.call({ op: "friends-pending" });
+                        if (pend.ok)
+                            entry = findPending(pend.data?.pending ?? [], userid);
+                    }
+                    catch { /* no greeting then; the accept still goes through */ }
+                }
                 const r = await opts.call({ op: "friends-accept", userid });
+                if (r.ok && greetings && entry) {
+                    greetings.record(entry.userid || userid, entry.hello, entry.arrivedAt);
+                }
                 sendJson(res, r.ok ? 200 : 400, r);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.126",
+  "version": "0.1.128",
   "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",
@@ -26,7 +26,7 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@decentnetwork/beagle-ui": "^0.2.35",
+    "@decentnetwork/beagle-ui": "^0.2.37",
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.313",
     "@decentnetwork/peer": "^0.1.170",