@decentnetwork/lan 0.1.234 → 0.1.236

package/dist/cli/commands.js

@@ -17,6 +17,7 @@ import yaml from "js-yaml";
 import { startMultiExitRouter } from "../proxy/multi-exit-router.js";
 import { resolveEgressBindIp } from "../proxy/egress.js";
 import { startFriendUi } from "../ui/server.js";
+import { installLogThrottle } from "../utils/log-throttle.js";
 /**
  * Refuse to open a second Carrier peer with this identity if the
  * daemon is already running with the same keypair. Two peers sharing
@@ -442,6 +443,12 @@ export async function cmdUp(args) {
     if (args.name) {
         config.node.name = args.name;
     }
+    // Collapse repeated log lines before they reach stdout. A daemon that runs
+    // for weeks repeats the same message shape endlessly (a peer re-keying, an
+    // onion path failing); unthrottled that produced a 12 GB log file, and a
+    // full disk stops the daemon outright. Covers the SDK's [peer-debug] output
+    // too, since this wraps the process console rather than our Logger.
+    installLogThrottle();
     const daemon = new DaemonServer({
         config,
         configDir: dir,
@@ -2390,6 +2397,22 @@ WantedBy=multi-user.target
             const msg = err instanceof Error ? err.message : String(err);
             throw new Error(`Could not write ${plistPath} (need root? try 'sudo'): ${msg}`);
         }
+        // launchd never rotates StandardOutPath — the file grows until the disk is
+        // full and the daemon dies with it (a 12 GB agentnet log is how we found
+        // this). systemd users get journald rotation for free; on macOS the native
+        // equivalent is a newsyslog rule, so install one alongside the plist:
+        // rotate at 10 MB, keep 5 compressed generations.
+        try {
+            const fs = await import("fs/promises");
+            await fs.mkdir("/etc/newsyslog.d", { recursive: true });
+            await fs.writeFile("/etc/newsyslog.d/com.decentlan.agentnet.conf", "# logfilename          [owner:group]  mode count size(KB) when  flags\n" +
+                "/var/log/agentnet.log  root:wheel     644  5     10240    *     GZ\n", "utf-8");
+            console.log("Log rotation: /var/log/agentnet.log rotates at 10 MB, 5 compressed generations kept.");
+        }
+        catch (err) {
+            // Not fatal — the daemon's own log throttling already bounds the volume.
+            console.log(`Note: could not install the newsyslog rotation rule (${err instanceof Error ? err.message : err}). The log is still throttled in-process.`);
+        }
         execSync(`launchctl load ${plistPath}`);
         console.log(`Installed ${plistPath} and started com.decentlan.agentnet.`);
         console.log(`Optional — watch China video (CCTV etc.): agentnet proxy trust-ca && agentnet proxy router --hls-accel  (docs/CCTV-VIEWING.md)`);

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.234";
+window.__DK_UI_VERSION="0.1.236";
 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"/>',
@@ -3002,6 +3002,7 @@ function DkApp() {
     sessionStorage.setItem(key, "1");
     window.location.reload();
   }, [me && me.lanVer]);
+  const peers = data.peers;
   const [pendingAddr, setPendingAddr] = React.useState(() => dkParseDeepLinkAddress());
   React.useEffect(() => {
     const onHash = () => {
@@ -3030,7 +3031,6 @@ function DkApp() {
       }
     }
   }, [pendingAddr, peers]);
-  const peers = data.peers;
   const requests = data.requests;
   const exits = data.exits;
   const activeExit = data.activeExit;

package/dist/ui/server.js

@@ -242,7 +242,9 @@ export function startFriendUi(opts) {
             }
         });
     });
-    const server = http.createServer(async (req, res) => {
+    // Named so the IPv6 loopback listener below can share it (Node binds one
+    // listener to one address, and `localhost` is two addresses).
+    const handler = async (req, res) => {
         try {
             const url = (req.url || "/").split("?")[0];
             // Desktop UI bundle (the design). Falls back to the classic page when
@@ -922,12 +924,39 @@ export function startFriendUi(opts) {
         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}`);
+    };
+    const server = http.createServer(handler);
+    // `localhost` resolves to BOTH ::1 and 127.0.0.1. Binding only 127.0.0.1
+    // left the UI unreachable in a browser: Chrome/Safari try ::1 first and
+    // don't fall back the way curl does, so http://localhost:8765 refused the
+    // connection while 127.0.0.1:8765 served fine — and the daemon log claimed
+    // the UI was up. When the caller asked for loopback (the default), listen on
+    // BOTH families. An explicit non-loopback host is honoured as given.
+    const isLoopback = host === "127.0.0.1" || host === "localhost" || host === "::1";
+    let v6 = null;
+    server.listen(port, host === "localhost" ? "127.0.0.1" : host, () => {
+        log(`Friend UI on http://${isLoopback ? "localhost" : host}:${port}`);
         log(`(serves the running daemon's friends + pending requests over IPC)`);
     });
-    return { stop: () => server.close() };
+    if (isLoopback) {
+        // Second server object on ::1: Node can't bind one listener to two
+        // specific addresses, and binding :: instead would expose the UI on every
+        // interface — the opposite of what a loopback default promises.
+        v6 = http.createServer(handler);
+        v6.on("error", (err) => {
+            // A host with IPv6 disabled gives EADDRNOTAVAIL/EAFNOSUPPORT; the IPv4
+            // listener above is already serving, so this is not fatal.
+            if (err.code !== "EADDRINUSE")
+                log(`(IPv6 loopback unavailable: ${err.code ?? err.message} — IPv4 still serving)`);
+        });
+        v6.listen(port, "::1");
+    }
+    return {
+        stop: () => {
+            server.close();
+            v6?.close();
+        },
+    };
 }
 const PAGE = `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"/>

package/dist/utils/log-throttle.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Bound the daemon's log volume by collapsing repeated lines.
+ *
+ * A long-running daemon emits the same message shape over and over — a peer
+ * that keeps re-keying, an onion path that keeps failing, a node blacklisted
+ * on a loop. Left alone that filled a 12 GB log file. The value of the 30,000th
+ * copy of a line is zero, but the disk cost is not, and on a full disk the
+ * daemon stops working entirely.
+ *
+ * This wraps the process's console so EVERY writer is covered, including the
+ * `[peer-debug]` output from `@decentnetwork/peer` (which logs via console and
+ * so can't be reached by our own Logger class). Messages are bucketed by
+ * "shape" — ids, addresses and numbers stripped — so a line that differs only
+ * by which peer or port it names still collapses into one bucket.
+ *
+ * Behaviour per shape, per window: print the first BURST copies verbatim, then
+ * go quiet; when the window closes, print a single "(… ×N suppressed)" line so
+ * the volume is still visible. Nothing is dropped silently.
+ */
+export interface LogThrottleOptions {
+    /** Copies of one shape printed verbatim before suppression. */
+    burst?: number;
+    /** Window length; the counter and suppression reset after this. */
+    windowMs?: number;
+    /** Distinct shapes tracked at once (guards the map itself from a leak). */
+    maxShapes?: number;
+}
+/** Collapse a message to its shape: strip ids, IPs, numbers and durations so
+ *  the same event about different peers shares one bucket. */
+export declare function logShape(message: string): string;
+/**
+ * Install the throttle on `console`. Returns a restore function (used by tests;
+ * the daemon never uninstalls).
+ */
+export declare function installLogThrottle(opts?: LogThrottleOptions): () => void;

