shieldcortex 3.0.3 → 3.1.0

package/hooks/openclaw/cortex-memory/handler.ts

@@ -6,158 +6,22 @@
  * - Context injection on agent bootstrap
  * - Keyword-triggered memory saves
  */
-import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
+import { createOpenClawRuntime } from "./runtime.mjs";
 
 // ==================== SERVER COMMAND RESOLUTION ====================
 
-let _shieldConfig = null;
 let _autoMemoryNoticeShown = false;
-
-async function loadShieldConfig() {
-  if (_shieldConfig) return _shieldConfig;
-
-  try {
-    const configPath = path.join(homedir(), ".shieldcortex", "config.json");
-    _shieldConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
-  } catch {
-    _shieldConfig = {};
-  }
-
-  return _shieldConfig;
-}
+const runtime = createOpenClawRuntime({ logPrefix: "[cortex-memory]" });
+const loadShieldConfig = runtime.loadShieldConfig;
+const callCortex = runtime.callCortex;
 
 async function isOpenClawAutoMemoryEnabled() {
   const config = await loadShieldConfig();
-  // Default OFF — OpenClaw has its own memory system. User must explicitly opt in.
-  return config?.openclawAutoMemory === true;
-}
-
-/**
- * Resolve the fastest way to invoke shieldcortex:
- * 1. ~/.shieldcortex/config.json "binaryPath" override
- * 2. Global install detected via `which shieldcortex`
- * 3. Fallback to `npx -y shieldcortex` (slow on ARM64)
- */
-let _resolvedServerCmd = null;
-
-async function resolveServerCmd() {
-  if (_resolvedServerCmd) return _resolvedServerCmd;
-
-  // 1. Check config for explicit binaryPath
-  try {
-    const config = await loadShieldConfig();
-    if (config?.binaryPath) {
-      await fs.access(config.binaryPath);
-      _resolvedServerCmd = config.binaryPath;
-      console.log(`[cortex-memory] Using configured binary: ${config.binaryPath}`);
-      return _resolvedServerCmd;
-    }
-  } catch { /* Config not found, no binaryPath, or path invalid */ }
-
-  // 2. Try to find global install via `which`
-  try {
-    const { execFileSync } = await import("node:child_process");
-    const bin = execFileSync("which", ["shieldcortex"], {
-      encoding: "utf-8",
-      timeout: 3000,
-    }).trim();
-    if (bin) {
-      _resolvedServerCmd = bin;
-      console.log(`[cortex-memory] Using global install: ${bin}`);
-      return _resolvedServerCmd;
-    }
-  } catch { /* Not in PATH */ }
-
-  // 3. Fall back to npx (slow but always works)
-  _resolvedServerCmd = "npx -y shieldcortex";
-  console.log("[cortex-memory] Falling back to npx -y shieldcortex (slow path)");
-  return _resolvedServerCmd;
-}
-
-// ==================== CORTEX MCP HELPER ====================
-
-let _lastCallErrorType = null;
-
-function classifyCallError(err) {
-  if (err.killed || err.code === "ETIMEDOUT" || err.signal === "SIGTERM") return "timeout";
-  if (/ENOENT|not found|command not found/i.test(err.message || "")) return "not-found";
-  if (/mcporter/i.test(err.message || "")) return "mcporter";
-  return "unknown";
-}
-
-/**
- * Call a ShieldCortex MCP tool via mcporter
- * @param {string} tool - Tool name (e.g., "remember", "recall", "get_context")
- * @param {Record<string, string>} args - Tool arguments as key:value pairs
- * @param {object} options - Options { retries: number, timeout: number }
- * @returns {Promise<string|null>} Raw stdout or null on error
- */
-async function callCortex(tool, args = {}, options = { retries: 1, timeout: 15000 }) {
-  const serverCmd = await resolveServerCmd();
-
-  return new Promise((resolve) => {
-    const cmdArgs = [
-      "mcporter", "call", "--stdio",
-      serverCmd,
-      tool,
-    ];
-    for (const [key, value] of Object.entries(args)) {
-      // Escape single quotes by doubling them (FTS5-safe)
-      const safe = String(value).replace(/'/g, "''");
-      cmdArgs.push(`${key}:${safe}`);
-    }
-
-    let attempts = 0;
-    const maxAttempts = (options.retries || 0) + 1;
-
-    function attempt() {
-      attempts++;
-      execFile("npx", cmdArgs, {
-        timeout: options.timeout || 15000,
-        maxBuffer: 1024 * 256,
-      }, (err, stdout) => {
-        if (err) {
-          // Distinguish timeout from other errors
-          const isTimeout = err.killed || err.code === "ETIMEDOUT" || err.signal === "SIGTERM";
-          const errorType = isTimeout ? "TIMEOUT" : "ERROR";
-
-          if (attempts < maxAttempts) {
-            console.warn(`[cortex-memory] ${errorType} on ${tool} (attempt ${attempts}/${maxAttempts}), retrying...`);
-            setTimeout(attempt, 1000); // 1s delay before retry
-            return;
-          }
-
-          // One-time categorised warning per error type (prevents spam)
-          const category = classifyCallError(err);
-          if (category !== _lastCallErrorType) {
-            _lastCallErrorType = category;
-            switch (category) {
-              case "timeout":
-                console.warn("[cortex-memory] ShieldCortex call timed out (15s). Memory may be under heavy load.");
-                break;
-              case "not-found":
-                console.warn("[cortex-memory] ShieldCortex binary not found. Run: npm install -g shieldcortex");
-                break;
-              case "mcporter":
-                console.warn("[cortex-memory] mcporter failed to reach ShieldCortex MCP server. Is it configured?");
-                break;
-              default:
-                console.warn(`[cortex-memory] ShieldCortex call failed: ${err.message}`);
-            }
-          }
-          resolve(null);
-          return;
-        }
-        resolve(stdout?.trim() || null);
-      });
-    }
-
-    attempt();
-  });
+  return runtime.isOpenClawAutoMemoryEnabled(config);
 }
 
 // ==================== NOVELTY / DEDUPE GATE ====================

package/hooks/openclaw/cortex-memory/runtime.mjs

@@ -0,0 +1,129 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export function createOpenClawRuntime({ logPrefix = "[shieldcortex]" } = {}) {
+  let shieldConfig = null;
+  let resolvedServerCmd = null;
+  let lastCallErrorType = null;
+
+  async function loadShieldConfig() {
+    if (shieldConfig) return shieldConfig;
+
+    try {
+      const configPath = path.join(homedir(), ".shieldcortex", "config.json");
+      shieldConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+    } catch {
+      shieldConfig = {};
+    }
+
+    return shieldConfig;
+  }
+
+  function isOpenClawAutoMemoryEnabled(config) {
+    return config?.openclawAutoMemory === true;
+  }
+
+  function classifyCallError(err) {
+    if (err.killed || err.code === "ETIMEDOUT" || err.signal === "SIGTERM") return "timeout";
+    if (/ENOENT|not found|command not found/i.test(err.message || "")) return "not-found";
+    if (/mcporter/i.test(err.message || "")) return "mcporter";
+    return "unknown";
+  }
+
+  async function resolveServerCmd() {
+    if (resolvedServerCmd) return resolvedServerCmd;
+
+    try {
+      const config = await loadShieldConfig();
+      if (config?.binaryPath) {
+        await fs.access(config.binaryPath);
+        resolvedServerCmd = config.binaryPath;
+        console.log(`${logPrefix} Using configured binary: ${config.binaryPath}`);
+        return resolvedServerCmd;
+      }
+    } catch {}
+
+    try {
+      const { execFileSync } = await import("node:child_process");
+      const bin = execFileSync("which", ["shieldcortex"], {
+        encoding: "utf-8",
+        timeout: 3000,
+      }).trim();
+      if (bin) {
+        resolvedServerCmd = bin;
+        console.log(`${logPrefix} Using global install: ${bin}`);
+        return resolvedServerCmd;
+      }
+    } catch {}
+
+    resolvedServerCmd = "npx -y shieldcortex";
+    console.log(`${logPrefix} Falling back to npx -y shieldcortex (slow path)`);
+    return resolvedServerCmd;
+  }
+
+  async function callCortex(tool, args = {}, options = { retries: 0, timeout: 15000 }) {
+    const serverCmd = await resolveServerCmd();
+
+    return new Promise((resolve) => {
+      const cmdArgs = ["mcporter", "call", "--stdio", serverCmd, tool];
+      for (const [key, value] of Object.entries(args)) {
+        cmdArgs.push(`${key}:${String(value).replace(/'/g, "''")}`);
+      }
+
+      let attempts = 0;
+      const maxAttempts = (options.retries || 0) + 1;
+
+      function attempt() {
+        attempts++;
+        execFile("npx", cmdArgs, {
+          timeout: options.timeout || 15000,
+          maxBuffer: 256 * 1024,
+        }, (err, stdout) => {
+          if (err) {
+            const isTimeout = err.killed || err.code === "ETIMEDOUT" || err.signal === "SIGTERM";
+            const errorType = isTimeout ? "TIMEOUT" : "ERROR";
+
+            if (attempts < maxAttempts) {
+              console.warn(`${logPrefix} ${errorType} on ${tool} (attempt ${attempts}/${maxAttempts}), retrying...`);
+              setTimeout(attempt, 1000);
+              return;
+            }
+
+            const category = classifyCallError(err);
+            if (category !== lastCallErrorType) {
+              lastCallErrorType = category;
+              switch (category) {
+                case "timeout":
+                  console.warn(`${logPrefix} ShieldCortex call timed out (15s). Memory may be under heavy load.`);
+                  break;
+                case "not-found":
+                  console.warn(`${logPrefix} ShieldCortex binary not found. Run: npm install -g shieldcortex`);
+                  break;
+                case "mcporter":
+                  console.warn(`${logPrefix} mcporter failed to reach ShieldCortex MCP server. Is it configured?`);
+                  break;
+                default:
+                  console.warn(`${logPrefix} ShieldCortex call failed: ${err.message}`);
+              }
+            }
+            resolve(null);
+            return;
+          }
+
+          resolve(stdout?.trim() || null);
+        });
+      }
+
+      attempt();
+    });
+  }
+
+  return {
+    callCortex,
+    isOpenClawAutoMemoryEnabled,
+    loadShieldConfig,
+    resolveServerCmd,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Persistent brain for AI agents. Knowledge graphs, memory decay, contradiction detection, Iron Dome behaviour protection — plus the only defence pipeline that stops memory poisoning. Works with Claude Code, OpenClaw, LangChain, and any MCP agent.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,7 +39,7 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
     "build": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json && cp plugins/openclaw/openclaw.plugin.json plugins/openclaw/dist/",
-    "build:dashboard": "cd dashboard && npm run build && (cp -r .next/static .next/standalone/dashboard/.next/ 2>/dev/null || true) && (cp -r public .next/standalone/dashboard/ 2>/dev/null || true)",
+    "build:dashboard": "cd dashboard && npm run build && (cp -r .next/static .next/standalone/dashboard/.next/ 2>/dev/null || true) && (cp -r public .next/standalone/dashboard/ 2>/dev/null || true) && cd .. && node scripts/prune-dashboard-standalone.mjs",
     "build:all": "npm run build && npm run build:dashboard",
     "start": "node dist/index.js",
     "start:api": "node dist/index.js --mode api",
@@ -123,8 +123,12 @@
     "dist",
     "hooks/openclaw",
     "plugins/openclaw/dist",
-    "scripts/*.mjs",
-    "scripts/*.sh",
+    "scripts/postinstall.mjs",
+    "scripts/pre-compact-hook.mjs",
+    "scripts/run-jest.mjs",
+    "scripts/session-end-hook.mjs",
+    "scripts/session-start-hook.mjs",
+    "scripts/stop-hook.mjs",
     "dashboard/.next/standalone"
   ]
 }

package/plugins/openclaw/dist/index.js

@@ -4,61 +4,27 @@
  * Hooks into llm_input/llm_output for real-time defence scanning
  * and optional memory extraction. All operations are fire-and-forget.
  */
-import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { homedir } from "node:os";
+import { createOpenClawRuntime } from "../../../hooks/openclaw/cortex-memory/runtime.mjs";
 let _config = null;
+const runtime = createOpenClawRuntime({ logPrefix: "[shieldcortex]" });
 async function loadConfig() {
     if (_config)
         return _config;
-    try {
-        _config = JSON.parse(await fs.readFile(path.join(homedir(), ".shieldcortex", "config.json"), "utf-8"));
-    }
-    catch {
-        _config = {};
-    }
+    _config = await runtime.loadShieldConfig();
     return _config;
 }
 function isAutoMemoryEnabled(config) {
-    return config.openclawAutoMemory === true;
+    return runtime.isOpenClawAutoMemoryEnabled(config);
 }
 function isAutoMemoryDedupeEnabled(config) {
     return config.openclawAutoMemoryDedupe !== false;
 }
-// ==================== SERVER CMD ====================
-let _serverCmd = null;
-async function resolveServerCmd() {
-    if (_serverCmd)
-        return _serverCmd;
-    const config = await loadConfig();
-    if (config.binaryPath) {
-        try {
-            await fs.access(config.binaryPath);
-            return (_serverCmd = config.binaryPath);
-        }
-        catch { }
-    }
-    try {
-        const { execFileSync } = await import("node:child_process");
-        const bin = execFileSync("which", ["shieldcortex"], { encoding: "utf-8", timeout: 3000 }).trim();
-        if (bin)
-            return (_serverCmd = bin);
-    }
-    catch { }
-    return (_serverCmd = "npx -y shieldcortex");
-}
-// ==================== MCP HELPER ====================
 function callCortex(tool, args = {}) {
-    return resolveServerCmd().then(serverCmd => new Promise(resolve => {
-        const cmdArgs = ["mcporter", "call", "--stdio", serverCmd, tool];
-        for (const [k, v] of Object.entries(args))
-            cmdArgs.push(`${k}:${String(v).replace(/'/g, "''")}`);
-        execFile("npx", cmdArgs, { timeout: 15000, maxBuffer: 256 * 1024 }, (err, stdout) => {
-            resolve(err ? null : stdout?.trim() || null);
-        });
-    }));
+    return runtime.callCortex(tool, args);
 }
 // ==================== DEFENCE PIPELINE ====================
 let _pipeline = null;

package/scripts/run-jest.mjs

@@ -4,27 +4,51 @@ import { spawn } from 'child_process';
 import path from 'path';
 
 const jestBin = path.join(process.cwd(), 'node_modules', 'jest', 'bin', 'jest.js');
+const localStorageFile = path.join(process.cwd(), '.jest-localstorage');
 
 function sanitizeNodeOptions(value) {
   if (!value) return undefined;
 
   const cleaned = value
     .replace(/(?:^|\s)--localstorage-file(?:=\S+)?(?=\s|$)/g, ' ')
+    .replace(/(?:^|\s)--disable-warning(?:=\S+)?(?=\s|$)/g, ' ')
     .replace(/\s+/g, ' ')
     .trim();
 
   return cleaned || undefined;
 }
 
+function appendNodeOption(existing, option) {
+  return existing ? `${existing} ${option}` : option;
+}
+
 const env = { ...process.env, SHIELDCORTEX_SKIP_EMBEDDINGS: '1' };
 delete env.ELECTRON_RUN_AS_NODE;
 
-const sanitizedNodeOptions = sanitizeNodeOptions(env.NODE_OPTIONS);
+const combinedNodeOptions = [env.NODE_OPTIONS, env.npm_config_node_options]
+  .filter(Boolean)
+  .join(' ')
+  .trim();
+
+let sanitizedNodeOptions = sanitizeNodeOptions(combinedNodeOptions);
+
+if (process.allowedNodeEnvironmentFlags.has('--localstorage-file')) {
+  sanitizedNodeOptions = appendNodeOption(
+    sanitizedNodeOptions,
+    `--localstorage-file=${JSON.stringify(localStorageFile)}`,
+  );
+}
+
+if (process.allowedNodeEnvironmentFlags.has('--disable-warning')) {
+  sanitizedNodeOptions = appendNodeOption(sanitizedNodeOptions, '--disable-warning=ExperimentalWarning');
+}
+
 if (sanitizedNodeOptions) {
   env.NODE_OPTIONS = sanitizedNodeOptions;
 } else {
   delete env.NODE_OPTIONS;
 }
+delete env.npm_config_node_options;
 
 const child = spawn(
   process.execPath,