@decentnetwork/lan 0.1.283 → 0.1.285

package/dist/daemon/friend-meta.d.ts

@@ -14,6 +14,18 @@ export interface FriendMeta {
     pinned?: boolean;
     /** ts of the newest message the user has seen — drives unread counts. */
     lastReadTs?: number;
+    /**
+     * When we first had PROOF this friendship is mutual — something arrived from
+     * them, or a send to them landed. Both need a two-way session, which needs
+     * them to have accepted.
+     *
+     * The SDK clears its own "requested" state on a dhtpk_update, which it reads
+     * as acceptance. It is not: that packet says the peer exists and is
+     * reachable, nothing about a human pressing Accept. Trusting it showed a
+     * peer as online before they had accepted, while every message to them
+     * queued — because there is no session to someone who has not added you.
+     */
+    confirmedAt?: number;
     addedAt: number;
 }
 export declare class FriendMetaStore {
@@ -29,6 +41,9 @@ export declare class FriendMetaStore {
     ensure(userid: string): FriendMeta;
     setAlias(userid: string, alias: string | undefined): void;
     markRead(userid: string, ts?: number): void;
+    /** Record proof the friendship is mutual. Idempotent; first proof wins. */
+    markConfirmed(userid: string, ts?: number): boolean;
+    isConfirmed(userid: string): boolean;
     setPinned(userid: string, pinned: boolean): void;
     remove(userid: string): void;
     private scheduleSave;

package/dist/daemon/friend-meta.js

@@ -59,6 +59,18 @@ export class FriendMetaStore {
             this.scheduleSave();
         }
     }
+    /** Record proof the friendship is mutual. Idempotent; first proof wins. */
+    markConfirmed(userid, ts = Date.now()) {
+        const m = this.ensure(userid);
+        if (m.confirmedAt)
+            return false;
+        m.confirmedAt = ts;
+        this.scheduleSave();
+        return true;
+    }
+    isConfirmed(userid) {
+        return !!this.byUserid.get(userid)?.confirmedAt;
+    }
     setPinned(userid, pinned) {
         const m = this.ensure(userid);
         m.pinned = pinned || undefined;

package/dist/daemon/server.d.ts

@@ -135,6 +135,17 @@ export declare class DaemonServer {
      *  text and queued files, oldest first. Called when a friend reconnects.
      *  Stops early if the link drops again, leaving the remainder queued for the
      *  next reconnect (true store-and-forward). Re-entrancy-guarded per peer. */
+    /**
+     * One-time backfill so upgrading does not re-open settled friendships.
+     *
+     * requestedAt stays on a friend record forever, so the new "unproven"
+     * rule would mark every friend we ever ASKED — i.e. most of them — as
+     * "requested" again until the next message. An inbound message is the same
+     * proof the live rule uses: they could only have sent it over a session that
+     * required them to accept us. So anyone we have already heard from is
+     * confirmed at startup, and only genuinely unaccepted requests stay pending.
+     */
+    private backfillConfirmedFriends;
     private flushOutbox;
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */

package/dist/daemon/server.js

@@ -385,6 +385,7 @@ export class DaemonServer {
             // On-disk chat + friend-metadata stores (survive restarts; back the UI).
             this.messageStore = new MessageStore(resolve(this.configDir, "messages.json"));
             this.friendMeta = new FriendMetaStore(resolve(this.configDir, "friends-meta.json"));
+            this.backfillConfirmedFriends();
             this.outboxDir = resolve(this.configDir, "outbox");
             this.reconcileOutboxOnStart();
             // Start IPC as soon as the peer is up. The CLI uses it to drive
@@ -393,7 +394,11 @@ export class DaemonServer {
             this.ipcEvents.setMaxListeners(50);
             this.ipcServer = new IpcServer(ipcSocketPath(this.config.carrier.dataDir), {
                 friendRequest: async (address, hello) => {
-                    await this.peerManager.sendFriendRequest(address, hello);
+                    // sendFriendRequest waits for our own announce to store and then
+                    // walks the DHT toward the target — tens of seconds is normal, and
+                    // none of it changes what the caller should do. Awaiting it made
+                    // "add" look like a dead button for the whole walk.
+                    void this.peerManager.sendFriendRequest(address, hello).catch((e) => this.logger.warn(`friend-request to ${String(address).slice(0, 8)} failed: ${e.message}`));
                 },
                 friendsPending: async () => {
                     const entries = this.pendingFriends?.list() ?? [];
@@ -412,7 +417,14 @@ export class DaemonServer {
                     const entry = this.pendingFriends?.remove(userid);
                     if (!entry)
                         throw new Error(`No pending friend-request for userid ${userid}`);
-                    await this.peerManager.acceptFriendRequest(entry.pubkey);
+                    // Answer as soon as the entry is gone from pending — that is the part
+                    // the UI renders. The node call is effectively local (its session
+                    // attempt is already fire-and-forget), so waiting on it only delayed
+                    // the click. Put the entry back if it does refuse.
+                    void this.peerManager.acceptFriendRequest(entry.pubkey).catch((e) => {
+                        this.pendingFriends?.add(entry);
+                        this.logger.warn(`accept ${userid.slice(0, 8)} failed: ${e.message}`);
+                    });
                 },
                 friendsReject: async (userid) => {
                     const entry = this.pendingFriends?.remove(userid);
@@ -423,23 +435,38 @@ export class DaemonServer {
                 chatSend: async (userid, text) => {
                     if (!text)
                         return;
-                    // If the friend is online, deliver immediately. If they're offline (or
-                    // the live send throws), queue it: store as "queued" and flush on their
-                    // next reconnect — so chat works store-and-forward, not just live.
-                    if (this.peerManager?.isFriendOnline(userid)) {
+                    // Record the message BEFORE any network attempt, and return without
+                    // waiting for the wire.
+                    //
+                    // The offline branch already did this. The ONLINE branch awaited
+                    // sendText and only logged afterwards — and sendText is not quick:
+                    // with the ack path it retries for up to 15s. So a message to an
+                    // ONLINE friend did not appear in the sender's own thread until
+                    // delivery finished, while a message to an offline one appeared at
+                    // once. The faster the peer, the less you noticed; the slower, the
+                    // more it looked like the app had ignored you.
+                    //
+                    // Same rule the embedded host and the browser client already follow:
+                    // a delivery failure is a STATE on the message, never its absence.
+                    const msg = this.messageStore?.append(userid, "out", text, Date.now(), "queued");
+                    this.friendMeta?.ensure(userid);
+                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    if (!msg || !this.peerManager?.isFriendOnline(userid)) {
+                        this.logger.info(`Queued text for ${userid.slice(0, 8)} (delivers on reconnect)`);
+                        return;
+                    }
+                    // Deliver in the background; the reconnect flush covers a failure.
+                    void (async () => {
                         try {
                             await this.peerManager.sendText(userid, text);
-                            this.logChat(userid, "out", text);
-                            return;
+                            this.friendMeta?.markConfirmed(userid); // it landed: mutual
+                            this.messageStore?.setStatus(userid, msg.id, undefined); // delivered
                         }
                         catch (e) {
-                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, queuing: ${e.message}`);
+                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, stays queued: ${e.message}`);
                         }
-                    }
-                    this.messageStore?.append(userid, "out", text, Date.now(), "queued");
-                    this.friendMeta?.ensure(userid);
-                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                    this.logger.info(`Queued text for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    })();
                 },
                 chatLogLocal: async (userid, dir, text) => {
                     if (!text)
@@ -466,6 +493,11 @@ export class DaemonServer {
                         // The build-default nickname is useless (every node sends it) —
                         // treat it as no-name so the UI falls back to alias/userid.
                         const realName = f.name && f.name !== "@decentnetwork/peer" ? f.name : undefined;
+                        // A peer WE asked stays "requested" until proof arrives, whatever
+                        // the SDK's own status says. Peers we did not ask (inbound
+                        // requests we accepted) have no requestedAt, so they are
+                        // unaffected — as is every friend already confirmed.
+                        const unproven = !!f.requestedAt && !this.friendMeta?.isConfirmed(uid);
                         return {
                             userid: uid,
                             // Full Carrier address (pubkey+nospam+checksum) — the form a NEW
@@ -474,7 +506,7 @@ export class DaemonServer {
                             address: f.address,
                             alias: meta?.alias,
                             name: meta?.alias || realName || uid,
-                            status: f.status,
+                            status: unproven ? "requested" : f.status,
                             lastSeen: f.lastSeen,
                             pinned: meta?.pinned ?? false,
                             lastMessage: lastMsg ? { dir: lastMsg.dir, text: lastMsg.text, ts: lastMsg.ts } : undefined,
@@ -1121,6 +1153,7 @@ export class DaemonServer {
             };
             // Chat: log incoming Carrier text messages (packet 64) for the UI.
             this.peerManager.on("message", (pubkey, text, via) => {
+                this.friendMeta?.markConfirmed(pubkey); // they reached us: mutual
                 this.logChat(pubkey, "in", text, via);
             });
             // Presence: push to IPC subscribers so the TUI/UI reflects online/offline
@@ -1187,6 +1220,7 @@ export class DaemonServer {
                 }
             });
             this.peerManager.on("file-complete", (p) => {
+                this.friendMeta?.markConfirmed(p.friendId);
                 if (p.sending || !p.data) {
                     if (p.sending) {
                         // The receiver has ACKed the whole file — now it's truly delivered.
@@ -1609,6 +1643,32 @@ export class DaemonServer {
      *  text and queued files, oldest first. Called when a friend reconnects.
      *  Stops early if the link drops again, leaving the remainder queued for the
      *  next reconnect (true store-and-forward). Re-entrancy-guarded per peer. */
+    /**
+     * One-time backfill so upgrading does not re-open settled friendships.
+     *
+     * requestedAt stays on a friend record forever, so the new "unproven"
+     * rule would mark every friend we ever ASKED — i.e. most of them — as
+     * "requested" again until the next message. An inbound message is the same
+     * proof the live rule uses: they could only have sent it over a session that
+     * required them to accept us. So anyone we have already heard from is
+     * confirmed at startup, and only genuinely unaccepted requests stay pending.
+     */
+    backfillConfirmedFriends() {
+        if (!this.messageStore || !this.friendMeta)
+            return;
+        let marked = 0;
+        const all = this.messageStore.history();
+        for (const [peer, msgs] of Object.entries(all)) {
+            if (this.friendMeta.isConfirmed(peer))
+                continue;
+            if (msgs.some((m) => m.dir === "in")) {
+                this.friendMeta.markConfirmed(peer);
+                marked++;
+            }
+        }
+        if (marked)
+            this.logger.info(`Confirmed ${marked} existing friend(s) from chat history`);
+    }
     async flushOutbox(userid) {
         if (this.flushingOutbox.has(userid))
             return;

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.283";
+window.__DK_UI_VERSION="0.1.285";
 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.283",
+  "version": "0.1.285",
   "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",