wolverine-ai 1.3.0 → 1.4.0

package/README.md

@@ -74,6 +74,7 @@ wolverine/
 │   │   ├── models.js        ← 10-model configuration system
 │   │   ├── verifier.js      ← Fix verification (syntax + boot probe)
 │   │   ├── error-parser.js  ← Stack trace parsing + error classification
+│   │   ├── error-hook.js   ← Auto-injected into child (IPC error reporting)
 │   │   ├── patcher.js       ← File patching with sandbox
 │   │   ├── health-monitor.js← PM2-style health checks
 │   │   ├── config.js        ← Config loader (settings.json + env)
@@ -105,7 +106,8 @@ wolverine/
 │   ├── monitor/             ← Performance + process management
 │   │   ├── perf-monitor.js  ← Endpoint response times + spam detection
 │   │   ├── process-monitor.js← Memory/CPU/heartbeat + leak detection
-│   │   └── route-prober.js  ← Auto-discovers and tests all routes
+│   │   ├── route-prober.js  ← Auto-discovers and tests all routes
+│   │   └── error-monitor.js ← Caught 500 error detection (no-crash healing)
 │   ├── dashboard/           ← Web UI
 │   │   └── server.js        ← Real-time dashboard + command interface
 │   ├── notifications/       ← Alerts
