shieldcortex 3.0.2 → 3.0.4

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.2",
+  "version": "3.0.4",
   "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,