@decentnetwork/lan 0.1.300 → 0.1.302

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

@@ -226,6 +226,21 @@ export declare class PeerManager extends EventEmitter {
      * through PacketSession.
      */
     sendText(pubkey: string, text: string): Promise<void>;
+    /** Send a text to a friend who is NOT connected: the SDK posts it to the
+     *  express store-and-forward relay, and the friend's client collects it on
+     *  its next pull — the same path the browser client and the phones already
+     *  use towards us. Resolves "offline" when it was posted, "acked" when a
+     *  session turned out to be live after all; throws when there is no express
+     *  node to post to.
+     *
+     *  Two shapes, because the SDK has two send paths. A friend known to speak
+     *  the delivery envelope (a JS peer, protoVersion >= 2) is sent through
+     *  sendTextUntilAck with a stable deliveryId and a 250 ms window: one post,
+     *  no retry loop (offline, the ACK cannot come, and the 15 s loop would post
+     *  the same message to the relay three times), and the receiver de-dupes on
+     *  the id if it ever sees it twice. A friend whose client is unknown or
+     *  native gets the plain packet — phones do not read the envelope. */
+    sendTextOffline(pubkey: string, text: string, deliveryId: string): Promise<"offline" | "acked">;
     /**
      * Open an outbound packet session (initiator).
      * Sends HANDSHAKE_REQ and waits for HANDSHAKE_ACK.

package/dist/carrier/peer-manager.js

@@ -493,6 +493,42 @@ export class PeerManager extends EventEmitter {
         }
         await this.peer.sendText(pubkey, text);
     }
+    /** Send a text to a friend who is NOT connected: the SDK posts it to the
+     *  express store-and-forward relay, and the friend's client collects it on
+     *  its next pull — the same path the browser client and the phones already
+     *  use towards us. Resolves "offline" when it was posted, "acked" when a
+     *  session turned out to be live after all; throws when there is no express
+     *  node to post to.
+     *
+     *  Two shapes, because the SDK has two send paths. A friend known to speak
+     *  the delivery envelope (a JS peer, protoVersion >= 2) is sent through
+     *  sendTextUntilAck with a stable deliveryId and a 250 ms window: one post,
+     *  no retry loop (offline, the ACK cannot come, and the 15 s loop would post
+     *  the same message to the relay three times), and the receiver de-dupes on
+     *  the id if it ever sees it twice. A friend whose client is unknown or
+     *  native gets the plain packet — phones do not read the envelope. */
+    async sendTextOffline(pubkey, text, deliveryId) {
+        if (!this.peer) {
+            throw new Error("Peer not created. Call create() first.");
+        }
+        const friend = this.peer.friends().find((f) => f.pubkey === pubkey || f.userid === pubkey);
+        if ((friend?.protoVersion ?? 0) >= 2) {
+            try {
+                await this.peer.sendTextUntilAck(pubkey, text, { deliveryId, timeoutMs: 250, retryIntervalMs: 250 });
+                return "acked";
+            }
+            catch (e) {
+                // The one outcome where nothing was thrown by the send itself: the
+                // packet went out (to express, since there is no live session) and
+                // no ACK arrived in the window — which offline it cannot.
+                if (/ACK timed out/i.test(e.message))
+                    return "offline";
+                throw e;
+            }
+        }
+        const r = await this.peer.sendText(pubkey, text);
+        return r?.delivery === "offline" ? "offline" : "acked";
+    }
     /**
      * Open an outbound packet session (initiator).
      * Sends HANDSHAKE_REQ and waits for HANDSHAKE_ACK.

package/dist/daemon/message-store.d.ts

@@ -66,6 +66,9 @@ export declare class MessageStore {
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
     setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed"): boolean;
+    /** Record how a text message travelled: "online" over a live session,
+     *  "offline" posted to the express relay for the friend to collect. */
+    setVia(peer: string, id: string, via: "online" | "offline"): boolean;
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/daemon/message-store.js

@@ -74,6 +74,17 @@ export class MessageStore {
         this.scheduleSave();
         return true;
     }
+    /** Record how a text message travelled: "online" over a live session,
+     *  "offline" posted to the express relay for the friend to collect. */
+    setVia(peer, id, via) {
+        const arr = this.byPeer.get(peer);
+        const msg = arr?.find((m) => m.id === id);
+        if (!msg || msg.file)
+            return false;
+        msg.via = via;
+        this.scheduleSave();
+        return true;
+    }
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/daemon/server.js

@@ -467,11 +467,42 @@ export class DaemonServer {
                     // sender in ~/.agentnet/messages.json). "queued" now means exactly
                     // one thing: nobody is sending this, the flush must.
                     const online = !!this.peerManager?.isFriendOnline(userid);
-                    const msg = this.messageStore?.append(userid, "out", text, Date.now(), online ? "sending" : "queued");
+                    const msg = this.messageStore?.append(userid, "out", text, Date.now(), "sending");
                     this.friendMeta?.ensure(userid);
                     this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                    if (!msg || !online) {
-                        this.logger.info(`Queued text for ${userid.slice(0, 8)} (delivers on reconnect)`);
+                    if (!msg)
+                        return;
+                    // An OFFLINE friend used to get nothing at all: the message was
+                    // stored "queued" and waited for a live session, which for a friend
+                    // who is rarely connected — a browser tab, a phone in a pocket — can
+                    // be never. Meanwhile their client, on the same SDK, posted ITS
+                    // messages to the express store-and-forward relay and they arrived
+                    // here as offline mail. The asymmetry was observed on 2026-09-12: a
+                    // new web user's friend request and first message came through, the
+                    // reply sat queued, and — because the SDK takes the first offline
+                    // message from a "requested" friend as the proof of acceptance —
+                    // their tab never learned it had been accepted either.
+                    //
+                    // So an offline friend now gets the message posted to express, the
+                    // same way the SDK already does for friend requests. It is marked
+                    // sent · offline, not delivered: nothing confirms it until they
+                    // collect it. A live friend keeps the path below unchanged.
+                    if (!online) {
+                        void (async () => {
+                            try {
+                                const how = await this.peerManager.sendTextOffline(userid, text, `dl-${msg.id}`);
+                                this.messageStore?.setStatus(userid, msg.id, undefined);
+                                this.messageStore?.setVia(userid, msg.id, how === "offline" ? "offline" : "online");
+                                if (how === "acked")
+                                    this.friendMeta?.markConfirmed(userid);
+                                this.logger.info(`Text to ${userid.slice(0, 8)} ${how === "offline" ? "posted to offline mail (friend not connected)" : "delivered"}`);
+                            }
+                            catch (e) {
+                                this.logger.warn(`Offline text to ${userid.slice(0, 8)} failed, queued for reconnect: ${e.message}`);
+                                this.messageStore?.setStatus(userid, msg.id, "queued");
+                            }
+                            this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                        })();
                         return;
                     }
                     // Deliver in the background; on failure hand it to the reconnect flush.
@@ -914,11 +945,17 @@ export class DaemonServer {
                     // (INBOX 2026-08-22 #2). Detect systemd by the env it stamps on
                     // every unit (sudo's env_reset strips these, so an interactive
                     // `sudo agentnet up` still takes the spawn path).
-                    const underSystemd = process.platform === "linux" &&
-                        Boolean(process.env.INVOCATION_ID || process.env.JOURNAL_STREAM);
+                    //
+                    // launchd is the same trap on macOS: the replacement is not
+                    // launchd's job, so the KeepAlive job keeps starting its own copy,
+                    // which refuses the identity every ~10 s, forever (mac-dev
+                    // 2026-09-14, 20934 runs). See supervisor.ts.
+                    const { restartSupervisor } = await import("./supervisor.js");
+                    const supervisor = restartSupervisor();
+                    const underSupervisor = supervisor !== null;
                     setExitReason("selfRestart via IPC");
-                    this.logger.info(underSystemd
-                        ? "Self-restart requested via IPC — running under systemd, will exit non-zero for the supervisor to relaunch"
+                    this.logger.info(underSupervisor
+                        ? `Self-restart requested via IPC — running under ${supervisor}, will exit non-zero for the supervisor to relaunch`
                         : `Self-restart requested via IPC — relaunching ${node} ${argv.join(" ")}`);
                     // Schedule shutdown for after the IPC response goes out. The
                     // 50ms timeout lets the response leave before cleanup closes IPC.
@@ -949,7 +986,7 @@ export class DaemonServer {
                                         child.unref();
                                     }
                                 }
-                                else if (!underSystemd) {
+                                else if (!underSupervisor) {
                                     // sh -c so we can shell-quote argv safely and use sleep.
                                     // Node's detached flag reparents the relauncher to PID 1.
                                     // At this point stop() has released IPC, TUN and the pidfile;
@@ -969,7 +1006,7 @@ export class DaemonServer {
                             // Non-zero under systemd so Restart=on-failure (and =always)
                             // relaunches us; zero elsewhere — the detached child is the
                             // replacement and a supervisor must not also start one.
-                            setTimeout(() => process.exit(underSystemd ? 70 : 0), 200);
+                            setTimeout(() => process.exit(underSupervisor ? 70 : 0), 200);
                         })();
                     }, 50);
                     return { scheduledMs: 1500, argv: [node, ...argv] };

package/dist/daemon/supervisor.d.ts

@@ -0,0 +1,4 @@
+export type RestartSupervisor = "systemd" | "launchd" | null;
+/** The launchd label `agentnet service install` writes. */
+export declare const LAUNCHD_LABEL = "com.decentlan.agentnet";
+export declare function restartSupervisor(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): RestartSupervisor;

package/dist/daemon/supervisor.js

@@ -0,0 +1,25 @@
+// supervisor.ts — who brings this daemon back after it exits?
+//
+// selfRestart re-execs a detached replacement everywhere except under a
+// supervisor. Under systemd that replacement dies with the cgroup (INBOX
+// 2026-08-22 #2). Under launchd it survives but is not launchd's job: it is
+// reparented to pid 1, and the KeepAlive job keeps starting its own copy,
+// which refuses the identity ("Another decentlan daemon is already running")
+// every ~10 s, forever — 20934 runs on mac-dev by 2026-09-14, with
+// /var/log/agentnet.log growing without bound. Under either supervisor the
+// right restart is to exit and let the supervisor start the new code.
+/** The launchd label `agentnet service install` writes. */
+export const LAUNCHD_LABEL = "com.decentlan.agentnet";
+export function restartSupervisor(platform = process.platform, env = process.env) {
+    // systemd stamps these on every unit; sudo's env_reset strips them, so an
+    // interactive `sudo agentnet up` still takes the spawn path.
+    if (platform === "linux" && (env.INVOCATION_ID || env.JOURNAL_STREAM))
+        return "systemd";
+    // launchd sets XPC_SERVICE_NAME to the job's label. A shell has "0" or its
+    // terminal app's name there, so only the installed job matches. A
+    // replacement an older build re-exec'd inherited it too — and exiting is
+    // right for that orphan as well: launchd's job takes the identity back.
+    if (platform === "darwin" && env.XPC_SERVICE_NAME === LAUNCHD_LABEL)
+        return "launchd";
+    return null;
+}

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.300";
+window.__DK_UI_VERSION="0.1.302";
 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.300",
+  "version": "0.1.302",
   "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",