@@ -176,6 +178,26 @@ After fix:
   → Promote backup to stable after 30min uptime
 ```
 
+### Caught Error Healing (No-Crash)
+
+Most production bugs don't crash the process — Fastify/Express catch them and return 500. Wolverine now detects these too:
+
+```
+Route returns 500 (process still alive)
+  → Error hook reports to parent via IPC (auto-injected, zero user code changes)
+  → ErrorMonitor tracks consecutive 500s per route
+  → 3 failures in 30s → triggers heal pipeline (same as crash healing)
+  → Fix applied → server restarted → route prober verifies fix
+```
+
+| Setting | Default | Env Variable |
+|---------|---------|-------------|
+| Failure threshold | 3 | `WOLVERINE_ERROR_THRESHOLD` |
+| Time window | 30s | `WOLVERINE_ERROR_WINDOW_MS` |
+| Cooldown per route | 60s | `WOLVERINE_ERROR_COOLDOWN_MS` |
+
+The error hook auto-patches Fastify and Express via `--require` preload. No middleware, no code changes to your server.
+
 ---
 
 ## Agent Tool Harness

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {

package/src/brain/brain.js

@@ -211,6 +211,10 @@ const SEED_DOCS = [
     text: "Agent fix strategy table: the agent system prompt includes a decision table mapping error patterns to correct fix actions. Cannot find module 'X' (package) → bash_exec: npm install X. Cannot find module './X' (local) → edit_file: fix require path. ENOENT → write_file: create missing file. EACCES → bash_exec: chmod. EADDRINUSE → bash_exec: kill process. SyntaxError → edit_file: fix code. TypeError → edit_file: fix logic. MODULE_NOT_FOUND + node_modules → bash_exec: rm -rf node_modules && npm install. The fast path AI response format now supports both 'changes' (code edits) and 'commands' (shell commands like npm install). Dangerous commands blocked: rm -rf /, format, mkfs.",
     metadata: { topic: "agent-fix-strategy" },
   },
+  {
+    text: "Error Monitor: detects caught 500 errors that don't crash the process. Most production bugs are caught by Fastify/Express error handlers — the server stays alive but routes return 500. Wolverine's crash-based heal pipeline never triggers for these. ErrorMonitor tracks 5xx errors per route via IPC from child process. After N consecutive 500s within a time window (default: 3 failures in 30s), triggers the heal pipeline without killing the server. Error hook auto-injected via --require preload (no user code changes). Cooldown prevents heal spam (default: 60s per route). Stats available in dashboard and telemetry. Config: WOLVERINE_ERROR_THRESHOLD, WOLVERINE_ERROR_WINDOW_MS, WOLVERINE_ERROR_COOLDOWN_MS.",
+    metadata: { topic: "error-monitor" },
+  },
 ];
 
 class Brain {

package/src/core/error-hook.js

@@ -0,0 +1,127 @@
+/**
+ * Error Hook — preloaded into the child server process via --require.
+ *
+ * Patches Fastify and Express error handlers to report caught errors
+ * back to the Wolverine parent process via IPC. This enables healing
+ * of 500 errors that don't crash the process.
+ *
+ * How it works:
+ * 1. Runner spawns child with: node --require ./src/core/error-hook.js server/index.js
+ * 2. This file hooks into Module._load to intercept fastify/express creation
+ * 3. When a framework instance is created, we add an error handler that sends IPC messages
+ * 4. Parent's ErrorMonitor receives the messages and triggers heal after threshold
+ *
+ * Zero changes to user's server code.
+ */
+
+const Module = require("module");
+const originalLoad = Module._load;
+
+let _hooked = false;
+
+Module._load = function (request, parent, isMain) {
+  const result = originalLoad.apply(this, arguments);
+
+  // Hook Fastify
+  if (request === "fastify" && typeof result === "function" && !_hooked) {
+    const originalFastify = result;
+    const wrapped = function (...args) {
+      const instance = originalFastify(...args);
+      _hookFastify(instance);
+      return instance;
+    };
+    // Preserve all properties (fastify.default, etc.)
+    Object.keys(originalFastify).forEach((key) => {
+      wrapped[key] = originalFastify[key];
+    });
+    _hooked = true;
+    return wrapped;
+  }
+
+  // Hook Express
+  if (request === "express" && typeof result === "function" && !_hooked) {
+    const originalExpress = result;
+    const wrapped = function (...args) {
+      const app = originalExpress(...args);
+      _hookExpress(app);
+      return app;
+    };
+    Object.keys(originalExpress).forEach((key) => {
+      wrapped[key] = originalExpress[key];
+    });
+    _hooked = true;
+    return wrapped;
+  }
+
+  return result;
+};
+
+function _hookFastify(fastify) {
+  // Use onReady to add hooks after all plugins are loaded
+  fastify.addHook("onReady", function (done) {
+    // Add a global error handler that reports to parent
+    fastify.addHook("onError", function (request, reply, error, done) {
+      _reportError(request.url, request.method, error);
+      done();
+    });
+    done();
+  });
+
+  // Also intercept the setErrorHandler if user sets one
+  const originalSetError = fastify.setErrorHandler.bind(fastify);
+  fastify.setErrorHandler = function (handler) {
+    return originalSetError(function (error, request, reply) {
+      _reportError(request.url, request.method, error);
+      return handler(error, request, reply);
+    });
+  };
+}
+
+function _hookExpress(app) {
+  // For Express, we monkey-patch app.use to detect error middleware
+  // and also add our own at the end via a delayed hook
+  const originalListen = app.listen.bind(app);
+  app.listen = function (...args) {
+    // Add our error handler AFTER all user middleware
+    app.use(function wolverineErrorHandler(err, req, res, next) {
+      _reportError(req.originalUrl || req.url, req.method, err);
+      next(err);
+    });
+    return originalListen(...args);
+  };
+}
+
+function _reportError(url, method, error) {
+  if (!process.send) return; // No IPC channel — not spawned by wolverine
+
+  try {
+    // Extract file/line from stack trace
+    let file = null;
+    let line = null;
+    if (error && error.stack) {
+      const stackLines = error.stack.split("\n");
+      for (const sl of stackLines) {
+        const match = sl.match(/\(([^)]+):(\d+):(\d+)\)/) || sl.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+        if (match && !match[1].includes("node_modules") && !match[1].includes("node:")) {
+          file = match[1];
+          line = parseInt(match[2], 10);
+          break;
+        }
+      }
+    }
+
+    process.send({
+      type: "route_error",
+      path: url,
+      method: method || "GET",
+      statusCode: 500,
+      message: error?.message || "Unknown error",
+      stack: error?.stack?.slice(0, 2000) || "",
+      file,
+      line,
+      timestamp: Date.now(),
+    });
+  } catch {
+    // Silently fail — don't break the server for IPC issues
+  }
+}

package/src/core/runner.js

@@ -20,6 +20,7 @@ const { ProcessMonitor } = require("../monitor/process-monitor");
 const { RouteProber } = require("../monitor/route-prober");
 const { startHeartbeat, stopHeartbeat } = require("../platform/heartbeat");
 const { Notifier } = require("../notifications/notifier");
+const { ErrorMonitor } = require("../monitor/error-monitor");
 
 /**
  * The Wolverine process runner — v3.
@@ -90,6 +91,15 @@ class WolverineRunner {
       brain: this.brain,
     });
 
+    // Error monitor — detects caught 500 errors without process crash
+    this.errorMonitor = new ErrorMonitor({
+      threshold: parseInt(process.env.WOLVERINE_ERROR_THRESHOLD, 10) || 3,
+      windowMs: parseInt(process.env.WOLVERINE_ERROR_WINDOW_MS, 10) || 30000,
+      cooldownMs: parseInt(process.env.WOLVERINE_ERROR_COOLDOWN_MS, 10) || 60000,
+      logger: this.logger,
+      onError: (routePath, errorDetails) => this._healFromError(routePath, errorDetails),
+    });
+
     // Brain — semantic memory + project context
     this.brain = new Brain(this.cwd);
 
@@ -120,6 +130,7 @@ class WolverineRunner {
       repairHistory: this.repairHistory,
       processMonitor: this.processMonitor,
       routeProber: this.routeProber,
+      errorMonitor: this.errorMonitor,
     });
 
     // Stability tracking
@@ -287,10 +298,13 @@ class WolverineRunner {
     this._stderrBuffer = "";
     this._lastStartTime = Date.now();
 
-    this.child = spawn("node", [this.scriptPath], {
+    // Spawn with --require error-hook.js for IPC error reporting
+    // The error hook auto-patches Fastify/Express to report caught 500s
+    const errorHookPath = path.join(__dirname, "error-hook.js");
+    this.child = spawn("node", ["--require", errorHookPath, this.scriptPath], {
       cwd: this.cwd,
       env: { ...process.env },
-      stdio: ["inherit", "inherit", "pipe"],
+      stdio: ["inherit", "inherit", "pipe", "ipc"],
     });
 
     this.child.stderr.on("data", (data) => {
@@ -367,6 +381,30 @@ class WolverineRunner {
       this.logger.error(EVENT_TYPES.PROCESS_CRASH, `Failed to start: ${err.message}`);
       this.running = false;
     });
+
+    // IPC channel: child reports caught 500 errors (Fastify/Express)
+    this.child.on("message", (msg) => {
+      if (msg && msg.type === "route_error") {
+        const { redact } = require("../security/secret-redactor");
+        const safeMsg = redact(msg.message || "");
+        const safeStack = redact(msg.stack || "");
+        console.log(chalk.yellow(`  🔍 Caught error on ${msg.method} ${msg.path}: ${safeMsg.slice(0, 100)}`));
+        this.logger.warn("error_monitor.caught", `${msg.method} ${msg.path} → 500: ${safeMsg.slice(0, 200)}`, {
+          route: msg.path, method: msg.method, file: msg.file, line: msg.line,
+        });
+        this.errorMonitor.record(msg.path, msg.statusCode || 500, {
+          message: safeMsg,
+          stack: safeStack,
+          file: msg.file,
+          line: msg.line,
+          path: msg.path,
+          method: msg.method,
+        });
+      }
+    });
+
+    // Reset error monitor on new spawn
+    this.errorMonitor.reset();
   }
 
   async _healAndRestart() {
@@ -432,6 +470,55 @@ class WolverineRunner {
     }
   }
 
+  /**
+   * Heal from a caught 500 error (ErrorMonitor threshold reached).
+   * Unlike crash healing, the server is still running — we heal and restart.
+   */
+  async _healFromError(routePath, errorDetails) {
+    if (this._healInProgress || this._shuttingDown) return;
+    this._healInProgress = true;
+
+    console.log(chalk.yellow(`\n🐺 Wolverine healing caught error on ${routePath}...`));
+    this.logger.info("heal.error_monitor", `Healing caught 500 on ${routePath}`, { route: routePath });
+
+    // Build a synthetic stderr from the error details
+    const stderr = [
+      errorDetails.message || "Unknown error",
+      errorDetails.stack || "",
+      errorDetails.file ? `    at ${errorDetails.file}:${errorDetails.line || 0}` : "",
+    ].filter(Boolean).join("\n");
+
+    try {
+      const result = await heal({
+        stderr,
+        cwd: this.cwd,
+        sandbox: this.sandbox,
+        redactor: this.redactor,
+        notifier: this.notifier,
+        rateLimiter: this.rateLimiter,
+        backupManager: this.backupManager,
+        logger: this.logger,
+        brain: this.brain,
+        mcp: this.mcp,
+        skills: this.skills,
+        repairHistory: this.repairHistory,
+      });
+
+      if (result.healed) {
+        console.log(chalk.green(`\n🐺 Wolverine healed ${routePath} via ${result.mode}! Restarting...\n`));
+        this.errorMonitor.clearRoute(routePath);
+        this._healInProgress = false;
+        this.restart();
+      } else {
+        console.log(chalk.red(`\n🐺 Could not heal ${routePath}: ${result.explanation}`));
+        this._healInProgress = false;
+      }
+    } catch (err) {
+      console.log(chalk.red(`\n🐺 Error during heal: ${err.message}`));
+      this._healInProgress = false;
+    }
+  }
+
   _startStabilityTimer() {
     this._clearStabilityTimer();
     this._stabilityTimer = setTimeout(() => {

package/src/dashboard/server.js

@@ -29,6 +29,7 @@ class DashboardServer {
     this.repairHistory = options.repairHistory;
     this.processMonitor = options.processMonitor;
     this.routeProber = options.routeProber;
+    this.errorMonitor = options.errorMonitor;
 
     this.auth = new AdminAuth();
     this._sseClients = new Set();
@@ -869,6 +870,7 @@ ${context ? "\nBrain:\n" + context : ""}`,
       session: this.logger ? this.logger.getSessionStats() : {},
       backups: this.backupManager ? this.backupManager.getStats() : {},
       health: this.healthMonitor ? this.healthMonitor.getStats() : {},
