@solongate/proxy 0.59.3 → 0.59.4

package/hooks/guard.bundled.mjs

@@ -6531,11 +6531,12 @@ var init_src = __esm({
 
 // packages/proxy/hooks/guard.mjs
 import { readFileSync, existsSync, statSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync } 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 = 32;
+var HOOK_VERSION = 33;
 function localLogsOnly(security) {
   const l = security && security.localLogs;
   return !!(l && l.enabled && typeof l.path === "string" && l.path.trim());
@@ -6713,6 +6714,51 @@ var AGENT_TYPE = process.argv[2] || "claude-code";
 var POLICY_SELECTOR = process.env.SOLONGATE_AGENT_ID || "";
 var AGENT_ID = POLICY_SELECTOR || AGENT_TYPE;
 var AGENT_NAME = process.env.SOLONGATE_AGENT_NAME || process.argv[3] || AGENT_TYPE;
+var REFRESH_MODE = process.argv.includes("--sg-refresh-policy");
+async function refreshPolicyCache() {
+  try {
+    const agentKey = (AGENT_ID || "default").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const cacheFile = join(resolve(homedir(), ".solongate"), ".policy-cache-" + agentKey + ".json");
+    let selfProtect = true, security = null, hookVersions = null, policy = null;
+    try {
+      if (existsSync(cacheFile)) {
+        const c = JSON.parse(readFileSync(cacheFile, "utf-8"));
+        if (c) {
+          policy = c.policy ?? null;
+          if (typeof c.selfProtect === "boolean")
+            selfProtect = c.selfProtect;
+          if (c.security !== void 0)
+            security = c.security;
+          if (c.hookVersions)
+            hookVersions = c.hookVersions;
+        }
+      }
+    } catch {
+    }
+    try {
+      const res = await fetch(API_URL + "/api/v1/policies/active?agent_id=" + encodeURIComponent(AGENT_ID || "") + "&hv=" + HOOK_VERSION, { headers: AUTH_HEADERS, signal: AbortSignal.timeout(8e3) });
+      if (res.ok) {
+        const body = await res.json();
+        if (typeof body?.self_protection_enabled === "boolean")
+          selfProtect = body.self_protection_enabled;
+        if (body?.security !== void 0)
+          security = body.security;
+        if (body?.hook_versions && typeof body.hook_versions === "object")
+          hookVersions = body.hook_versions;
+        policy = body && body.policy ? body.policy : null;
+      }
+    } catch {
+    }
+    try {
+      writeFileSync(cacheFile, JSON.stringify({ _ts: Date.now(), policy, selfProtect, security, hookVersions }));
+    } catch {
+    }
+  } catch {
+  }
+}
+if (REFRESH_MODE) {
+  refreshPolicyCache().finally(() => process.exit(0));
+}
 function blockTool(reason) {
   if (AGENT_TYPE === "gemini-cli") {
     process.stdout.write(JSON.stringify({
@@ -7610,6 +7656,8 @@ function readReferencedFiles(args, cwd) {
 }
 process.stdin.on("data", (c) => input += c);
 process.stdin.on("end", async () => {
+  if (REFRESH_MODE)
+    return;
   if (process.env.SOLONGATE_DEBUG) {
   }
   if (!API_KEY) {
@@ -7671,21 +7719,6 @@ process.stdin.on("end", async () => {
       } catch {
       }
       if (refreshDue) {
-        try {
-          const res = await fetch(API_URL + "/api/v1/policies/active?agent_id=" + encodeURIComponent(AGENT_ID || "") + "&hv=" + HOOK_VERSION, { headers: AUTH_HEADERS, signal: AbortSignal.timeout(2e3) });
-          if (res.ok) {
-            const body = await res.json();
-            if (typeof body?.self_protection_enabled === "boolean")
-              selfProtectEnabled = body.self_protection_enabled;
-            if (body?.security !== void 0)
-              securityCfg = body.security;
-            if (body?.hook_versions && typeof body.hook_versions === "object")
-              CLOUD_HOOK_VERSIONS = body.hook_versions;
-            if (body && body.policy)
-              dashboardPolicy = body.policy;
-          }
-        } catch {
-        }
         if (!dashboardPolicy && staleCache) {
           dashboardPolicy = staleCache.policy;
           if (typeof staleCache.selfProtect === "boolean")
@@ -7695,10 +7728,19 @@ process.stdin.on("end", async () => {
           if (staleCache.hookVersions)
             CLOUD_HOOK_VERSIONS = staleCache.hookVersions;
         }
-        const keepPolicy = dashboardPolicy || staleCache && staleCache.policy || null;
-        try {
-          writeFileSync(policyCacheFile, JSON.stringify({ _ts: Date.now(), policy: keepPolicy, selfProtect: selfProtectEnabled, security: securityCfg, hookVersions: CLOUD_HOOK_VERSIONS }));
-        } catch {
+        if (API_KEY) {
+          try {
+            const lock = join(resolve(homedir(), ".solongate"), ".policy-refresh-" + agentKey + ".lock");
+            const due = !existsSync(lock) || Date.now() - statSync(lock).mtimeMs > 3e3;
+            if (due) {
+              try {
+                writeFileSync(lock, String(Date.now()));
+              } catch {
+              }
+              spawn(process.execPath, [process.argv[1], AGENT_TYPE, AGENT_NAME, "--sg-refresh-policy"], { detached: true, stdio: "ignore", env: process.env }).unref();
+            }
+          } catch {
+          }
         }
       }
       if (process.env.SOLONGATE_DEBUG) {

package/hooks/guard.mjs

@@ -22,6 +22,7 @@
  * Auto-installed by: npx @solongate/proxy init --global
  */
 import { readFileSync, existsSync, statSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync } 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';
@@ -31,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 = 32;
+const HOOK_VERSION = 33;
 
 // True when local log storage is ON. In that mode logs are kept LOCAL ONLY and
 // nothing is sent to the cloud audit log.
@@ -248,6 +249,40 @@ const POLICY_SELECTOR = process.env.SOLONGATE_AGENT_ID || '';
 const AGENT_ID = POLICY_SELECTOR || AGENT_TYPE;
 const AGENT_NAME = process.env.SOLONGATE_AGENT_NAME || process.argv[3] || AGENT_TYPE;
 
+// ── Background policy refresh (stale-while-revalidate) ──
+// The hot path NEVER blocks on the network: when the policy cache is stale it
+// serves the cached (or local) policy INSTANTLY and spawns this detached mode to
+// fetch a fresh policy and rewrite the cache for the NEXT call. Result: fast tool
+// calls AND ~one-call propagation of policy changes — no long-TTL tradeoff.
+const REFRESH_MODE = process.argv.includes('--sg-refresh-policy');
+async function refreshPolicyCache() {
+  try {
+    const agentKey = (AGENT_ID || 'default').replace(/[^a-zA-Z0-9_-]/g, '_');
+    const cacheFile = join(resolve(homedir(), '.solongate'), '.policy-cache-' + agentKey + '.json');
+    // Preserve existing fields so a failed fetch never erases the last-known-good.
+    let selfProtect = true, security = null, hookVersions = null, policy = null;
+    try {
+      if (existsSync(cacheFile)) {
+        const c = JSON.parse(readFileSync(cacheFile, 'utf-8'));
+        if (c) { policy = c.policy ?? null; if (typeof c.selfProtect === 'boolean') selfProtect = c.selfProtect; if (c.security !== undefined) security = c.security; if (c.hookVersions) hookVersions = c.hookVersions; }
+      }
+    } catch {}
+    try {
+      const res = await fetch(API_URL + '/api/v1/policies/active?agent_id=' + encodeURIComponent(AGENT_ID || '') + '&hv=' + HOOK_VERSION, { headers: AUTH_HEADERS, signal: AbortSignal.timeout(8000) });
+      if (res.ok) {
+        const body = await res.json();
+        if (typeof body?.self_protection_enabled === 'boolean') selfProtect = body.self_protection_enabled;
+        if (body?.security !== undefined) security = body.security;
+        if (body?.hook_versions && typeof body.hook_versions === 'object') hookVersions = body.hook_versions;
+        policy = (body && body.policy) ? body.policy : null;
+      }
+    } catch {}
+    // Always advance _ts (success or failure) so the hot path backs off between refreshes.
+    try { writeFileSync(cacheFile, JSON.stringify({ _ts: Date.now(), policy, selfProtect, security, hookVersions })); } catch {}
+  } catch {}
+}
+if (REFRESH_MODE) { refreshPolicyCache().finally(() => process.exit(0)); }
+
 // ── Per-tool block/allow output ──
 // Response format depends on the agent:
 // Claude Code:  exit 2 + stderr = BLOCK, exit 0 = ALLOW
@@ -1369,6 +1404,9 @@ function readReferencedFiles(args, cwd) {
 
 process.stdin.on('data', c => input += c);
 process.stdin.on('end', async () => {
+  // Background-refresh invocation has no tool call to evaluate — it already ran
+  // refreshPolicyCache() at startup; do nothing on the (empty) stdin.
+  if (REFRESH_MODE) return;
   // No policy selected => no enforcement. A plain launch (no SOLONGATE_AGENT_ID)
   // is intentionally unrestricted.
   if (process.env.SOLONGATE_DEBUG) {
@@ -1466,32 +1504,31 @@ process.stdin.on('end', async () => {
           }
         }
       } catch {}
-      // Refresh from the API at most once per TTL window.
+      // Cache stale → DO NOT block the tool on the network. Serve the last-known-good
+      // policy right now (or the local policy.json fallback below if there is none)
+      // and kick off a DETACHED background refresh that rewrites the cache for the
+      // NEXT call. Stale-while-revalidate: tool calls stay instant (~ms), yet a
+      // policy change still lands within ~one call, because the fetch runs in
+      // parallel instead of on the hot path.
       if (refreshDue) {
-        try {
-          const res = await fetch(API_URL + '/api/v1/policies/active?agent_id=' + encodeURIComponent(AGENT_ID || '') + '&hv=' + HOOK_VERSION, { headers: AUTH_HEADERS, signal: AbortSignal.timeout(2000) });
-          if (res.ok) {
-            const body = await res.json();
-            if (typeof body?.self_protection_enabled === 'boolean') selfProtectEnabled = body.self_protection_enabled;
-            if (body?.security !== undefined) securityCfg = body.security;
-            if (body?.hook_versions && typeof body.hook_versions === 'object') CLOUD_HOOK_VERSIONS = body.hook_versions;
-            if (body && body.policy) dashboardPolicy = body.policy;
-          }
-        } catch {}
-        // API slow/unreachable → keep enforcing the last-known-good policy.
         if (!dashboardPolicy && staleCache) {
           dashboardPolicy = staleCache.policy;
           if (typeof staleCache.selfProtect === 'boolean') selfProtectEnabled = staleCache.selfProtect;
           if (staleCache.security !== undefined) securityCfg = staleCache.security;
           if (staleCache.hookVersions) CLOUD_HOOK_VERSIONS = staleCache.hookVersions;
         }
-        // ALWAYS advance _ts after an attempt — success, stale fallback, or even a
-        // cold miss with no policy — so a slow/down endpoint is retried at most
-        // once per TTL (≈2s per 10s worst case, not 2s per call). Keep the
-        // last-known-good policy in the cache so a failed attempt never erases it;
-        // when nothing is available, enforcement falls back to ~/.solongate/policy.json below.
-        const keepPolicy = dashboardPolicy || (staleCache && staleCache.policy) || null;
-        try { writeFileSync(policyCacheFile, JSON.stringify({ _ts: Date.now(), policy: keepPolicy, selfProtect: selfProtectEnabled, security: securityCfg, hookVersions: CLOUD_HOOK_VERSIONS })); } catch {}
+        // Debounce: at most one background refresh in flight per ~3s, so a burst of
+        // stale calls (or several agents sharing this cache) doesn't spawn a swarm.
+        if (API_KEY) {
+          try {
+            const lock = join(resolve(homedir(), '.solongate'), '.policy-refresh-' + agentKey + '.lock');
+            const due = !existsSync(lock) || (Date.now() - statSync(lock).mtimeMs) > 3000;
+            if (due) {
+              try { writeFileSync(lock, String(Date.now())); } catch {}
+              spawn(process.execPath, [process.argv[1], AGENT_TYPE, AGENT_NAME, '--sg-refresh-policy'], { detached: true, stdio: 'ignore', env: process.env }).unref();
+            }
+          } catch {}
+        }
       }
 
       if (process.env.SOLONGATE_DEBUG) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solongate/proxy",
-  "version": "0.59.3",
+  "version": "0.59.4",
   "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": {