@decentnetwork/lan 0.1.151 → 0.1.154

package/dist/proxy/multi-exit-router.js

@@ -114,6 +114,7 @@ const STALL_MIN_OPEN_MS = 4000; // only a tunnel open at least this long can cou
 const STALL_MIN_BYTES = 16 * 1024; // delivered at least this = a healthy, real segment
 const STALL_DEAD_BYTES = 1024; // relayed LESS than this = the exit is genuinely dead (only THIS counts as a stall); a small-but-real request (playlist/key/keep-alive, 1-16 KB) is NEUTRAL, so it can't flap a healthy exit out of the pool
 const TRIP_AFTER_STALLS = 3; // consecutive DEAD tunnels before an exit is tripped out (hysteresis)
+const TRIP_AFTER_UPSTREAM_FAILS = 5; // consecutive non-200 CONNECT responses (exit's proxy broken, e.g. 502s everything) before tripping
 const TRIP_COOLDOWN_MS = 30_000; // how long a tripped exit stays excluded before it's retried
 // Measures peak short-window throughput of a byte stream. Feed it every chunk
 // length via add(); read peakBps at the end. Peak (not average) shrugs off TCP
@@ -196,6 +197,7 @@ export function startMultiExitRouter(opts) {
         served: 0,
         lastRtt: null,
         lastSuccessMs: null,
+        consecUpstreamFails: 0,
         speedEwma: null,
         bytesDown: 0,
         stalls: 0,
@@ -458,6 +460,7 @@ export function startMultiExitRouter(opts) {
                 // tunnels are flowing.
                 exit.lastSuccessMs = Date.now();
                 exit.fails = 0;
+                exit.consecUpstreamFails = 0;
                 if (!exit.healthy) {
                     exit.healthy = true;
                     log(`✓ ${exit.name} [${exit.region}] UP (live traffic)`);
@@ -527,7 +530,20 @@ export function startMultiExitRouter(opts) {
                 up.on("error", () => client.destroy());
             }
             else {
-                // Exit answered but the ORIGIN errored (502/403/…) — not an exit fault.
+                // Exit answered with a non-200 CONNECT status. Usually the ORIGIN's
+                // fault (a dead host 502s on EVERY exit — tripping would churn the pool),
+                // so we just fail over. BUT if THIS exit returns non-200 for many targets
+                // in a row (reset on any success), its own proxy is broken — e.g. it 502s
+                // everything (dead upstream / wrong version). Trip it so it stops eating
+                // the first pick on every request. A single dead origin can't reach the
+                // threshold: other hosts still succeed on this exit and reset the streak.
+                exit.consecUpstreamFails++;
+                if (exit.consecUpstreamFails >= TRIP_AFTER_UPSTREAM_FAILS && exit.trippedUntil <= Date.now()) {
+                    exit.trippedUntil = Date.now() + TRIP_COOLDOWN_MS;
+                    exit.healthy = false;
+                    log(`✗ ${exit.name} [${exit.region}] TRIPPED for ${TRIP_COOLDOWN_MS / 1000}s (proxy returned ${status.trim()} for ${exit.consecUpstreamFails} targets in a row) — excluding from pool`);
+                    printPool();
+                }
                 fail(`upstream ${status}`, false);
             }
         };

package/dist/types.d.ts

@@ -110,6 +110,10 @@ export interface BootstrapNode {
     port: number;
     pk: string;
     isTcp?: boolean;
+    /** Express relays only: set `false` to reach the relay over plain HTTP
+     *  instead of HTTPS (the payload is already end-to-end encrypted). Lets a
+     *  relay run on a raw IP with no TLS cert / domain / ICP filing. */
+    tls?: boolean;
 }
 export interface CarrierConfig {
     dataDir: string;

package/dist/ui/desktop/app.js

@@ -173,15 +173,24 @@ async function dkGet(path) {
   return r.json();
 }
 async function dkPost(path, body) {
-  const r = await fetch(path, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(body || {})
-  });
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 15e3);
   try {
-    return await r.json();
+    const r = await fetch(path, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body || {}),
+      signal: ctrl.signal
+    });
+    try {
+      return await r.json();
+    } catch (e) {
+      return { ok: r.ok };
+    }
   } catch (e) {
-    return { ok: r.ok };
+    return { ok: false, error: e && e.name === "AbortError" ? "timed out" : e && e.message || "network error" };
+  } finally {
+    clearTimeout(timer);
   }
 }
 function dkCopy(text) {
@@ -1012,6 +1021,9 @@ function PeerSidebar({ T, peers, requests, activeId, onSelect, onAct, onAdd }) {
       } else {
         setAddState({ kind: "err", msg: r && r.error ? `${T.addFailed}: ${r.error}` : T.addFailed });
       }
+    }).catch((e) => {
+      setAddState({ kind: "err", msg: `${T.addFailed}: ${e && e.message || e}` });
+    }).finally(() => {
       setTimeout(() => setAddState((s) => s && s.kind !== "sending" ? null : s), 6e3);
     });
   };

package/dist/ui/server.js

@@ -665,8 +665,27 @@ export function startFriendUi(opts) {
             }
             if (req.method === "POST" && url === "/api/add") {
                 const { address } = await readBody(req);
-                const r = await opts.call({ op: "friend-request", address });
-                sendJson(res, r.ok ? 200 : 400, r);
+                // A friend-request is fire-and-forget: it's delivered when the peer is
+                // online and only becomes a friend once they accept. Don't let the UI
+                // hang on the network round-trip (DHT lookup / unreachable peer) — kick
+                // the send off, but respond within a short window. A fast failure (e.g.
+                // a malformed address) still surfaces its real error; a slow send
+                // returns optimistic success and continues in the background.
+                const sent = opts
+                    .call({ op: "friend-request", address })
+                    .then((r) => ({ done: true, r }))
+                    .catch((e) => ({ done: true, r: { ok: false, error: e instanceof Error ? e.message : String(e) } }));
+                const settled = await Promise.race([
+                    sent,
+                    new Promise((r) => setTimeout(() => r({ done: false }), 2500)),
+                ]);
+                if (settled.done) {
+                    sendJson(res, settled.r.ok ? 200 : 400, settled.r);
+                }
+                else {
+                    void sent.catch(() => { }); // let it finish in the background, no unhandled rejection
+                    sendJson(res, 200, { ok: true, queued: true });
+                }
                 return;
             }
             res.writeHead(404);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.151",
+  "version": "0.1.154",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",