@decentnetwork/lan 0.1.76 → 0.1.78

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/proxy/connect-proxy.js

@@ -126,11 +126,15 @@ export class ConnectProxy {
         }
         let bytes = 0;
         let closed = false;
+        let lastBytes = -1;
+        let idleTimer;
         const upstream = net.connect(port, host);
         const tearDown = (reason) => {
             if (closed)
                 return;
             closed = true;
+            if (idleTimer)
+                clearInterval(idleTimer);
             upstream.destroy();
             clientSocket.destroy();
             this.stats.active = Math.max(0, this.stats.active - 1);
@@ -181,6 +185,26 @@ export class ConnectProxy {
         upstream.on("end", () => tearDown("upstream end"));
         clientSocket.on("error", (err) => tearDown(`client error: ${err.message}`));
         clientSocket.on("end", () => tearDown("client end"));
+        // "close" catches abrupt teardowns (RST / socket destroyed) that never
+        // emit "end" — without these, a half-dead tunnel leaks.
+        upstream.on("close", () => tearDown("upstream close"));
+        clientSocket.on("close", () => tearDown("client close"));
+        // Idle reaper: when the Carrier path drops mid-stream the broken side
+        // sends no FIN, so neither "end" nor "error" fires and the sockets would
+        // leak until the kernel's multi-hour TCP keepalive — they pile up under
+        // load (1080p opens many high-bandwidth tunnels; two clients on one exit
+        // compounds it) and starve the exit. If no bytes flow in EITHER direction
+        // across two idle ticks, tear it down. Active streaming keeps `bytes`
+        // climbing (and backpressure pauses a one-sided flow), so only genuinely
+        // dead tunnels are reaped. Tunable via AGENTNET_TUNNEL_IDLE_MS.
+        const idleMs = Number(process.env.AGENTNET_TUNNEL_IDLE_MS) || 120_000;
+        idleTimer = setInterval(() => {
+            if (bytes === lastBytes)
+                tearDown("idle (no data — Carrier path likely dropped)");
+            else
+                lastBytes = bytes;
+        }, idleMs);
+        idleTimer.unref?.();
     }
     refuse(clientSocket, src, srcName, target, code, reason) {
         this.stats.totalRefused += 1;

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.76",
+  "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",