n2n-nexus 0.4.2 → 0.7.0

package/build/daemon/index.js

@@ -1,41 +1,57 @@
 import { createDaemonServer } from "./server.js";
-import { pkg, getRootPath } from "../config/index.js";
-import { NEXUS_HOST } from "../constants.js";
+import { closeDatabase } from "../storage/sqlite.js";
+import { runTaskMaintenance } from "../storage/tasks.js";
+import { TASK_MAINTENANCE_INTERVAL_MS } from "../constants.js";
+import { pkg } from "../config/index.js";
+import { getArg } from "../config/cli.js";
+import { getRootPath } from "../config/paths.js";
+import { NEXUS_HOST, NEXUS_PORT } from "../constants.js";
 function parsePort() {
-    const argIndex = process.argv.indexOf("--port");
-    if (argIndex !== -1) {
-        const parsed = parseInt(process.argv[argIndex + 1] || "", 10);
+    for (const candidate of [getArg("--port"), process.env.NEXUS_DAEMON_PORT]) {
+        const parsed = parseInt(candidate || "", 10);
         if (!isNaN(parsed) && parsed > 0)
             return parsed;
     }
-    const envPort = parseInt(process.env.NEXUS_DAEMON_PORT || process.env.NEXUS_PORT || "", 10);
-    if (!isNaN(envPort) && envPort > 0)
-        return envPort;
-    return 5688;
+    return NEXUS_PORT;
 }
 function parseHost() {
-    const argIndex = process.argv.indexOf("--host");
-    if (argIndex !== -1 && process.argv[argIndex + 1]) {
-        return process.argv[argIndex + 1];
-    }
-    return process.env.NEXUS_HOST || NEXUS_HOST;
+    return getArg("--host") || process.env.NEXUS_HOST || NEXUS_HOST;
 }
 export async function runDaemon() {
     const port = parsePort();
     const host = parseHost();
     const root = getRootPath();
-    // Inject root path into CONFIG via env so StorageManager picks it up
+    // Publish the resolved root so every storage module (which reads NEXUS_ROOT) agrees with the log line below
     process.env.NEXUS_ROOT = root;
-    const { server, storageInfo } = await createDaemonServer({ port, host, version: pkg.version });
+    const { server } = await createDaemonServer({ port, host, version: pkg.version });
     await new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(port, host, () => {
             console.error(`[n2n-nexus] Daemon v${pkg.version} listening on http://${host}:${port}`);
-            console.error(`[n2n-nexus] Storage: ${root} (${storageInfo.storageMode}${storageInfo.isDegraded ? ", degraded" : ""})`);
+            console.error(`[n2n-nexus] Storage: ${root}`);
             resolve();
         });
     });
-    process.once("SIGINT", () => { console.error("[n2n-nexus] Shutting down."); server.close(() => process.exit(0)); });
-    process.once("SIGTERM", () => { server.close(() => process.exit(0)); });
+    // Expire overdue tasks and purge old finished ones at startup and then periodically
+    const maintain = () => {
+        const { expired, removed } = runTaskMaintenance();
+        if (expired || removed)
+            console.error(`[n2n-nexus] Task maintenance: ${expired} expired, ${removed} removed.`);
+    };
+    maintain();
+    setInterval(maintain, TASK_MAINTENANCE_INTERVAL_MS).unref();
+    // Graceful shutdown: stop accepting connections, let in-flight requests
+    // finish, then close SQLite. A second signal exits immediately.
+    const shutdown = (signal) => {
+        console.error(`[n2n-nexus] ${signal} received, shutting down.`);
+        server.close(() => {
+            closeDatabase();
+            process.exit(0);
+        });
+        process.once(signal, () => process.exit(1));
+    };
+    process.once("SIGINT", () => shutdown("SIGINT"));
+    process.once("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("exit", () => closeDatabase());
     console.error("[n2n-nexus] Ready. Press Ctrl+C to stop.");
 }

package/build/daemon/rate-limit.js

@@ -0,0 +1,62 @@
+/**
+ * Token-bucket rate limiter keyed by caller. Each key may make `burst`
+ * calls at once and refills at `perSecond`. Only `perSecond` = 0 disables
+ * it; `burst` is at least 1 (a bucket smaller than one call would reject
+ * every call forever).
+ */
+export class RateLimiter {
+    perSecond;
+    now;
+    buckets = new Map();
+    lastSweep = 0;
+    burst;
+    constructor(perSecond, burst, now = Date.now) {
+        this.perSecond = perSecond;
+        this.now = now;
+        this.burst = Math.max(1, burst);
+    }
+    get enabled() {
+        return this.perSecond > 0;
+    }
+    /** Take one token for `key`. Returns 0 when allowed, otherwise seconds until a token is available. */
+    take(key) {
+        if (!this.enabled)
+            return 0;
+        const t = this.now();
+        this.sweep(t);
+        const b = this.buckets.get(key) ?? { tokens: this.burst, updated: t };
+        b.tokens = Math.min(this.burst, b.tokens + ((t - b.updated) / 1000) * this.perSecond);
+        b.updated = t;
+        this.buckets.set(key, b);
+        if (b.tokens >= 1) {
+            b.tokens -= 1;
+            return 0;
+        }
+        return Math.max(1, Math.ceil((1 - b.tokens) / this.perSecond));
+    }
+    /** Drop buckets that have refilled completely, so ids that stop calling do not accumulate. */
+    sweep(t) {
+        if (t - this.lastSweep < 60_000)
+            return;
+        this.lastSweep = t;
+        const fullAfterMs = (this.burst / this.perSecond) * 1000;
+        for (const [key, b] of this.buckets) {
+            if (t - b.updated >= fullAfterMs)
+                this.buckets.delete(key);
+        }
+    }
+}
+/** Per-instance limit from NEXUS_RATE_LIMIT (calls/s, 0 disables) and NEXUS_RATE_BURST. */
+export function rateLimitFromEnv(env = process.env) {
+    const num = (v, d) => {
+        const n = Number(v);
+        return v !== undefined && v !== "" && Number.isFinite(n) && n >= 0 ? n : d;
+    };
+    return { perSecond: num(env.NEXUS_RATE_LIMIT, 20), burst: num(env.NEXUS_RATE_BURST, 60) };
+}
+/**
+ * Instance ids are self-declared, so a client could rotate them to dodge the
+ * per-instance limit; every request is also counted per client address at
+ * this multiple of the per-instance limit.
+ */
+export const ADDRESS_LIMIT_FACTOR = 5;