@decentnetwork/lan 0.1.234 → 0.1.235

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.235";
 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/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.235",
   "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",