@decentnetwork/lan 0.1.77 → 0.1.78

package/dist/carrier/packet-session.d.ts

@@ -6,13 +6,15 @@ import type { PacketFrame } from "./types.js";
 export interface PacketSessionOptions {
     peerId: string;
     sessionId: number;
-    sendText: (text: string) => Promise<void>;
+    /** Send a raw decentlan frame over the given Carrier custom packet id
+     *  (PACKET_ID_DL_SESSION for handshake, PACKET_ID_DL_IP for data). */
+    sendFrame: (frame: Uint8Array, packetId: number) => Promise<void>;
     onClose?: () => void;
 }
 export declare class PacketSession extends EventEmitter {
     private peerId;
     private sessionId;
-    private sendText;
+    private sendFrame;
     private isActive;
     private handshakeTimeout;
     private handshakePromise;

package/dist/carrier/packet-session.js

@@ -3,11 +3,11 @@
  */
 import { EventEmitter } from "events";
 import { FrameCodec } from "./frame.js";
-import { FRAME_OPCODE_HANDSHAKE_REQ, FRAME_OPCODE_DATA, } from "./types.js";
+import { FRAME_OPCODE_HANDSHAKE_REQ, FRAME_OPCODE_DATA, PACKET_ID_DL_SESSION, PACKET_ID_DL_IP, } from "./types.js";
 export class PacketSession extends EventEmitter {
     peerId;
     sessionId;
-    sendText;
+    sendFrame;
     isActive = false;
     handshakeTimeout = null;
     handshakePromise = null;
@@ -15,7 +15,7 @@ export class PacketSession extends EventEmitter {
         super();
         this.peerId = opts.peerId;
         this.sessionId = opts.sessionId;
-        this.sendText = opts.sendText;
+        this.sendFrame = opts.sendFrame;
         this.on("close", () => {
             if (opts.onClose) {
                 opts.onClose();
@@ -38,9 +38,8 @@ export class PacketSession extends EventEmitter {
             return this.handshakePromise;
         }
         this.handshakePromise = new Promise((resolve, reject) => {
-            // Send handshake request
+            // Send handshake request (lossless session channel — must arrive)
             const frame = FrameCodec.encode(new Uint8Array(0), this.sessionId, FRAME_OPCODE_HANDSHAKE_REQ);
-            const frameBase64 = Buffer.from(frame).toString("base64");
             // 30s default — Carrier express relay can add several seconds of latency
             // for cross-region peers. Configurable via AGENTNET_HANDSHAKE_TIMEOUT_MS.
             const timeoutMs = parseInt(process.env.AGENTNET_HANDSHAKE_TIMEOUT_MS || "30000", 10);
@@ -67,7 +66,7 @@ export class PacketSession extends EventEmitter {
                 this.handshakePromise = null;
                 reject(new Error(`Handshake aborted for peer ${this.peerId}`));
             });
-            this.sendText(frameBase64).catch((error) => {
+            this.sendFrame(frame, PACKET_ID_DL_SESSION).catch((error) => {
                 if (this.handshakeTimeout) {
                     clearTimeout(this.handshakeTimeout);
                 }
@@ -82,9 +81,10 @@ export class PacketSession extends EventEmitter {
             throw new Error("Packet session not active. Call handshake() first.");
         }
         const frame = FrameCodec.encode(packet, this.sessionId, FRAME_OPCODE_DATA);
-        const frameBase64 = Buffer.from(frame).toString("base64");
         try {
-            await this.sendText(frameBase64);
+            // IP data → lossy custom packet (best-effort; inner TCP handles
+            // reliability — see docs/PROTOCOL.md, avoids TCP-over-TCP).
+            await this.sendFrame(frame, PACKET_ID_DL_IP);
         }
         catch (error) {
             // Don't tear down the whole session for a single failed sendText —

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

@@ -152,5 +152,16 @@ export declare class PeerManager extends EventEmitter {
      * Send a HANDSHAKE_ACK frame to a peer.
      */
     private sendHandshakeAck;
+    /**
+     * Send a dora control message to a dora server over the dora custom packet
+     * (162, lossless). Replaces the old `DORA:`-prefixed text on packet 64.
+     */
+    sendDora(userid: string, text: string): Promise<void>;
+    /**
+     * Route a decoded decentlan frame to its packet-session, creating or
+     * replacing the session on a HANDSHAKE_REQ (handles the Carrier re-pair
+     * case where both sides hold different sessionIds).
+     */
+    private handleDecodedFrame;
     private setupEventHandlers;
 }

package/dist/carrier/peer-manager.js

@@ -6,13 +6,8 @@ import { Peer } from "@decentnetwork/peer";
 import { EventEmitter } from "events";
 import { PacketSession } from "./packet-session.js";
 import { FrameCodec } from "./frame.js";
-import { FRAME_OPCODE_HANDSHAKE_ACK, } from "./types.js";
+import { FRAME_OPCODE_HANDSHAKE_ACK, PACKET_ID_DL_SESSION, PACKET_ID_DL_DORA, PACKET_ID_DL_IP, } from "./types.js";
 import { Logger } from "../utils/logger.js";
-// Dora wire-prefix. Kept inline (rather than imported from @decentnetwork/dora) to
-// avoid coupling peer-manager — a transport-layer module — to an
-// application-protocol package. The prefix is part of decentlan's text
-// channel contract and must match the constant defined in dora's types.ts.
-const DORA_PREFIX = "DORA:";
 export class PeerManager extends EventEmitter {
     peer = null;
     identity = null;
@@ -331,11 +326,11 @@ export class PeerManager extends EventEmitter {
         const session = new PacketSession({
             peerId: pubkey,
             sessionId,
-            sendText: async (text) => {
+            sendFrame: async (frame, packetId) => {
                 if (!this.peer) {
                     throw new Error("Peer not available");
                 }
-                await this.peer.sendText(pubkey, text);
+                await this.peer.sendCustomPacket(pubkey, packetId, frame);
             },
             onClose: () => {
                 this.sessions.delete(pubkey);
@@ -364,8 +359,42 @@ export class PeerManager extends EventEmitter {
             throw new Error("Peer not available");
         }
         const frame = FrameCodec.encode(new Uint8Array(0), sessionId, FRAME_OPCODE_HANDSHAKE_ACK);
-        const frameBase64 = Buffer.from(frame).toString("base64");
-        await this.peer.sendText(pubkey, frameBase64);
+        await this.peer.sendCustomPacket(pubkey, PACKET_ID_DL_SESSION, frame);
+    }
+    /**
+     * Send a dora control message to a dora server over the dora custom packet
+     * (162, lossless). Replaces the old `DORA:`-prefixed text on packet 64.
+     */
+    async sendDora(userid, text) {
+        if (!this.peer) {
+            throw new Error("Peer not created. Call create() first.");
+        }
+        await this.peer.sendCustomPacket(userid, PACKET_ID_DL_DORA, Buffer.from(text, "utf-8"));
+    }
+    /**
+     * Route a decoded decentlan frame to its packet-session, creating or
+     * replacing the session on a HANDSHAKE_REQ (handles the Carrier re-pair
+     * case where both sides hold different sessionIds).
+     */
+    handleDecodedFrame(pubkey, frame) {
+        let session = this.sessions.get(pubkey);
+        if (FrameCodec.isHandshakeRequest(frame.opcode)) {
+            if (session && session.getSessionId() !== frame.sessionId) {
+                this.logger.info(`Replacing stale session for ${pubkey} (old=${session.getSessionId()}, new=${frame.sessionId})`);
+                session.close();
+                session = undefined;
+            }
+            if (!session) {
+                this.logger.info(`Auto-creating session for inbound peer ${pubkey} (sessionId=${frame.sessionId})`);
+                session = this.createSession(pubkey, frame.sessionId);
+            }
+        }
+        if (session) {
+            session.handleIncomingFrame(frame);
+        }
+        else {
+            this.logger.debug(`No session for peer ${pubkey}, ignoring frame opcode=0x${frame.opcode.toString(16)}`);
+        }
     }
     setupEventHandlers() {
         if (!this.peer) {
@@ -406,54 +435,37 @@ export class PeerManager extends EventEmitter {
                 }
             }
         });
-        // Text messages contain our framed packets
+        // Packet 64 (PACKET_ID_MESSAGE) is now CHAT only — plain Carrier text,
+        // interoperable with native Carrier clients. IP traffic and dora moved to
+        // their own custom packets (onCustomPacket below). See docs/PROTOCOL.md.
         this.peer.onText((message) => {
+            // Empty messages are kickSessionEstablishment keepalives — ignore.
+            if (message.text.length === 0) {
+                return;
+            }
+            this.emit("message", message.pubkey, message.text);
+        });
+        // decentlan custom packets: IP data (192, lossy), session handshake
+        // (161, lossless), dora control (162, lossless). Each on its own Carrier
+        // packet id — a chat message can never be mistaken for an IP packet, and
+        // no crafted message can inject onto the TUN.
+        this.peer.onCustomPacket(({ pubkey, id, data }) => {
             try {
-                // Silently skip empty messages — kickSessionEstablishment sends
-                // an empty sendText to trigger the SDK's #initiateSession path,
-                // and the receiver doesn't need to log a warning for that.
-                if (message.text.length === 0) {
-                    return;
-                }
-                // Dora messages share the same text channel as packet frames but
-                // carry a `DORA:` ASCII prefix that's not valid base64. Route them
-                // to whoever is subscribed (DoraClient/DoraServer in daemon).
-                if (message.text.startsWith(DORA_PREFIX)) {
-                    this.emit("dora-message", message.pubkey, message.text);
-                    return;
-                }
-                const frameData = Buffer.from(message.text, "base64");
-                const frame = FrameCodec.decode(new Uint8Array(frameData));
-                if (!frame) {
-                    this.logger.warn(`Invalid frame from ${message.pubkey}`);
+                if (id === PACKET_ID_DL_DORA) {
+                    this.emit("dora-message", pubkey, Buffer.from(data).toString("utf-8"));
                     return;
                 }
-                let session = this.sessions.get(message.pubkey);
-                // For HANDSHAKE_REQ: always create or REPLACE the session with the
-                // new sessionId. Without this, after a Carrier session drop + re-pair
-                // the peer's new HANDSHAKE_REQ would be dropped because the existing
-                // local session has the old sessionId — so the responder never sends
-                // HANDSHAKE_ACK and the initiator times out forever.
-                if (FrameCodec.isHandshakeRequest(frame.opcode)) {
-                    if (session && session.getSessionId() !== frame.sessionId) {
-                        this.logger.info(`Replacing stale session for ${message.pubkey} (old=${session.getSessionId()}, new=${frame.sessionId})`);
-                        session.close();
-                        session = undefined;
+                if (id === PACKET_ID_DL_IP || id === PACKET_ID_DL_SESSION) {
+                    const frame = FrameCodec.decode(data);
+                    if (!frame) {
+                        this.logger.warn(`Invalid frame from ${pubkey} (packet ${id})`);
+                        return;
                     }
-                    if (!session) {
-                        this.logger.info(`Auto-creating session for inbound peer ${message.pubkey} (sessionId=${frame.sessionId})`);
-                        session = this.createSession(message.pubkey, frame.sessionId);
-                    }
-                }
-                if (session) {
-                    session.handleIncomingFrame(frame);
-                }
-                else {
-                    this.logger.debug(`No session for peer ${message.pubkey}, ignoring frame opcode=0x${frame.opcode.toString(16)}`);
+                    this.handleDecodedFrame(pubkey, frame);
                 }
             }
             catch (error) {
-                this.logger.error(`Error processing frame from ${message.pubkey}:`, error);
+                this.logger.error(`Error processing custom packet from ${pubkey}:`, error);
             }
         });
         // Friend requests

package/dist/carrier/types.d.ts

@@ -8,3 +8,6 @@ export declare const FRAME_OPCODE_HANDSHAKE_ACK = 2;
 export declare const FRAME_OPCODE_DATA = 16;
 export declare const FRAME_MAGIC = 170;
 export declare const FRAME_HEADER_SIZE = 6;
+export declare const PACKET_ID_DL_SESSION = 161;
+export declare const PACKET_ID_DL_DORA = 162;
+export declare const PACKET_ID_DL_IP = 192;

package/dist/carrier/types.js

@@ -9,3 +9,10 @@ export const FRAME_OPCODE_DATA = 0x10;
 // Frame structure
 export const FRAME_MAGIC = 0xaa;
 export const FRAME_HEADER_SIZE = 6; // magic(1) + length(2) + sessionId(2) + opcode(1)
+// decentlan application packet IDs in toxcore's custom ranges (see
+// docs/PROTOCOL.md). Sent via peer.sendCustomPacket / received via
+// peer.onCustomPacket — a separate channel from chat (PACKET_ID_MESSAGE 64),
+// so IP traffic can never be confused with a Carrier message.
+export const PACKET_ID_DL_SESSION = 161; // lossless: session handshake frames (must arrive)
+export const PACKET_ID_DL_DORA = 162; // lossless: dora control (must arrive)
+export const PACKET_ID_DL_IP = 192; // lossy: IP data frames (best-effort; inner TCP retransmits)

package/dist/cli/commands.d.ts

@@ -214,6 +214,30 @@ export declare function cmdProxyUse(args: {
     peer: string;
     configDir?: string;
 }): Promise<void>;
+/**
+ * Run the multi-exit client router: a local HTTPS (CONNECT) proxy that
+ * load-balances / fails over across several exit nodes, sending only China
+ * traffic through them and everything else direct. This is the client-side
+ * counterpart to `agentnet proxy enable` (which is the per-exit server).
+ *
+ * Exits come from --exit (repeatable, "host[:port]" or "name=host[:port]").
+ * If none are given we auto-discover them from the daemon's live IPAM (every
+ * known peer becomes a candidate exit on its proxy port; health checks drop
+ * the ones that aren't actually serving a proxy).
+ */
+/**
+ * Start the local Friend UI — a web page to view friends, accept/reject
+ * incoming friend-requests, and add friends by address. Talks to the running
+ * daemon over IPC. For manual accept/reject the daemon must run with
+ * `friends.autoAccept: false` (otherwise requests are accepted instantly and
+ * never queue).
+ */
+export declare function cmdUi(args: {
+    port?: number;
+    listen?: string;
+    doraDir?: string;
+    configDir?: string;
+}): Promise<void>;
 export declare function cmdProxyRouter(args: {
     exit?: string[];
     port?: number;

package/dist/cli/commands.js

@@ -13,6 +13,7 @@ import { AclEngine } from "../acl/acl-engine.js";
 import { AuditLog } from "../acl/audit.js";
 import yaml from "js-yaml";
 import { startMultiExitRouter } from "../proxy/multi-exit-router.js";
+import { startFriendUi } from "../ui/server.js";
 /**
  * Refuse to open a second Carrier peer with this identity if the
  * daemon is already running with the same keypair. Two peers sharing
@@ -1030,6 +1031,48 @@ export async function cmdProxyUse(args) {
     console.log(`#   agentnet proxy enable`);
     console.log(`#   agentnet grant --peer <your-userid> --tcp ${port}`);
 }
+/**
+ * Run the multi-exit client router: a local HTTPS (CONNECT) proxy that
+ * load-balances / fails over across several exit nodes, sending only China
+ * traffic through them and everything else direct. This is the client-side
+ * counterpart to `agentnet proxy enable` (which is the per-exit server).
+ *
+ * Exits come from --exit (repeatable, "host[:port]" or "name=host[:port]").
+ * If none are given we auto-discover them from the daemon's live IPAM (every
+ * known peer becomes a candidate exit on its proxy port; health checks drop
+ * the ones that aren't actually serving a proxy).
+ */
+/**
+ * Start the local Friend UI — a web page to view friends, accept/reject
+ * incoming friend-requests, and add friends by address. Talks to the running
+ * daemon over IPC. For manual accept/reject the daemon must run with
+ * `friends.autoAccept: false` (otherwise requests are accepted instantly and
+ * never queue).
+ */
+export async function cmdUi(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    if (daemonPid(config) === null) {
+        console.error("Daemon is not running — start it with 'agentnet up' first.");
+        process.exit(1);
+    }
+    // If this node also runs a dora server, surface its allocation table.
+    // Use --dora-dir, else auto-detect the common locations.
+    const { homedir } = await import("os");
+    const doraCandidates = args.doraDir
+        ? [resolve(args.doraDir, "roster.yaml")]
+        : [resolve(homedir(), ".dora-test", "roster.yaml"), resolve(homedir(), ".decent-registry", "roster.yaml")];
+    const doraRosterPath = doraCandidates.find((p) => existsSync(p)) ?? (args.doraDir ? doraCandidates[0] : undefined);
+    startFriendUi({
+        call: (req) => ipcCall(config, req),
+        routesPath: resolve(dir, "routes.yaml"),
+        doraRosterPath,
+        listenHost: args.listen ?? "127.0.0.1",
+        listenPort: args.port ?? 8765,
+    });
+    // Keep the process alive; runs until Ctrl-C / signal.
+    await new Promise(() => { });
+}
 export async function cmdProxyRouter(args) {
     const dir = args.configDir || ConfigLoader.defaultConfigDir();
     const config = await ConfigLoader.load(resolve(dir, "config.yaml"));

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // Belt-and-braces — also raise it here in case the CLI is run directly
 // (e.g. `node dist/cli/index.js` rather than via dist/index.js).
 EventEmitter.defaultMaxListeners = 100;
-import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, } from "./commands.js";
+import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, } from "./commands.js";
 async function main() {
     await yargs(hideBin(process.argv))
         .scriptName("agentnet")
@@ -124,6 +124,13 @@ async function main() {
     })
         .demandCommand(1, "Specify a service subcommand (run 'agentnet service --help')"), () => {
         // parent handler — never invoked because demandCommand above
+    })
+        .command("ui", "Start the local Friend UI web page (friends list, accept/reject requests, add friend)", (y) => y
+        .option("port", { type: "number", default: 8765, describe: "Local listen port" })
+        .option("listen", { type: "string", default: "127.0.0.1", describe: "Listen host" })
+        .option("dora-dir", { type: "string", describe: "If this node runs a dora server, its data-dir (to show allocations)" })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdUi({ port: argv.port, listen: argv.listen, doraDir: argv["dora-dir"], configDir: argv["config-dir"] });
     })
         // Tell the running daemon to re-exec itself with its original argv.
         // The daemon inherits its own uid (root if it was launched as root)

package/dist/daemon/ipc.d.ts

@@ -39,6 +39,10 @@ export interface IpcHandlers {
     /** Reject (drop) a queued friend-request by userid. Doesn't
      *  notify the sender — they'll just see no acceptance. */
     friendsReject: (userid: string) => Promise<void>;
+    /** Send a chat message (Carrier text, packet 64) to a friend and log it. */
+    chatSend: (userid: string, text: string) => Promise<void>;
+    /** Return recent chat history grouped by friend userid. */
+    chatHistory: () => Promise<Record<string, unknown>>;
     /** Re-read proxy allowlist from config and apply it to the running
      *  proxy WITHOUT restarting the daemon. Lets `agentnet proxy
      *  allow-host` take effect instantly instead of forcing a daemon
@@ -55,10 +59,11 @@ export interface IpcHandlers {
     selfRestart: () => Promise<Record<string, unknown>>;
 }
 export interface IpcRequest {
-    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "proxy-reload" | "self-restart";
+    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "proxy-reload" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;
+    text?: string;
 }
 export interface IpcResponseOk {
     ok: true;

package/dist/daemon/ipc.js

@@ -144,6 +144,14 @@ export class IpcServer {
                 await this.handlers.friendsReject(req.userid);
                 return;
             }
+            case "chat-send": {
+                if (!req.userid)
+                    throw new Error("userid is required");
+                await this.handlers.chatSend(req.userid, req.text ?? "");
+                return;
+            }
+            case "chat-history":
+                return await this.handlers.chatHistory();
             case "proxy-reload":
                 return await this.handlers.proxyReload();
             case "self-restart":

package/dist/daemon/server.d.ts

@@ -33,6 +33,9 @@ export declare class DaemonServer {
     private ipcServer?;
     private dnsServer?;
     private pendingFriends?;
+    /** In-memory chat history, keyed by friend userid (last 200 each). Drives
+     *  the `agentnet ui` chat window; not persisted across restarts. */
+    private chatLog;
     private startedAt;
     private isRunning;
     private statusTimer?;
@@ -51,6 +54,8 @@ export declare class DaemonServer {
      */
     private startPeerStatusSummary;
     getStatus(): DaemonStatus;
+    /** Append a chat message to the in-memory log (capped at 200 per friend). */
+    private logChat;
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
     private reFriendAt;

package/dist/daemon/server.js

@@ -50,6 +50,9 @@ export class DaemonServer {
     ipcServer;
     dnsServer;
     pendingFriends;
+    /** In-memory chat history, keyed by friend userid (last 200 each). Drives
+     *  the `agentnet ui` chat window; not persisted across restarts. */
+    chatLog = new Map();
     startedAt = 0;
     isRunning = false;
     statusTimer;
@@ -167,6 +170,18 @@ export class DaemonServer {
                         throw new Error(`No pending friend-request for userid ${userid}`);
                     // No-op at the Carrier level — sender just sees no acceptance.
                 },
+                chatSend: async (userid, text) => {
+                    if (!text)
+                        return;
+                    await this.peerManager.sendText(userid, text);
+                    this.logChat(userid, "out", text);
+                },
+                chatHistory: async () => {
+                    const chats = {};
+                    for (const [userid, msgs] of this.chatLog)
+                        chats[userid] = msgs;
+                    return { chats };
+                },
                 proxyReload: async () => {
                     // Re-read the proxy allowlist from disk and push it into the
                     // running proxy without a daemon restart (which would drop
@@ -429,6 +444,10 @@ export class DaemonServer {
                 }
                 return input;
             };
+            // Chat: log incoming Carrier text messages (packet 64) for the UI.
+            this.peerManager.on("message", (pubkey, text) => {
+                this.logChat(pubkey, "in", text);
+            });
             this.peerManager.on("friend-request", (req) => {
                 void pubkeyHexToUserid(req.pubkey).then((userid) => {
                     const who = `${req.name || "(unnamed)"} ${userid}`;
@@ -649,6 +668,17 @@ export class DaemonServer {
             activeSessions: this.packetRouter?.getStats().activeSessions || 0,
         };
     }
+    /** Append a chat message to the in-memory log (capped at 200 per friend). */
+    logChat(userid, dir, text) {
+        let msgs = this.chatLog.get(userid);
+        if (!msgs) {
+            msgs = [];
+            this.chatLog.set(userid, msgs);
+        }
+        msgs.push({ dir, text, ts: Date.now() });
+        if (msgs.length > 200)
+            msgs.splice(0, msgs.length - 200);
+    }
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
     reFriendAt = new Map();

package/dist/dora/dora-integration.js

@@ -40,7 +40,7 @@ export class DoraIntegration {
         this.logger = new Logger({ prefix: "Dora" });
         this.client = new DoraClient({
             registryUserids: opts.config.userids ?? [],
-            sendText: (toUserid, text) => opts.peerManager.sendText(toUserid, text),
+            sendText: (toUserid, text) => opts.peerManager.sendDora(toUserid, text),
             onText: (handler) => {
                 opts.peerManager.on("dora-message", (fromUserid, text) => {
                     handler(fromUserid, text);

package/dist/ui/server.d.ts

@@ -0,0 +1,17 @@
+import type { IpcRequest, IpcResponse } from "../daemon/ipc.js";
+export interface FriendUiOptions {
+    /** Call the running daemon over IPC (injected so this module stays
+     *  decoupled from the CLI's ipc client). */
+    call: (req: IpcRequest) => Promise<IpcResponse>;
+    /** Path to ~/.agentnet/routes.yaml — the exit-routing table the UI edits. */
+    routesPath: string;
+    /** If this node also runs a dora server, the path to its roster.yaml — the
+     *  UI shows the allocation table (userid → IP → name). Undefined = no dora. */
+    doraRosterPath?: string;
+    listenHost?: string;
+    listenPort?: number;
+    log?: (msg: string) => void;
+}
+export declare function startFriendUi(opts: FriendUiOptions): {
+    stop: () => void;
+};

package/dist/ui/server.js

@@ -0,0 +1,315 @@
+//
+// Friend UI — a tiny local web page for managing a peer's friends:
+//   1. display the friend list (name / status / userid)
+//   2. display incoming friend-requests, with Accept / Reject
+//   3. add a friend by address
+//
+// It's a thin frontend over the daemon's existing IPC ops (diag,
+// friends-pending, friends-accept, friends-reject, friend-request) — no new
+// daemon logic. Started with `agentnet ui`; point a browser at the printed URL.
+//
+// Note: requests only QUEUE for manual Accept/Reject when the daemon runs with
+// `friends.autoAccept = false`. With auto-accept on, the pending list stays
+// empty because the daemon accepts immediately.
+//
+import http from "node:http";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import yaml from "js-yaml";
+export function startFriendUi(opts) {
+    const host = opts.listenHost ?? "127.0.0.1";
+    const port = opts.listenPort ?? 8765;
+    const log = opts.log ?? ((s) => console.log(s));
+    const sendJson = (res, code, body) => {
+        res.writeHead(code, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+    };
+    const readBody = (req) => new Promise((resolve) => {
+        let b = "";
+        req.on("data", (c) => (b += c));
+        req.on("end", () => {
+            try {
+                resolve(b ? JSON.parse(b) : {});
+            }
+            catch {
+                resolve({});
+            }
+        });
+    });
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = (req.url || "/").split("?")[0];
+            if (req.method === "GET" && (url === "/" || url === "/index.html")) {
+                res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+                res.end(PAGE);
+                return;
+            }
+            if (req.method === "GET" && url === "/api/state") {
+                const [diag, pending] = await Promise.all([
+                    opts.call({ op: "diag" }),
+                    opts.call({ op: "friends-pending" }),
+                ]);
+                const d = diag.ok ? (diag.data ?? {}) : {};
+                const identity = d.identity ?? {};
+                const tun = d.tun ?? {};
+                const me = {
+                    userid: identity.userid,
+                    address: identity.address,
+                    ip: d.allocatedIp ?? tun.ip,
+                    installed: !!tun.ip, // lan/TUN is up
+                };
+                const friends = d.friends ?? [];
+                const pend = pending.ok ? (pending.data?.pending ?? []) : [];
+                sendJson(res, 200, { me, friends, pending: pend });
+                return;
+            }
+            if (req.method === "GET" && url === "/api/chat-history") {
+                const r = await opts.call({ op: "chat-history" });
+                sendJson(res, 200, r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
+                return;
+            }
+            if (req.method === "POST" && url === "/api/chat-send") {
+                const { userid, text } = await readBody(req);
+                const r = await opts.call({ op: "chat-send", userid, text });
+                sendJson(res, r.ok ? 200 : 400, r);
+                return;
+            }
+            if (req.method === "GET" && url === "/api/routes") {
+                let routes = { regions: [], default: "direct" };
+                if (existsSync(opts.routesPath)) {
+                    routes = yaml.load(readFileSync(opts.routesPath, "utf-8")) ?? routes;
+                }
+                const diag = await opts.call({ op: "diag" });
+                const available = diag.ok ? (diag.data?.ipam ?? []) : [];
+                sendJson(res, 200, { routes, available });
+                return;
+            }
+            if (req.method === "GET" && url === "/api/dora") {
+                let records = [];
+                if (opts.doraRosterPath && existsSync(opts.doraRosterPath)) {
+                    const r = yaml.load(readFileSync(opts.doraRosterPath, "utf-8"));
+                    records = r?.records ?? [];
+                }
+                sendJson(res, 200, { isDora: !!opts.doraRosterPath, records });
+                return;
+            }
+            if (req.method === "POST" && url === "/api/routes") {
+                const body = await readBody(req);
+                try {
+                    const routes = JSON.parse(body.routes ?? "{}");
+                    writeFileSync(opts.routesPath, yaml.dump(routes, { lineWidth: -1 }), "utf-8");
+                    sendJson(res, 200, { ok: true });
+                }
+                catch (err) {
+                    sendJson(res, 400, { ok: false, error: err instanceof Error ? err.message : String(err) });
+                }
+                return;
+            }
+            if (req.method === "POST" && url === "/api/accept") {
+                const { userid } = await readBody(req);
+                const r = await opts.call({ op: "friends-accept", userid });
+                sendJson(res, r.ok ? 200 : 400, r);
+                return;
+            }
+            if (req.method === "POST" && url === "/api/reject") {
+                const { userid } = await readBody(req);
+                const r = await opts.call({ op: "friends-reject", userid });
+                sendJson(res, r.ok ? 200 : 400, r);
+                return;
+            }
+            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);
+                return;
+            }
+            res.writeHead(404);
+            res.end("not found");
+        }
+        catch (err) {
+            sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.listen(port, host, () => {
+        log(`Friend UI on http://${host}:${port}`);
+        log(`(serves the running daemon's friends + pending requests over IPC)`);
+    });
+    return { stop: () => server.close() };
+}
+const PAGE = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>decentlan — friends</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font: 15px/1.5 -apple-system, system-ui, sans-serif; max-width: 760px; margin: 2rem auto; padding: 0 1rem; }
+  h1 { font-size: 1.3rem; } h2 { font-size: 1rem; margin: 1.5rem 0 .5rem; color: #888; text-transform: uppercase; letter-spacing: .04em; }
+  .row { display: flex; align-items: center; gap: .75rem; padding: .55rem .7rem; border: 1px solid #8883; border-radius: 8px; margin-bottom: .4rem; }
+  .row .meta { flex: 1; min-width: 0; }
+  .row .name { font-weight: 600; }
+  .row .sub { font-size: .8rem; color: #888; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .dot { width: .6rem; height: .6rem; border-radius: 50%; flex: 0 0 auto; }
+  .online { background: #2ecc71; } .offline { background: #bbb; } .requested { background: #f1c40f; }
+  button { font: inherit; padding: .3rem .7rem; border-radius: 6px; border: 1px solid #8886; background: transparent; cursor: pointer; }
+  button.accept { border-color: #2ecc71; color: #2ecc71; } button.reject { border-color: #e74c3c; color: #e74c3c; }
+  button:hover { background: #8881; }
+  .add { display: flex; gap: .5rem; margin: .5rem 0 1.5rem; }
+  .add input { flex: 1; font: inherit; padding: .4rem .6rem; border-radius: 6px; border: 1px solid #8886; background: transparent; color: inherit; }
+  .empty { color: #999; font-style: italic; padding: .4rem 0; }
+  #toast { position: fixed; bottom: 1rem; left: 50%; transform: translateX(-50%); background: #333; color: #fff; padding: .5rem 1rem; border-radius: 8px; opacity: 0; transition: opacity .2s; }
+  #toast.show { opacity: 1; }
+</style></head>
+<body>
+<h1>decentlan · friends</h1>
+<div id="me" class="sub" style="margin:-.5rem 0 1rem"></div>
+
+<div class="add">
+  <input id="addr" placeholder="paste a friend's address to send a request" autocomplete="off"/>
+  <button onclick="addFriend()">Add</button>
+</div>
+
+<h2>Friend requests <span id="pcount"></span></h2>
+<div id="pending"></div>
+
+<div id="doraPanel" style="display:none">
+  <h2>Dora allocations <span id="dcount"></span></h2>
+  <div id="dora"></div>
+</div>
+
+<h2>Exit nodes <span id="ecount"></span></h2>
+<div id="exits"></div>
+<div class="add">
+  <input id="exitIp" placeholder="exit virtual IP (e.g. 10.86.1.15)" autocomplete="off" style="flex:2"/>
+  <input id="exitRegion" placeholder="region (china/japan/us)" autocomplete="off" list="regionList" style="flex:1"/>
+  <datalist id="regionList"><option>china</option><option>japan</option><option>us</option></datalist>
+  <button onclick="addExit()">Add exit</button>
+</div>
+
+<h2>Friends <span id="fcount"></span></h2>
+<div id="friends"></div>
+
+<div id="chat" style="display:none; position:fixed; inset:0; background:Canvas; padding:1.5rem 1rem; max-width:760px; margin:0 auto;">
+  <div class="row" style="border:none; padding-left:0">
+    <button onclick="closeChat()">← Back</button>
+    <div class="meta"><div class="name" id="chatName"></div><div class="sub" id="chatSub"></div></div>
+  </div>
+  <div id="chatLog" style="height:calc(100vh - 13rem); overflow-y:auto; display:flex; flex-direction:column; gap:.35rem; padding:.5rem 0;"></div>
+  <div class="add"><input id="chatInput" placeholder="message…" autocomplete="off"/><button onclick="sendChat()">Send</button></div>
+</div>
+
+<div id="toast"></div>
+<script>
+const esc = s => String(s ?? '').replace(/[&<>"]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+const short = s => { s = String(s ?? ''); return s.length > 20 ? s.slice(0,10)+'…'+s.slice(-6) : s; };
+let toastT;
+function toast(msg){ const t=document.getElementById('toast'); t.textContent=msg; t.classList.add('show'); clearTimeout(toastT); toastT=setTimeout(()=>t.classList.remove('show'),2200); }
+
+async function api(path, body){ const r = await fetch(path, body?{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(body)}:{}); return r.json(); }
+
+window.friendsById = {};
+async function refresh(){
+  let s; try { s = await api('/api/state'); } catch(e){ return; }
+  const pend = s.pending || [], fr = s.friends || [], me = s.me || {};
+  document.getElementById('me').textContent = me.ip
+    ? ('My IP: ' + me.ip + (me.userid ? ' · ' + short(me.userid) : ''))
+    : (me.userid ? ('userid: ' + short(me.userid) + ' · lan/TUN not up') : 'daemon: no identity');
+  fr.forEach(f => { window.friendsById[f.userid||f.carrierId] = f; });
+  document.getElementById('pcount').textContent = pend.length ? '('+pend.length+')' : '';
+  document.getElementById('fcount').textContent = fr.length ? '('+fr.length+')' : '';
+  document.getElementById('pending').innerHTML = pend.length ? pend.map(p => \`
+    <div class="row">
+      <div class="meta"><div class="name">\${esc(p.name || 'unnamed')}</div>
+        <div class="sub">\${esc(short(p.userid))}\${p.hello? ' · "'+esc(p.hello)+'"':''}</div></div>
+      <button class="accept" onclick="act('accept','\${esc(p.userid)}')">Accept</button>
+      <button class="reject" onclick="act('reject','\${esc(p.userid)}')">Reject</button>
+    </div>\`).join('') : '<div class="empty">No pending requests.</div>';
+  document.getElementById('friends').innerHTML = fr.length ? fr.map(f => \`
+    <div class="row" style="cursor:pointer" onclick="openChat('\${esc(f.userid||f.carrierId)}')" title="open chat">
+      <span class="dot \${esc(f.status||'offline')}"></span>
+      <div class="meta"><div class="name">\${esc(f.name || 'unnamed')}</div>
+        <div class="sub">\${esc(f.status||'')} · \${esc(short(f.userid||f.carrierId))}\${f.virtualIp? ' · '+esc(f.virtualIp):''}</div></div>
+    </div>\`).join('') : '<div class="empty">No friends yet.</div>';
+}
+async function act(kind, userid){ const r = await api('/api/'+kind, {userid}); toast(r.ok? (kind==='accept'?'Accepted':'Rejected') : (r.error||'failed')); refresh(); }
+async function addFriend(){ const a=document.getElementById('addr'); const v=a.value.trim(); if(!v) return; const r=await api('/api/add',{address:v}); toast(r.ok?'Friend-request sent':(r.error||'failed')); if(r.ok) a.value=''; refresh(); }
+document.getElementById('addr').addEventListener('keydown', e=>{ if(e.key==='Enter') addFriend(); });
+
+let chatWith = null, chatTimer = null;
+async function openChat(userid){
+  chatWith = userid;
+  const f = window.friendsById[userid] || {};
+  document.getElementById('chatName').textContent = f.name || 'unnamed';
+  document.getElementById('chatSub').textContent = (f.status||'') + ' · ' + short(userid);
+  document.getElementById('chat').style.display = 'block';
+  await renderChat();
+  clearInterval(chatTimer); chatTimer = setInterval(renderChat, 2000);
+  document.getElementById('chatInput').focus();
+}
+function closeChat(){ chatWith = null; clearInterval(chatTimer); document.getElementById('chat').style.display='none'; refresh(); }
+async function renderChat(){
+  if(!chatWith) return;
+  let h; try { h = await api('/api/chat-history'); } catch(e){ return; }
+  const msgs = (h.chats && h.chats[chatWith]) || [];
+  const log = document.getElementById('chatLog');
+  log.innerHTML = msgs.length ? msgs.map(m => \`<div style="align-self:\${m.dir==='out'?'flex-end':'flex-start'};max-width:75%;padding:.4rem .7rem;border-radius:12px;background:\${m.dir==='out'?'#3478f6':'#8883'};color:\${m.dir==='out'?'#fff':'inherit'}">\${esc(m.text)}</div>\`).join('') : '<div class="empty">No messages yet — say hi.</div>';
+  log.scrollTop = log.scrollHeight;
+}
+async function sendChat(){
+  const i = document.getElementById('chatInput'); const t = i.value.trim();
+  if(!t || !chatWith) return;
+  i.value='';
+  const r = await api('/api/chat-send', {userid: chatWith, text: t});
+  if(!r.ok) toast(r.error||'send failed');
+  renderChat();
+}
+document.getElementById('chatInput').addEventListener('keydown', e=>{ if(e.key==='Enter') sendChat(); });
+
+// ---- Exit nodes (routes.yaml) ----
+let routesObj = { regions: [], default: 'direct' };
+async function refreshExits(){
+  let r; try { r = await api('/api/routes'); } catch(e){ return; }
+  routesObj = r.routes || { regions: [], default: 'direct' };
+  if(!Array.isArray(routesObj.regions)) routesObj.regions = [];
+  const regions = routesObj.regions;
+  const total = regions.reduce((n,rg)=>n+((rg.exits||[]).length),0);
+  document.getElementById('ecount').textContent = total ? '('+total+')' : '';
+  document.getElementById('exits').innerHTML = regions.length ? regions.map((rg)=> \`
+    <div class="row" style="flex-direction:column; align-items:stretch; gap:.3rem">
+      <div class="name">\${esc(rg.name)} \${(rg.exits||[]).length? '':'<span class="sub">(empty → direct)</span>'}</div>
+      \${(rg.exits||[]).map(ip=>\`<div class="sub" style="display:flex; gap:.5rem; align-items:center"><span style="flex:1">\${esc(ip)}</span><button class="reject" onclick="removeExit('\${esc(rg.name)}','\${esc(ip)}')">×</button></div>\`).join('')}
+    </div>\`).join('') : '<div class="empty">No routes.yaml regions — using auto-discovery.</div>';
+}
+function saveRoutes(){ return api('/api/routes', { routes: JSON.stringify(routesObj) }); }
+async function addExit(){
+  const ip=document.getElementById('exitIp').value.trim(), region=(document.getElementById('exitRegion').value.trim()||'china');
+  if(!ip) return;
+  let rg = routesObj.regions.find(x=>x.name===region);
+  if(!rg){ rg={name:region, exits:[]}; routesObj.regions.push(rg); }
+  rg.exits = rg.exits||[]; if(!rg.exits.includes(ip)) rg.exits.push(ip);
+  const r = await saveRoutes(); toast(r.ok?'Added — restart the router to apply':(r.error||'failed'));
+  document.getElementById('exitIp').value=''; refreshExits();
+}
+async function removeExit(region, ip){
+  const rg = routesObj.regions.find(x=>x.name===region); if(!rg) return;
+  rg.exits = (rg.exits||[]).filter(x=>x!==ip);
+  const r = await saveRoutes(); toast(r.ok?'Removed — restart the router to apply':(r.error||'failed')); refreshExits();
+}
+
+// ---- Dora allocations (if this node runs a dora server) ----
+async function refreshDora(){
+  let d; try { d = await api('/api/dora'); } catch(e){ return; }
+  const panel = document.getElementById('doraPanel');
+  if(!d.isDora){ panel.style.display='none'; return; }
+  panel.style.display='block';
+  const recs = d.records || [];
+  document.getElementById('dcount').textContent = '('+recs.length+')';
+  document.getElementById('dora').innerHTML = recs.length ? recs.map(r => \`
+    <div class="row">
+      <div class="meta"><div class="name">\${esc(r.name||'unnamed')} · \${esc(r.virtualIp||'')}</div>
+        <div class="sub">\${esc(short(r.userid))}</div></div>
+    </div>\`).join('') : '<div class="empty">No nodes registered yet.</div>';
+}
+
+refresh(); refreshExits(); refreshDora();
+setInterval(refresh, 3000); setInterval(refreshExits, 8000); setInterval(refreshDora, 5000);
+</script>
+</body></html>`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "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",
@@ -77,7 +77,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.6",
-    "@decentnetwork/peer": "^0.1.32",
+    "@decentnetwork/peer": "^0.1.33",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"
   },