package/dist/utils/log-throttle.js

@@ -0,0 +1,105 @@
+/**
+ * Bound the daemon's log volume by collapsing repeated lines.
+ *
+ * A long-running daemon emits the same message shape over and over — a peer
+ * that keeps re-keying, an onion path that keeps failing, a node blacklisted
+ * on a loop. Left alone that filled a 12 GB log file. The value of the 30,000th
+ * copy of a line is zero, but the disk cost is not, and on a full disk the
+ * daemon stops working entirely.
+ *
+ * This wraps the process's console so EVERY writer is covered, including the
+ * `[peer-debug]` output from `@decentnetwork/peer` (which logs via console and
+ * so can't be reached by our own Logger class). Messages are bucketed by
+ * "shape" — ids, addresses and numbers stripped — so a line that differs only
+ * by which peer or port it names still collapses into one bucket.
+ *
+ * Behaviour per shape, per window: print the first BURST copies verbatim, then
+ * go quiet; when the window closes, print a single "(… ×N suppressed)" line so
+ * the volume is still visible. Nothing is dropped silently.
+ */
+/** Collapse a message to its shape: strip ids, IPs, numbers and durations so
+ *  the same event about different peers shares one bucket. */
+export function logShape(message) {
+    return message
+        .replace(/\b[0-9a-fA-F]{16,}\b/g, "<hex>")
+        .replace(/\b[1-9A-HJ-NP-Za-km-z]{40,}\b/g, "<id>") // base58 userid/address
+        .replace(/\b\d+\.\d+\.\d+\.\d+\b/g, "<ip>")
+        // No word boundaries: counters are routinely glued to a unit ("60s",
+        // "250ms", "step2"). Requiring \b left those unnormalized, so every
+        // distinct duration became its own bucket and nothing collapsed.
+        .replace(/\d+(\.\d+)?/g, "<n>")
+        .slice(0, 200);
+}
+/**
+ * Install the throttle on `console`. Returns a restore function (used by tests;
+ * the daemon never uninstalls).
+ */
+export function installLogThrottle(opts = {}) {
+    const burst = opts.burst ?? 5;
+    const windowMs = opts.windowMs ?? 60_000;
+    const maxShapes = opts.maxShapes ?? 500;
+    const shapes = new Map();
+    const original = {
+        log: console.log.bind(console),
+        debug: console.debug.bind(console),
+        info: console.info.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+    };
+    const wrap = (emit) => (message, ...args) => {
+        // Only throttle plain string messages; structured/objects pass through.
+        if (typeof message !== "string") {
+            emit(message, ...args);
+            return;
+        }
+        const now = Date.now();
+        const key = logShape(message);
+        let st = shapes.get(key);
+        if (!st) {
+            // Bound the tracking map. Evicting the oldest window is enough: a
+            // genuinely hot shape re-registers on its next line.
+            if (shapes.size >= maxShapes) {
+                let oldestKey;
+                let oldest = Infinity;
+                for (const [k, v] of shapes) {
+                    if (v.windowStart < oldest) {
+                        oldest = v.windowStart;
+                        oldestKey = k;
+                    }
+                }
+                if (oldestKey)
+                    shapes.delete(oldestKey);
+            }
+            st = { count: 0, windowStart: now, suppressed: 0, sample: message };
+            shapes.set(key, st);
+        }
+        if (now - st.windowStart >= windowMs) {
+            // Window closed — report what we swallowed, then start fresh.
+            if (st.suppressed > 0) {
+                emit(`… ${st.suppressed} more like this suppressed in the last ${Math.round(windowMs / 1000)}s: ${st.sample.slice(0, 160)}`);
+            }
+            st.count = 0;
+            st.suppressed = 0;
+            st.windowStart = now;
+        }
+        st.count++;
+        if (st.count <= burst) {
+            emit(message, ...args);
+            return;
+        }
+        st.suppressed++;
+    };
+    console.log = wrap(original.log);
+    console.debug = wrap(original.debug);
+    console.info = wrap(original.info);
+    console.warn = wrap(original.warn);
+    // Errors are rare and each one matters — never suppress them.
+    console.error = original.error;
+    return () => {
+        console.log = original.log;
+        console.debug = original.debug;
+        console.info = original.info;
+        console.warn = original.warn;
+        console.error = original.error;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.234",
+  "version": "0.1.236",
   "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",