@decentnetwork/lan 0.1.268 → 0.1.269

package/dist/daemon/ipc.d.ts

@@ -100,6 +100,11 @@ export interface IpcHandlers {
      *  without adding an op per feature. Inbound ones arrive as
      *  `{type:"app", userid, packetId, data}` events on `subscribe`. */
     appSend: (userid: string, packetId: number, data: Uint8Array) => Promise<void>;
+    /** Per-registry dora health: asks each configured dora for its roster
+     *  INDIVIDUALLY, so one healthy registry cannot mask three dead ones the way
+     *  the merged resolve path does. Backs external monitoring, which would
+     *  otherwise need its own Carrier peer and a cold session per check. */
+    doraStatus: () => Promise<Record<string, unknown>>;
     /** Long-poll for inbound call-signaling payloads. Resolves with any queued
      *  signals immediately, otherwise holds the connection until one arrives or a
      *  ~20s timeout elapses (then resolves empty). The UI re-polls to get
@@ -127,7 +132,7 @@ export interface IpcHandlers {
     selfRestart: () => Promise<Record<string, unknown>>;
 }
 export interface IpcRequest {
-    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-log-local" | "file-log-local" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "friends-autoaccept" | "set-profile" | "file-send" | "file-delete" | "file-cancel" | "file-retry" | "chat-mark-read" | "subscribe" | "sign" | "call-signal" | "call-poll" | "proxy-reload" | "proxy-access" | "app-send" | "self-restart";
+    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-log-local" | "file-log-local" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "friends-autoaccept" | "set-profile" | "file-send" | "file-delete" | "file-cancel" | "file-retry" | "chat-mark-read" | "subscribe" | "sign" | "call-signal" | "call-poll" | "proxy-reload" | "proxy-access" | "app-send" | "dora-status" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;

package/dist/daemon/ipc.js

@@ -294,6 +294,8 @@ export class IpcServer {
                 await this.handlers.appSend(req.userid, req.packetId, new Uint8Array(bytes));
                 return { sent: bytes.length };
             }
+            case "dora-status":
+                return await this.handlers.doraStatus();
             case "call-poll":
                 return await this.handlers.callPoll();
             case "proxy-reload":

package/dist/daemon/server.js

@@ -703,6 +703,11 @@ export class DaemonServer {
                     // applies to every caller, not just this socket.
                     await this.peerManager.sendAppPacket(userid, packetId, data);
                 },
+                doraStatus: async () => {
+                    if (!this.doraIntegration)
+                        return { checkedAt: new Date().toISOString(), registries: [], note: "dora not enabled on this node" };
+                    return await this.doraIntegration.doraStatus();
+                },
                 callPoll: async () => {
                     // Drain immediately if signals are queued; otherwise hold up to ~20s
                     // for one to arrive (near-instant delivery without a WebSocket). The

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

@@ -114,6 +114,26 @@ export declare class DoraIntegration {
      */
     private tryRegister;
     stop(): void;
+    /**
+     * Per-dora health, by asking each one for its roster.
+     *
+     * This lives in the daemon rather than in a monitoring tool with its own peer
+     * for one reason: reaching a dora needs a warm net_crypto session, and the
+     * daemon already holds one to every configured registry. A separate process
+     * has to build that from scratch on every check, which is slow, adds a second
+     * identity for the same operator, and fails in ways that look exactly like
+     * the outage it is trying to detect.
+     *
+     * Each registry is asked INDIVIDUALLY. The normal list() merges every
+     * registry's answer, which is right for resolving names and useless for
+     * health: one dora answering makes the merged call succeed while three sit
+     * dead — which is precisely how a dora stayed broken for ten days unnoticed.
+     *
+     * Results are cached briefly so a polling dashboard cannot turn into load on
+     * the registries it is watching.
+     */
+    private doraStatusCache?;
+    doraStatus(maxAgeMs?: number): Promise<Record<string, unknown>>;
     getAllocatedIp(): string | undefined;
     private refreshRoster;
     /**

package/dist/dora/dora-integration.js

@@ -384,6 +384,58 @@ export class DoraIntegration {
             this.retryBootstrapTimer = undefined;
         }
     }
+    /**
+     * Per-dora health, by asking each one for its roster.
+     *
+     * This lives in the daemon rather than in a monitoring tool with its own peer
+     * for one reason: reaching a dora needs a warm net_crypto session, and the
+     * daemon already holds one to every configured registry. A separate process
+     * has to build that from scratch on every check, which is slow, adds a second
+     * identity for the same operator, and fails in ways that look exactly like
+     * the outage it is trying to detect.
+     *
+     * Each registry is asked INDIVIDUALLY. The normal list() merges every
+     * registry's answer, which is right for resolving names and useless for
+     * health: one dora answering makes the merged call succeed while three sit
+     * dead — which is precisely how a dora stayed broken for ten days unnoticed.
+     *
+     * Results are cached briefly so a polling dashboard cannot turn into load on
+     * the registries it is watching.
+     */
+    doraStatusCache;
+    async doraStatus(maxAgeMs = 20_000) {
+        const cached = this.doraStatusCache;
+        if (cached && Date.now() - cached.at < maxAgeMs)
+            return cached.value;
+        const userids = this.opts.config.userids ?? [];
+        const checks = await Promise.all(userids.map(async (id) => {
+            const started = Date.now();
+            try {
+                // One client per registry: this is the whole point — a merged call
+                // would hide exactly the failure we are looking for.
+                const one = new DoraClient({
+                    registryUserids: [id],
+                    sendText: (to, text) => this.opts.peerManager.sendText(to, text),
+                    onText: (h) => this.opts.peerManager.on("message", (pubkey, text) => h(pubkey, text)),
+                    timeoutMs: 8000,
+                });
+                const roster = await one.list();
+                return { userid: id, ok: Array.isArray(roster) && roster.length > 0,
+                    entries: Array.isArray(roster) ? roster.length : 0,
+                    ms: Date.now() - started,
+                    ...(Array.isArray(roster) && roster.length === 0
+                        ? { error: "roster empty — answering but holding no records" }
+                        : {}) };
+            }
+            catch (err) {
+                return { userid: id, ok: false, entries: 0, ms: Date.now() - started,
+                    error: err instanceof Error ? err.message : String(err) };
+            }
+        }));
+        const value = { checkedAt: new Date().toISOString(), registries: checks };
+        this.doraStatusCache = { at: Date.now(), value };
+        return value;
+    }
     getAllocatedIp() {
         return this.allocatedIp;
     }

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.268";
+window.__DK_UI_VERSION="0.1.269";
 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.268",
+  "version": "0.1.269",
   "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",