wolverine-ai 1.5.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "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/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/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 */ }
 }