+      errorMonitor: this.errorMonitor ? this.errorMonitor.getStats() : {},
     }));
   }
 

package/src/index.js

@@ -23,6 +23,7 @@ const { spawnAgent, spawnParallel, exploreAndFix } = require("./agent/sub-agents
 const { McpRegistry } = require("./mcp/mcp-registry");
 const { McpSecurity } = require("./mcp/mcp-security");
 const { PerfMonitor } = require("./monitor/perf-monitor");
+const { ErrorMonitor } = require("./monitor/error-monitor");
 const { DashboardServer } = require("./dashboard/server");
 const { Notifier } = require("./notifications/notifier");
 const { Brain } = require("./brain/brain");
@@ -72,6 +73,7 @@ module.exports = {
   McpSecurity,
   // Monitor
   PerfMonitor,
+  ErrorMonitor,
   // Dashboard
   DashboardServer,
   // Notifications

package/src/monitor/error-monitor.js

@@ -0,0 +1,121 @@
+const chalk = require("chalk");
+
+/**
+ * Error Monitor — detects caught 500 errors that don't crash the process.
+ *
+ * Most production bugs are caught by Fastify/Express error handlers.
+ * The server stays alive but routes return 500. Wolverine's crash-based
+ * heal pipeline never triggers. This module bridges that gap.
+ *
+ * Tracks 5xx errors per route. After N consecutive failures within
+ * a time window, triggers the heal pipeline — without killing the server.
+ *
+ * Error flow: server error handler → IPC message → ErrorMonitor.record()
+ *   → threshold reached → onError callback → heal()
+ */
+
+class ErrorMonitor {
+  constructor({ threshold = 3, windowMs = 30000, cooldownMs = 60000, onError, logger } = {}) {
+    this.threshold = threshold;     // consecutive 5xx before triggering heal
+    this.windowMs = windowMs;       // time window for counting errors
+    this.cooldownMs = cooldownMs;   // cooldown after triggering (prevent heal spam)
+    this.onError = onError;         // callback: (routePath, errorDetails) => heal()
+    this.logger = logger;
+    this.routes = new Map();        // path → { count, firstSeen, lastError }
+    this._cooldowns = new Map();    // path → timestamp of last heal trigger
+    this._totalErrors = 0;
+    this._totalHeals = 0;
+  }
+
+  /**
+   * Record a route response. Call on every response from the child.
+   * @param {string} routePath — e.g. "/api/users"
+   * @param {number} statusCode — HTTP status
+   * @param {object} errorDetails — { message, stack, file, line }
+   */
+  record(routePath, statusCode, errorDetails) {
+    if (statusCode < 500) {
+      // Success — reset the error counter for this route
+      if (this.routes.has(routePath)) {
+        this.routes.delete(routePath);
+      }
+      return;
+    }
+
+    this._totalErrors++;
+
+    // Check cooldown — don't trigger heal for same route too quickly
+    const lastHeal = this._cooldowns.get(routePath);
+    if (lastHeal && Date.now() - lastHeal < this.cooldownMs) {
+      return;
+    }
+
+    const entry = this.routes.get(routePath) || { count: 0, firstSeen: Date.now(), lastError: null };
+    entry.count++;
+    entry.lastError = errorDetails;
+
+    // Reset if outside time window
+    if (Date.now() - entry.firstSeen > this.windowMs) {
+      entry.count = 1;
+      entry.firstSeen = Date.now();
+    }
+
+    this.routes.set(routePath, entry);
+
+    if (entry.count >= this.threshold) {
+      this._totalHeals++;
+      console.log(chalk.yellow(`\n🔍 ErrorMonitor: ${routePath} failed ${entry.count}x in ${Math.round((Date.now() - entry.firstSeen) / 1000)}s — triggering heal`));
+
+      if (this.logger) {
+        this.logger.warn("error_monitor.threshold", `Route ${routePath} hit ${this.threshold} consecutive 500s`, {
+          route: routePath,
+          count: entry.count,
+          error: errorDetails?.message?.slice(0, 200),
+        });
+      }
+
+      // Set cooldown and reset counter
+      this._cooldowns.set(routePath, Date.now());
+      this.routes.delete(routePath);
+
+      // Trigger the heal callback
+      if (this.onError) {
+        this.onError(routePath, errorDetails);
+      }
+    }
+  }
+
+  /**
+   * Clear a route's error state (e.g., after a successful heal).
+   */
+  clearRoute(routePath) {
+    this.routes.delete(routePath);
+    this._cooldowns.delete(routePath);
+  }
+
+  /**
+   * Get stats for dashboard/telemetry.
+   */
+  getStats() {
+    const activeRoutes = {};
+    for (const [path, entry] of this.routes) {
+      activeRoutes[path] = { count: entry.count, lastError: entry.lastError?.message?.slice(0, 100) };
+    }
+    return {
+      totalErrors: this._totalErrors,
+      totalHeals: this._totalHeals,
+      activeRoutes,
+      trackedRoutes: this.routes.size,
+    };
+  }
+
+  /**
+   * Reset all state (e.g., after server restart).
+   */
+  reset() {
+    this.routes.clear();
+    // Keep cooldowns — don't re-trigger immediately after restart
+  }
+}
+
+module.exports = { ErrorMonitor };