@solongate/proxy 0.83.7 → 0.83.8

package/hooks/guard.bundled.mjs

@@ -6530,13 +6530,13 @@ var init_src = __esm({
 });
 
 // hooks/guard.mjs
-import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync } from "node:fs";
+import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, openSync, readSync, closeSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { resolve, join, dirname, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 import { gunzipSync } from "node:zlib";
 import { createHash } from "node:crypto";
-var HOOK_VERSION = 72;
+var HOOK_VERSION = 73;
 function localLogsOnly(security) {
   if (security !== void 0) {
     const l = security && security.localLogs;
@@ -7915,35 +7915,62 @@ var RL_WINDOWS = [
   { key: "perHour", ms: 36e5, label: "hour" },
   { key: "perMinute", ms: 6e4, label: "minute" }
 ];
+var RL_REC = 14;
+var RL_MAX_READ = 1048576;
+var RL_MAX_FILE = 4194304;
 function rateLimitCheck(agentKey, limits) {
   try {
-    const file = join(resolve(homedir(), ".solongate"), ".ratelimit-" + agentKey + ".json");
+    const dir = resolve(homedir(), ".solongate");
+    const file = join(dir, ".ratelimit-" + agentKey + ".log");
     const now = Date.now();
-    let stamps = [];
-    if (existsSync(file)) {
-      try {
-        stamps = JSON.parse(readFileSync(file, "utf-8"));
-      } catch {
-        stamps = [];
-      }
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    try {
+      appendFileSync(file, String(now).padStart(13, "0") + "\n");
+    } catch {
+      return null;
+    }
+    let size = 0;
+    try {
+      size = statSync(file).size;
+    } catch {
+      return null;
+    }
+    const start = Math.max(0, size - RL_MAX_READ);
+    const from = start - start % RL_REC;
+    let buf = "";
+    try {
+      const fd = openSync(file, "r");
+      const b = Buffer.alloc(size - from);
+      readSync(fd, b, 0, b.length, from);
+      closeSync(fd);
+      buf = b.toString("latin1");
+    } catch {
+      return null;
+    }
+    const stamps = [];
+    for (let i = 0; i + RL_REC <= buf.length; i += RL_REC) {
+      const t = parseInt(buf.slice(i, i + 13), 10);
+      if (Number.isFinite(t) && now - t < 864e5)
+        stamps.push(t);
     }
-    if (!Array.isArray(stamps))
-      stamps = [];
-    stamps = stamps.filter((t) => typeof t === "number" && now - t < 864e5);
-    if (stamps.length > 5e4)
-      stamps = stamps.slice(-5e4);
     for (const w of RL_WINDOWS) {
       const limit = limits[w.key];
       if (limit > 0) {
         const count = stamps.reduce((n, t) => now - t < w.ms ? n + 1 : n, 0);
-        if (count >= limit)
+        if (count > limit)
           return { window: w.label, limit };
       }
     }
-    stamps.push(now);
-    try {
-      writeFileSync(file, JSON.stringify(stamps));
-    } catch {
+    if (size > RL_MAX_FILE) {
+      try {
+        const tmp = file + "." + process.pid + ".tmp";
+        writeFileSync(tmp, stamps.map((t) => String(t).padStart(13, "0") + "\n").join(""));
+        renameSync(tmp, file);
+      } catch {
+      }
     }
     return null;
   } catch {

package/hooks/guard.mjs

@@ -21,7 +21,7 @@
  * Logs DENY decisions to SolonGate Cloud. ALLOWs are logged by audit.mjs.
  * Auto-installed by: npx @solongate/proxy init --global
  */
-import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync } from 'node:fs';
+import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, openSync, readSync, closeSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { resolve, join, dirname, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
@@ -32,7 +32,7 @@ import { createHash } from 'node:crypto';
 // the installed hook self-updates when the cloud version is higher (see
 // maybeSelfUpdate). This is what makes guard fixes propagate without a manual
 // reinstall — the same trust model as the OPA WASM this hook already runs.
-const HOOK_VERSION = 72;
+const HOOK_VERSION = 73;
 
 // True when local log storage is ON. In that mode logs are kept LOCAL ONLY and
 // nothing is sent to the cloud audit log.
@@ -1746,28 +1746,80 @@ const RL_WINDOWS = [
   { key: 'perHour', ms: 3600000, label: 'hour' },
   { key: 'perMinute', ms: 60000, label: 'minute' },
 ];
+// One call = one fixed-width record, appended. 13 digits of epoch ms + newline;
+// good until the year 2286, and fixed width is what lets the file be read by
+// offset without parsing it all.
+const RL_REC = 14;
+const RL_MAX_READ = 1_048_576; // tail we scan: ~74k calls, far past any window
+const RL_MAX_FILE = 4_194_304; // compact past this
+
+/**
+ * Rate limit, counted with an append-only log.
+ *
+ * This used to read a JSON array of timestamps, count, push one and write the
+ * whole array back. Under a burst of parallel tool calls — the exact thing a
+ * rate limit is for — every hook read the same array and wrote back its own
+ * copy, so increments were lost and the limit did not hold: measured at 14
+ * calls through a limit of 5, from 30 fired at once.
+ *
+ * An O_APPEND write of a short record does not interleave, so no call can erase
+ * another's. The reservation is made BEFORE the decision, which is what makes
+ * the count exact under concurrency: every process appends, then counts what is
+ * in the window, and the ones past the limit are the ones refused. A refused
+ * call therefore also occupies a slot, which is the honest reading of a rate
+ * limit — thirty attempts in a minute IS thirty calls a minute, whatever came
+ * back. (This is the same trick the guest allowance used for the same reason.)
+ */
 function rateLimitCheck(agentKey, limits) {
   try {
-    const file = join(resolve(homedir(), '.solongate'), '.ratelimit-' + agentKey + '.json');
+    const dir = resolve(homedir(), '.solongate');
+    // New name: the old .json holds an array this format cannot read, and one
+    // window resetting on upgrade is better than parsing ambiguity.
+    const file = join(dir, '.ratelimit-' + agentKey + '.log');
     const now = Date.now();
-    let stamps = [];
-    if (existsSync(file)) {
-      try { stamps = JSON.parse(readFileSync(file, 'utf-8')); } catch { stamps = []; }
+    try { mkdirSync(dir, { recursive: true }); } catch {}
+    // Reserve first. A failed append must not hand out a free call, so treat it
+    // as "cannot account for this" and fall open the same way the catch does.
+    try { appendFileSync(file, String(now).padStart(13, '0') + '\n'); } catch { return null; }
+
+    let size = 0;
+    try { size = statSync(file).size; } catch { return null; }
+    const start = Math.max(0, size - RL_MAX_READ);
+    // Align to a record boundary so a truncated head is never parsed.
+    const from = start - (start % RL_REC);
+    let buf = '';
+    try {
+      const fd = openSync(file, 'r');
+      const b = Buffer.alloc(size - from);
+      readSync(fd, b, 0, b.length, from);
+      closeSync(fd);
+      buf = b.toString('latin1');
+    } catch { return null; }
+
+    const stamps = [];
+    for (let i = 0; i + RL_REC <= buf.length; i += RL_REC) {
+      const t = parseInt(buf.slice(i, i + 13), 10);
+      if (Number.isFinite(t) && now - t < 86400000) stamps.push(t);
     }
-    if (!Array.isArray(stamps)) stamps = [];
-    // Prune to the longest window (24h) and cap size to bound work/IO.
-    stamps = stamps.filter((t) => typeof t === 'number' && now - t < 86400000);
-    if (stamps.length > 50000) stamps = stamps.slice(-50000);
-    // Check each enabled window against the current count (before adding now).
+    // Our own record is in here, so the limit is crossed at > rather than >=.
     for (const w of RL_WINDOWS) {
       const limit = limits[w.key];
       if (limit > 0) {
         const count = stamps.reduce((n, t) => (now - t < w.ms ? n + 1 : n), 0);
-        if (count >= limit) return { window: w.label, limit };
+        if (count > limit) return { window: w.label, limit };
       }
     }
-    stamps.push(now);
-    try { writeFileSync(file, JSON.stringify(stamps)); } catch {}
+
+    // Compaction, rarely: keep the last 24h. Written beside and renamed, so a
+    // reader never sees a half-written file. An append landing during the swap
+    // is lost, which costs one call of accuracy on a file this size.
+    if (size > RL_MAX_FILE) {
+      try {
+        const tmp = file + '.' + process.pid + '.tmp';
+        writeFileSync(tmp, stamps.map((t) => String(t).padStart(13, '0') + '\n').join(''));
+        renameSync(tmp, file);
+      } catch { /* keep growing rather than risk the file */ }
+    }
     return null;
   } catch {
     return null; // fail open

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solongate/proxy",
-  "version": "0.83.7",
+  "version": "0.83.8",
   "description": "AI tool security proxy: protect any AI tool server with customizable policies, path/command constraints, rate limiting, and audit logging. No code changes required.",
   "type": "module",
   "bin": {