@decentnetwork/lan 0.1.285 → 0.1.287

package/dist/carrier/offline-call.js

@@ -6,10 +6,16 @@ export const DEFAULT_OFFLINE_CONFIG = {
     appName: "Beagle",
     socketUrl: "https://io.beagle.chat",
     socketUrls: ["https://io.beagle.chat"],
+    // Measured 2026-08-28: pushapi.beagle.chat returns 502 on every path (its
+    // vhost is down), www.callpass.cn is unreachable, and tokyo.fi.chat:3004 is
+    // the WRONG PORT — that service listens on 443. All three dead at once, so
+    // an offline call could not wake a phone, while the phone apps kept working
+    // because bgservers.json points them at tokyo.fi.chat on 443.
+    // Verified: POST https://tokyo.fi.chat/push-api/push-message with this
+    // client's exact query-string shape returns 200.
     pushEndpoints: [
-        "https://pushapi.beagle.chat/push-api/push-message",
-        "https://www.callpass.cn/push-api/push-message",
-        "https://tokyo.fi.chat:3004/push-api/push-message"
+        "https://tokyo.fi.chat/push-api/push-message",
+        "https://pushapi.beagle.chat/push-api/push-message"
     ]
 };
 /**

package/dist/carrier/peer-manager.d.ts

@@ -60,6 +60,18 @@ export declare class PeerManager extends EventEmitter {
      * pubkey is a no-op at the SDK level.
      */
     acceptFriendRequest(pubkey: string): Promise<void>;
