wolverine-ai 1.5.0 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "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/server/config/settings.json

@@ -47,6 +47,12 @@
     "startDelayMs": 10000
   },
 
+  "errorMonitor": {
+    "defaultThreshold": 3,
+    "windowMs": 30000,
+    "cooldownMs": 60000
+  },
+
   "dashboard": {},
 
   "cors": {

package/server/index.js

@@ -19,10 +19,38 @@ fastify.setNotFoundHandler((req, reply) => {
   reply.code(404).send({ error: "Not found", path: req.url });
 });
 
-// Error handler
+// Error handler — reports to Wolverine parent via IPC for auto-healing
 fastify.setErrorHandler((err, req, reply) => {
   console.error(`[ERROR] ${err.message}`);
-  reply.code(500).send({ error: "Internal server error" });
+  reply.code(500).send({ error: err.message });
+
+  // Report to Wolverine via IPC (if running under wolverine)
+  if (typeof process.send === "function") {
+    try {
+      // Extract file/line from stack trace
+      let file = null, line = null;
+      if (err.stack) {
+        const frames = err.stack.split("\n");
+        for (const frame of frames) {
+          const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+          if (m && !m[1].includes("node_modules") && !m[1].includes("node:")) {
+            file = m[1]; line = parseInt(m[2], 10); break;
+          }
+        }
+      }
+      process.send({
+        type: "route_error",
+        path: req.url,
+        method: req.method,
+        statusCode: 500,
+        message: err.message,
+        stack: err.stack,
+        file,
+        line,
+        timestamp: Date.now(),
+      });
+    } catch (_) { /* IPC send failed — non-fatal */ }
+  }
 });
 
 fastify.listen({ port: PORT, host: "0.0.0.0" }, (err) => {

package/src/core/ai-client.js

@@ -335,7 +335,7 @@ async function _chatCallWithHistory(openai, { model, messages, tools, maxTokens
  * Send an error context to OpenAI and get a repair patch back.
  * Uses CODING_MODEL — routes to correct API automatically.
  */
-async function requestRepair({ filePath, sourceCode, errorMessage, stackTrace }) {
+async function requestRepair({ filePath, sourceCode, backupSourceCode, errorMessage, stackTrace }) {
   const model = getModel("coding");
 
   const systemPrompt = "You are a Node.js debugging expert. Respond with ONLY valid JSON, no markdown fences.";
@@ -357,7 +357,7 @@ ${errorMessage}
 ${stackTrace}
 \`\`\`
 
-## Instructions
+${backupSourceCode ? `## Last Known Working Version\n\`\`\`javascript\n${backupSourceCode}\n\`\`\`\n\nCompare the current broken code with this working version. If the broken code added something that doesn't work, REVERT that addition rather than patching around it.\n` : ""}## Instructions
 1. Identify the root cause of the error.
 2. Not all errors are code bugs. Choose the correct fix type:
    - "Cannot find module 'X'" (not starting with ./ or ../) = missing npm package → use "commands" to npm install

package/src/core/error-hook.js

@@ -1,55 +1,54 @@
 /**
  * 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.
+ * Safety net: patches Fastify and Express to report caught errors
+ * via IPC to the Wolverine parent process. Works even if the user's
+ * server code doesn't call process.send() in its error handler.
  *
  * 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
+ * 1. Runner spawns: node --require error-hook.js server/index.js
+ * 2. This file intercepts require("fastify") and require("express")
+ * 3. Wraps the constructor to add an onError hook (Fastify) or
+ *    error middleware (Express) that sends IPC messages
+ * 4. Parent's ErrorMonitor receives messages and triggers heal
  *
- * Zero changes to user's server code.
+ * If the server already reports errors via process.send(), the hook
+ * deduplicates by checking a timestamp flag on the error object.
  */
 
 const Module = require("module");
 const originalLoad = Module._load;
 
-let _hooked = false;
+let _fastifyHooked = false;
+let _expressHooked = false;
 
 Module._load = function (request, parent, isMain) {
   const result = originalLoad.apply(this, arguments);
 
   // Hook Fastify
-  if (request === "fastify" && typeof result === "function" && !_hooked) {
+  if (request === "fastify" && typeof result === "function" && !_fastifyHooked) {
+    _fastifyHooked = true;
     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;
+    Object.keys(originalFastify).forEach((key) => { wrapped[key] = originalFastify[key]; });
+    wrapped.default = wrapped; // ESM compat
     return wrapped;
   }
 
   // Hook Express
-  if (request === "express" && typeof result === "function" && !_hooked) {
+  if (request === "express" && typeof result === "function" && !_expressHooked) {
+    _expressHooked = true;
     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;
+    Object.keys(originalExpress).forEach((key) => { wrapped[key] = originalExpress[key]; });
     return wrapped;
   }
 
@@ -57,55 +56,51 @@ Module._load = function (request, parent, isMain) {
 };
 
 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) {
+  // Wrap setErrorHandler so our IPC reporting runs BEFORE the user's handler
+  const origSetError = fastify.setErrorHandler;
+  fastify.setErrorHandler = function (userHandler) {
+    return origSetError.call(this, function (error, request, reply) {
       _reportError(request.url, request.method, error);
-      done();
+      return userHandler.call(this, error, request, reply);
     });
-    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) {
+  // Also add onError hook as a fallback (fires even if no custom error handler)
+  try {
+    fastify.addHook("onError", function (request, reply, error, done) {
       _reportError(request.url, request.method, error);
-      return handler(error, request, reply);
+      done();
     });
-  };
+  } catch { /* addHook may fail if server is already started */ }
 }
 
 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);
+  // Wrap app.listen to inject error middleware AFTER all user middleware
+  const originalListen = app.listen;
   app.listen = function (...args) {
-    // Add our error handler AFTER all user middleware
-    app.use(function wolverineErrorHandler(err, req, res, next) {
+    app.use(function _wolverineErrorHook(err, req, res, next) {
       _reportError(req.originalUrl || req.url, req.method, err);
       next(err);
     });
-    return originalListen(...args);
+    return originalListen.apply(this, args);
   };
 }
 
+// Dedup: skip if error was already reported in the same tick
+const _reported = new WeakSet();
+
 function _reportError(url, method, error) {
-  if (!process.send) return; // No IPC channel — not spawned by wolverine
+  if (typeof process.send !== "function") return;
+  if (!error || _reported.has(error)) return;
+  _reported.add(error);
 
   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;
+    let file = null, line = null;
+    if (error.stack) {
+      for (const frame of error.stack.split("\n")) {
+        const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+        if (m && !m[1].includes("node_modules") && !m[1].includes("node:")) {
+          file = m[1]; line = parseInt(m[2], 10); break;
         }
       }
     }
@@ -115,13 +110,11 @@ function _reportError(url, method, error) {
       path: url,
       method: method || "GET",
       statusCode: 500,
-      message: error?.message || "Unknown error",
-      stack: error?.stack?.slice(0, 2000) || "",
+      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
-  }
+  } catch { /* IPC send failed — non-fatal */ }
 }

package/src/core/runner.js

@@ -139,6 +139,7 @@ class WolverineRunner {
     this._stabilityTimer = null;
     this._stderrBuffer = "";
     this._healInProgress = false;
+    this._healStatus = null; // { active, file, error, phase, startedAt, iteration }
   }
 
   async start() {
@@ -410,6 +411,7 @@ class WolverineRunner {
   async _healAndRestart() {
     if (this._healInProgress) return;
     this._healInProgress = true;
+    this._healStatus = { active: true, error: this._stderrBuffer.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
 
     try {
       const result = await heal({
@@ -429,14 +431,23 @@ class WolverineRunner {
 
       if (result.healed) {
         this._lastBackupId = result.backupId;
-        const mode = result.mode === "agent" ? "multi-file agent" : "fast path";
+        this.retryCount = 0; // Fresh start after successful heal
+        const mode = result.mode === "agent" ? "multi-file agent" : result.mode || "fast path";
         console.log(chalk.green(`\n🐺 Wolverine healed the error via ${mode}! Restarting...\n`));
 
         if (result.agentStats) {
           console.log(chalk.gray(`   Agent stats: ${result.agentStats.turns} turns, ${result.agentStats.tokens} tokens, ${result.agentStats.filesModified.length} files modified`));
         }
 
+        // Broadcast heal success to dashboard SSE
+        if (this.logger) {
+          this.logger.info("heal.success", `Healed via ${mode}: ${result.explanation?.slice(0, 100)}`, {
+            mode, file: result.agentStats?.filesModified?.[0], duration: Date.now() - (this._healStatus?.startedAt || Date.now()),
+          });
+        }
+
         this._healInProgress = false;
+        this._healStatus = null;
         this._spawn();
       } else {
         console.log(chalk.red(`\n🐺 Wolverine could not heal: ${result.explanation}`));
@@ -479,6 +490,7 @@ class WolverineRunner {
     this._healInProgress = true;
 
     console.log(chalk.yellow(`\n🐺 Wolverine healing caught error on ${routePath}...`));
+    this._healStatus = { active: true, route: routePath, error: errorDetails?.message?.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
     this.logger.info("heal.error_monitor", `Healing caught 500 on ${routePath}`, { route: routePath });
 
     // Build a synthetic stderr from the error details
@@ -506,16 +518,28 @@ class WolverineRunner {
 
       if (result.healed) {
         console.log(chalk.green(`\n🐺 Wolverine healed ${routePath} via ${result.mode}! Restarting...\n`));
+        this.retryCount = 0; // Fresh start after successful heal
         this.errorMonitor.clearRoute(routePath);
+
+        // Broadcast heal success to dashboard SSE
+        if (this.logger) {
+          this.logger.info("heal.success", `Healed ${routePath} via ${result.mode}: ${result.explanation?.slice(0, 100)}`, {
+            mode: result.mode, route: routePath, duration: Date.now() - (this._healStatus?.startedAt || Date.now()),
+          });
+        }
+
         this._healInProgress = false;
+        this._healStatus = null;
         this.restart();
       } else {
         console.log(chalk.red(`\n🐺 Could not heal ${routePath}: ${result.explanation}`));
         this._healInProgress = false;
+        this._healStatus = null;
       }
     } catch (err) {
       console.log(chalk.red(`\n🐺 Error during heal: ${err.message}`));
       this._healInProgress = false;
+      this._healStatus = null;
     }
   }
 

package/src/core/wolverine.js

@@ -83,16 +83,22 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
   let openaiClient = null;
   try { openaiClient = getClient(); } catch { /* will fail later */ }
 
-  const injectionResult = await detectInjection(parsed.errorMessage, parsed.stackTrace, { openaiClient });
-
-  if (logger) logger.info(EVENT_TYPES.HEAL_INJECTION_SCAN, `Injection scan: ${injectionResult.safe ? "clean" : "BLOCKED"}`, injectionResult);
-
-  if (!injectionResult.safe) {
-    console.log(chalk.red("  🚨 BLOCKED: Potential prompt injection detected."));
-    if (logger) logger.critical(EVENT_TYPES.SECURITY_INJECTION_DETECTED, "Injection detected — repair blocked", injectionResult);
-    return { healed: false, explanation: "Prompt injection detected — repair blocked" };
+  // Skip injection scan on empty/trivial stderr (prevents false positives on clean restarts)
+  const stderrContent = (parsed.errorMessage || "").trim() + (parsed.stackTrace || "").trim();
+  if (stderrContent.length < 20) {
+    console.log(chalk.gray("  🛡️  Stderr too short for injection scan — skipping"));
+  } else {
+    const injectionResult = await detectInjection(parsed.errorMessage, parsed.stackTrace, { openaiClient });
+
+    if (logger) logger.info(EVENT_TYPES.HEAL_INJECTION_SCAN, `Injection scan: ${injectionResult.safe ? "clean" : "BLOCKED"}`, injectionResult);
+
+    if (!injectionResult.safe) {
+      console.log(chalk.red("  🚨 BLOCKED: Potential prompt injection detected."));
+      if (logger) logger.critical(EVENT_TYPES.SECURITY_INJECTION_DETECTED, "Injection detected — repair blocked", injectionResult);
+      return { healed: false, explanation: "Prompt injection detected — repair blocked" };
+    }
+    console.log(chalk.green("  ✅ Clean — no injection detected."));
   }
-  console.log(chalk.green("  ✅ Clean — no injection detected."));
 
   // 4b. Check if this is a human-required issue (expired keys, billing, etc.)
   if (notifier) {
@@ -128,6 +134,26 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
   // 5. Read the source file (if available) + get brain context
   const sourceCode = hasFile ? sandbox.readFile(parsed.filePath) : "";
 
+  // 5b. Get last known good version from backup (helps AI revert vs patch)
+  let backupSourceCode = "";
+  if (hasFile && backupManager) {
+    try {
+      const fs = require("fs");
+      const path = require("path");
+      const stableBackups = backupManager.getAll().filter(b => b.status === "stable" || b.status === "verified");
+      if (stableBackups.length > 0) {
+        const latest = stableBackups[stableBackups.length - 1];
+        const relPath = path.relative(cwd, parsed.filePath).replace(/[/\\]/g, "__");
+        const backupFile = path.join(cwd, ".wolverine", "backups", latest.id, relPath);
+        if (fs.existsSync(backupFile)) {
+          backupSourceCode = fs.readFileSync(backupFile, "utf-8");
+          if (backupSourceCode === sourceCode) backupSourceCode = ""; // Same — no useful diff
+          else console.log(chalk.gray(`  📋 Found last known good version (backup ${latest.id})`));
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
   let brainContext = "";
   // Inject relevant skill context (claw-code: pre-enrich prompt with matched tools)
   if (skills) {
@@ -183,7 +209,7 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
         console.log(chalk.yellow(`  🧠 Fast path (${getModel("coding")})...`));
         try {
           const repair = await requestRepair({
-            filePath: parsed.filePath, sourceCode,
+            filePath: parsed.filePath, sourceCode, backupSourceCode,
             errorMessage: parsed.errorMessage, stackTrace: parsed.stackTrace,
           });
           rateLimiter.record(errorSignature);
@@ -243,7 +269,7 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
         const agentResult = await agent.run({
           errorMessage: parsed.errorMessage, stackTrace: parsed.stackTrace,
           primaryFile: parsed.filePath, sourceCode,
-          brainContext: fullContext,
+          brainContext: fullContext + (backupSourceCode ? `\n\nLAST KNOWN WORKING VERSION of ${parsed.filePath}:\n${backupSourceCode}\nIf the broken code added something that doesn't work, revert it rather than patching around it.` : ""),
         });
         rateLimiter.record(errorSignature, agentResult.totalTokens);
 

package/src/dashboard/server.js

@@ -871,6 +871,7 @@ ${context ? "\nBrain:\n" + context : ""}`,
       backups: this.backupManager ? this.backupManager.getStats() : {},
       health: this.healthMonitor ? this.healthMonitor.getStats() : {},
       errorMonitor: this.errorMonitor ? this.errorMonitor.getStats() : {},
+      heal: this.runner ? this.runner._healStatus : null,
     }));
   }