+    /**
+     * Decline an inbound request, at the SDK level and not only in our own
+     * pending list.
+     *
+     * Rejecting used to be described as "a no-op at the Carrier level — sender
+     * just sees no acceptance". It is not: the request leaves a friend record in
+     * the SDK, and the SDK treats a later request from someone already in that
+     * list as a reconnection signal and never surfaces it. So rejecting a person
+     * once meant they could never reach you again, with nothing on either side
+     * saying why.
+     */
+    rejectFriendRequest(pubkey: string): void;
     /**
      * Remove a friend (by userid/pubkey). Drops them from the Carrier friend
      * store (and persists the shrunk list). Returns true if a friend was

package/dist/carrier/peer-manager.js

@@ -125,6 +125,23 @@ export class PeerManager extends EventEmitter {
         await this.peer.acceptFriendRequest(pubkey);
         this.logger.info(`Accepted friend request from ${pubkey}`);
     }
+    /**
+     * Decline an inbound request, at the SDK level and not only in our own
+     * pending list.
+     *
+     * Rejecting used to be described as "a no-op at the Carrier level — sender
+     * just sees no acceptance". It is not: the request leaves a friend record in
+     * the SDK, and the SDK treats a later request from someone already in that
+     * list as a reconnection signal and never surfaces it. So rejecting a person
+     * once meant they could never reach you again, with nothing on either side
+     * saying why.
+     */
+    rejectFriendRequest(pubkey) {
+        if (!this.peer)
+            return;
+        this.peer.rejectFriendRequest(pubkey);
+        this.logger.info(`Rejected friend request from ${pubkey}`);
+    }
     /**
      * Remove a friend (by userid/pubkey). Drops them from the Carrier friend
      * store (and persists the shrunk list). Returns true if a friend was

package/dist/daemon/server.js

@@ -430,7 +430,17 @@ export class DaemonServer {
                     const entry = this.pendingFriends?.remove(userid);
                     if (!entry)
                         throw new Error(`No pending friend-request for userid ${userid}`);
-                    // No-op at the Carrier level — sender just sees no acceptance.
+                    // Tell the SDK as well. This used to be left as "a no-op at the
+                    // Carrier level — sender just sees no acceptance", which was wrong:
+                    // the request leaves a friend record behind, and a later request
+                    // from anyone already in that list is swallowed as a reconnection
+                    // signal. Reject someone once and they could never reach you again.
+                    try {
+                        this.peerManager?.rejectFriendRequest(entry.pubkey);
+                    }
+                    catch (e) {
+                        this.logger.warn(`reject cleanup for ${userid.slice(0, 8)} failed: ${e.message}`);
+                    }
                 },
                 chatSend: async (userid, text) => {
                     if (!text)

package/dist/dora/dora-integration.d.ts

@@ -141,8 +141,15 @@ export declare class DoraIntegration {
      * ipam.yaml — that file remains operator-managed. Dora is treated as
      * a live overlay that's refreshed on every restart.
      *
-     * Conflict policy: dora wins. If ipam.yaml had a peer with a stale IP,
-     * the dora record overwrites it (assignPeer dedupes by name + carrierId).
+     * Conflict policy: dora wins over ipam.yaml, but NOT over an address a real
+     * packet just proved. A peer that re-allocates shows up on the wire before
+     * dora's roster catches up, and letting the roster win there made the two
+     * writers fight: the router learned the live address from inbound traffic,
+     * the next refresh put the stale one back, and the mapping oscillated. From
+     * the outside that is a ping at ~60% loss — a few replies, then a run of
+     * timeouts, then replies again. Measured between mac-dev and air-wli
+     * 2026-08-30, with the flip visible in the log as alternating
+     * "IPAM updated from inbound" and "Assigned peer" lines for one peer.
      */
     private mergeRosterIntoIpam;
     /**

package/dist/dora/dora-integration.js

@@ -14,6 +14,10 @@
 import { DoraClient, AllRegistriesUnavailableError } from "@decentnetwork/dora";
 import { DEFAULT_DORAS } from "../config/loader.js";
 import { Logger } from "../utils/logger.js";
+/** How long an address confirmed by an inbound packet outranks the dora
+ *  roster. Long enough to cover a roster that lags a re-allocation, short
+ *  enough that a peer which genuinely moved is picked up from dora again. */
+const LEARNED_IP_TRUST_MS = 10 * 60_000;
 export class DoraIntegration {
     opts;
     client;
@@ -458,8 +462,15 @@ export class DoraIntegration {
      * ipam.yaml — that file remains operator-managed. Dora is treated as
      * a live overlay that's refreshed on every restart.
      *
-     * Conflict policy: dora wins. If ipam.yaml had a peer with a stale IP,
-     * the dora record overwrites it (assignPeer dedupes by name + carrierId).
+     * Conflict policy: dora wins over ipam.yaml, but NOT over an address a real
+     * packet just proved. A peer that re-allocates shows up on the wire before
+     * dora's roster catches up, and letting the roster win there made the two
+     * writers fight: the router learned the live address from inbound traffic,
+     * the next refresh put the stale one back, and the mapping oscillated. From
+     * the outside that is a ping at ~60% loss — a few replies, then a run of
+     * timeouts, then replies again. Measured between mac-dev and air-wli
+     * 2026-08-30, with the flip visible in the log as alternating
+     * "IPAM updated from inbound" and "Assigned peer" lines for one peer.
      */
     mergeRosterIntoIpam(roster, myUserid) {
         let added = 0;
@@ -471,6 +482,17 @@ export class DoraIntegration {
             if (!existing) {
                 added += 1;
             }
+            else if (existing.virtualIp !== entry.virtualIp &&
+                existing.learnedAt !== undefined &&
+                Date.now() - existing.learnedAt < LEARNED_IP_TRUST_MS) {
+                // Traffic from this peer confirmed a different address, recently.
+                // Believe the wire and leave the entry alone; the roster will agree
+                // once dora catches up with the re-allocation.
+                this.logger.info(`roster says ${entry.name} is ${entry.virtualIp}, but traffic proved ` +
+                    `${existing.virtualIp} — keeping the learned address`);
+                this.maybeFriend(entry);
+                continue;
+            }
             else if (existing.virtualIp !== entry.virtualIp ||
                 existing.name !== entry.name) {
                 updated += 1;

package/dist/router/packet-router.js

@@ -244,6 +244,9 @@ export class PacketRouter extends EventEmitter {
             carrierId: srcPubkey,
             virtualIp: srcIp,
             services: existing?.services ?? [],
+            // Stamped so a stale dora roster cannot overwrite what a real packet
+            // just proved. See IpamRecord.learnedAt.
+            learnedAt: Date.now(),
         });
         this.logger.info(existing
             ? `IPAM updated from inbound: ${name} ${existing.virtualIp} -> ${srcIp}`

package/dist/types.d.ts

@@ -42,6 +42,14 @@ export interface IpamRecord {
     virtualIp: string;
     services: Service[];
     expiresAt?: number;
+    /** When this address was last confirmed by an inbound packet FROM this peer.
+     *
+     *  A packet is proof of the address a peer is using right now; the dora
+     *  roster is a cache that can lag a re-allocation. Without this the roster
+     *  overwrote the learned address on every refresh and the router flipped
+     *  between the two — visible as ~60% packet loss on a ping that otherwise
+     *  worked. */
+    learnedAt?: number;
 }
 export interface IpamConfig {
     namespace: string;

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.285";
+window.__DK_UI_VERSION="0.1.287";
 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"/>',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.285",
+  "version": "0.1.287",
   "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",
@@ -84,7 +84,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.14",
-    "@decentnetwork/peer": "^0.1.141",
+    "@decentnetwork/peer": "0.1.154",
     "@decentnetwork/peer-webrtc": "^0.2.10",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",