wolverine-ai 1.0.0

package/bin/wolverine.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const dotenv = require("dotenv");
+const chalk = require("chalk");
+
+// Load secrets
+dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+
+const { loadConfig } = require("../src/core/config");
+const { detect, logSystemInfo } = require("../src/core/system-info");
+const { logModelConfig } = require("../src/core/models");
+
+const args = process.argv.slice(2);
+const config = loadConfig();
+
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+${chalk.yellow("🐺 Wolverine Node.js")} — Autonomous self-healing server framework
+
+${chalk.bold("Usage:")}
+  wolverine <script.js> [options]
+
+${chalk.bold("Options:")}
+  --help, -h       Show this help
+  --single         Force single-worker mode (no clustering)
+  --workers <n>    Force specific worker count
+  --info           Show system info and exit
+
+${chalk.bold("Configuration:")}
+  server/config/settings.json    Models, telemetry, limits, health checks
+  .env.local                     Secrets only (API keys, admin key)
+
+${chalk.bold("Examples:")}
+  wolverine server/index.js
+  wolverine server/index.js --single
+  wolverine server/index.js --workers 4
+  wolverine --info
+`);
+  process.exit(0);
+}
+
+// --info: show system info and exit
+if (args.includes("--info")) {
+  const info = detect();
+  console.log(chalk.yellow.bold("\n  🐺 Wolverine — System Info\n"));
+  logSystemInfo(info);
+  console.log(chalk.gray(`\n  Node: ${info.nodeVersion}`));
+  console.log(chalk.gray(`  Hostname: ${info.hostname}`));
+  console.log(chalk.gray(`  Disk: ${info.disk.totalGB}GB total, ${info.disk.freeGB}GB free (${info.disk.usedPercent}% used)`));
+  console.log(chalk.gray(`  Memory: ${info.memory.totalGB}GB total, ${info.memory.freeGB}GB free (${info.memory.usedPercent}% used)`));
+  console.log("");
+  process.exit(0);
+}
+
+const scriptPath = args.find(a => !a.startsWith("--")) || "server/index.js";
+
+// System detection (for analytics + dashboard, NOT for forking)
+// Wolverine runs as a single process manager. If users want clustering,
+// they handle it inside their server (e.g. @fastify/cluster, pm2 cluster mode).
+// Forking workers at the wolverine level causes port conflicts because each
+// worker spawns its own child process on the same port.
+const systemInfo = detect();
+
+const { WolverineRunner } = require("../src/core/runner");
+
+console.log(chalk.yellow.bold("\n  🐺 Wolverine Node.js — Autonomous Server Agent\n"));
+logSystemInfo(systemInfo);
+console.log("");
+
+console.log(chalk.bold("  Models:"));
+logModelConfig(chalk);
+console.log("");
+console.log(chalk.gray(`  Script:     ${scriptPath}`));
+console.log(chalk.gray(`  Port:       ${config.server.port}`));
+console.log(chalk.gray(`  Retries:    ${config.server.maxRetries}`));
+console.log(chalk.gray(`  Sandbox:    ${path.resolve(process.cwd())} (locked)`));
+console.log(chalk.gray(`  Telemetry:  ${config.telemetry.enabled ? "on" : "off"}`));
+console.log("");
+
+const runner = new WolverineRunner(scriptPath, { cwd: process.cwd() });
+
+process.on("SIGINT", () => {
+  console.log(chalk.yellow(`\n\n👋 Shutting down Wolverine${workerLabel}...`));
+  runner.stop();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  runner.stop();
+  process.exit(0);
+});
+
+runner.start();

package/examples/01-basic-typo.js

@@ -0,0 +1,31 @@
+const http = require("http");
+const PORT = process.env.PORT || 3000;
+
+const users = [
+  { id: 1, name: "Alice" },
+  { id: 2, name: "Bob" },
+  { id: 3, name: "Charlie" },
+];
+
+// BUG: `userz` is not defined — should be `users`
+const userCache = JSON.stringify(users);
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/api/users" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(userCache);
+  } else if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", uptime: process.uptime() }));
+  } else if (req.url === "/time") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ time: new Date().toISOString() }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Server on http://localhost:${PORT}`);
+});

package/examples/02-multi-file/routes/users.js

@@ -0,0 +1,15 @@
+/**
+ * User routes module.
+ * Exports `getUsers` but the server imports `fetchUsers` — name mismatch.
+ */
+
+const users = [
+  { id: 1, name: "Alice", role: "admin" },
+  { id: 2, name: "Bob", role: "user" },
+];
+
+function getUsers() {
+  return { users, count: users.length };
+}
+
+module.exports = { getUsers };

package/examples/02-multi-file/server.js

@@ -0,0 +1,25 @@
+const http = require("http");
+const { getUsers } = require("./routes/users");
+
+const PORT = process.env.PORT || 3000;
+
+const initialData = getUsers();
+console.log(`Loaded ${initialData.count} users`);
+
+const server = http.createServer(async (req, res) => {
+  if (req.url === "/api/users" && req.method === "GET") {
+    const data = getUsers();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  } else if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok" }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Multi-file server on http://localhost:${PORT}`);
+});

package/examples/03-syntax-error.js

@@ -0,0 +1,23 @@
+const http = require("http");
+const PORT = process.env.PORT || 3000;
+
+function formatResponse(data) {
+  return JSON.stringify({ timestamp: Date.now(), data: data });
+}
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/api/data") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(formatResponse({ status: "ok" }));
+  } else if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(formatResponse({ status: "healthy" }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Server on http://localhost:${PORT}`);
+});

package/examples/04-secret-leak.js

@@ -0,0 +1,14 @@
+const http = require("http");
+const PORT = process.env.PORT || 3000;
+
+// BUG: calls .connect() on a string — will crash and expose TEST_PHRASE in error
+const secret = process.env.TEST_PHRASE || "fallback";
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200);
+  res.end("ok");
+});
+
+server.listen(PORT, () => {
+  console.log(`Server on http://localhost:${PORT}`);
+});

package/examples/05-expired-key.js

@@ -0,0 +1,27 @@
+const http = require("http");
+const https = require("https");
+const PORT = process.env.PORT || 3000;
+
+const options = {
+  hostname: "api.example-that-does-not-exist.com",
+  path: "/v1/data",
+  headers: { "Authorization": "Bearer expired_token_12345" },
+};
+
+// BUG: throws on ENOTFOUND — should be caught, not thrown
+const req = https.get(options, (res) => {
+  console.log("Status:", res.statusCode);
+});
+
+req.on("error", (err) => {
+  console.error(`503 Service Unavailable: External API down - ${err.message}`);
+});
+
+const server = http.createServer((reqIn, res) => {
+  res.writeHead(200);
+  res.end("ok");
+});
+
+server.listen(PORT, () => {
+  console.log(`Server on http://localhost:${PORT}`);
+});

package/examples/06-json-config/config.json

@@ -0,0 +1,13 @@
+{
+  "appName": "MyApp",
+  "version": "1.0.0",
+  "databse": {
+    "host": "localhost",
+    "port": 5432,
+    "name": "myapp_db"
+  },
+  "cache": {
+    "enabled": true,
+    "ttl": 3600
+  }
+}

package/examples/06-json-config/server.js

@@ -0,0 +1,28 @@
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const PORT = process.env.PORT || 3000;
+
+const configPath = path.join(__dirname, "config.json");
+const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+
+// BUG: config.json has "databse" not "database"
+const dbHost = config.databse.host;
+const dbPort = config.databse.port;
+
+console.log(`Connecting to database at ${dbHost}:${dbPort}`);
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", db: `${dbHost}:${dbPort}` }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Server on http://localhost:${PORT}`);
+});

package/examples/07-rate-limit-loop.js

@@ -0,0 +1,11 @@
+const http = require("http");
+const PORT = process.env.PORT || 3000;
+
+
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200);
+  res.end("ok");
+});
+
+server.listen(PORT);

package/examples/08-sandbox-escape.js

@@ -0,0 +1,20 @@
+const http = require("http");
+const PORT = process.env.PORT || 3000;
+
+// BUG: null.toString() crashes at startup
+const config = null;
+const appName = config?.toString() || "app";
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", app: appName }));
+  } else {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`${appName} server on http://localhost:${PORT}`);
+});

package/examples/buggy-server.js

@@ -0,0 +1,39 @@
+/**
+ * Example: A deliberately buggy HTTP server.
+ * Wolverine will detect the crash on startup and fix it automatically.
+ *
+ * BUG: `parseConfig` calls `settings.toUpperCase()` but settings is an object, not a string.
+ */
+
+const http = require("http");
+
+const PORT = process.env.PORT || 3000;
+
+const settings = { mode: "production", debug: false };
+
+// BUG: settings is an object, calling .toUpperCase() on it will throw
+const configMode = settings.mode.toUpperCase();
+
+const users = [
+  { id: 1, name: "Alice", role: configMode },
+  { id: 2, name: "Bob", role: "user" },
+];
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/api/users" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ users }));
+  } else if (req.url === "/health" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", uptime: process.uptime() }));
+  } else {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+  console.log(`Health: http://localhost:${PORT}/health`);
+  console.log(`Users:  http://localhost:${PORT}/api/users`);
+});

package/examples/demos/01-basic-typo/index.js

@@ -0,0 +1,20 @@
+const express = require("express");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// BUG: routes/api.js references `userz` instead of `users` — crashes on require
+app.use(express.json());
+
+const healthRoutes = require("./routes/health");
+const apiRoutes = require("./routes/api");
+
+app.use("/health", healthRoutes);
+app.use("/api", apiRoutes);
+
+app.get("/", (req, res) => {
+  res.json({ name: "Demo 01 — Basic Typo", status: "running" });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/01-basic-typo/routes/api.js

@@ -0,0 +1,13 @@
+const express = require("express");
+const router = express.Router();
+
+const users = [
+  { id: 1, name: "Alice" },
+  { id: 2, name: "Bob" },
+];
+
+// BUG: `userz` should be `users` — crashes on startup when building cache
+const userCache = JSON.stringify(userz);
+
+router.get("/users", (req, res) => { res.json(JSON.parse(userCache)); });
+module.exports = router;

package/examples/demos/01-basic-typo/routes/health.js

@@ -0,0 +1,4 @@
+const express = require("express");
+const router = express.Router();
+router.get("/", (req, res) => { res.json({ status: "ok", uptime: process.uptime() }); });
+module.exports = router;

package/examples/demos/02-multi-file/index.js

@@ -0,0 +1,24 @@
+const express = require("express");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+const healthRoutes = require("./routes/health");
+const apiRoutes = require("./routes/api");
+
+app.use("/health", healthRoutes);
+app.use("/api", apiRoutes);
+
+// BUG: fetchUsers doesn't exist — routes/api.js exports getUsers
+const { fetchUsers } = require("./routes/api");
+const initialData = fetchUsers();
+console.log(`Loaded ${initialData.count} users`);
+
+app.get("/", (req, res) => {
+  res.json({ name: "Demo 02 — Multi-File", status: "running" });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/02-multi-file/routes/api.js

@@ -0,0 +1,13 @@
+const express = require("express");
+const router = express.Router();
+
+const users = [
+  { id: 1, name: "Alice", role: "admin" },
+  { id: 2, name: "Bob", role: "user" },
+];
+
+// Exports getUsers, but index.js imports fetchUsers — name mismatch
+function getUsers() { return { users, count: users.length }; }
+
+router.get("/users", (req, res) => { res.json(getUsers()); });
+module.exports = { getUsers };

package/examples/demos/02-multi-file/routes/health.js

@@ -0,0 +1,4 @@
+const express = require("express");
+const router = express.Router();
+router.get("/", (req, res) => { res.json({ status: "ok", uptime: process.uptime() }); });
+module.exports = router;

package/examples/demos/03-syntax-error/index.js

@@ -0,0 +1,18 @@
+const express = require("express");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+// BUG: extra closing paren on the route handler
+app.get("/health", (req, res) => {
+  res.json({ status: "ok", uptime: process.uptime() });
+}));
+
+app.get("/", (req, res) => {
+  res.json({ name: "Demo 03 — Syntax Error", status: "running" });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/04-secret-leak/index.js

@@ -0,0 +1,16 @@
+const express = require("express");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+// BUG: calls .connect() on a string — crashes and exposes TEST_PHRASE in error
+const secret = process.env.TEST_PHRASE || "fallback";
+const connection = secret.connect("localhost:5432");
+
+app.get("/health", (req, res) => { res.json({ status: "ok" }); });
+app.get("/", (req, res) => { res.json({ name: "Demo 04 — Secret Leak" }); });
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/05-expired-key/index.js

@@ -0,0 +1,21 @@
+const express = require("express");
+const https = require("https");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+// BUG: calls a non-existent API, then throws on the error
+const req = https.get({ hostname: "api.example-that-does-not-exist.com", path: "/v1/data" }, (res) => {
+  console.log("Status:", res.statusCode);
+});
+req.on("error", (err) => {
+  throw new Error(`503 Service Unavailable: External API down - ${err.message}`);
+});
+
+app.get("/health", (req, res) => { res.json({ status: "ok" }); });
+app.get("/", (req, res) => { res.json({ name: "Demo 05 — Expired Key" }); });
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/06-json-config/config.json

@@ -0,0 +1,9 @@
+{
+  "appName": "MyApp",
+  "version": "1.0.0",
+  "databse": {
+    "host": "localhost",
+    "port": 5432,
+    "name": "myapp_db"
+  }
+}

package/examples/demos/06-json-config/index.js

@@ -0,0 +1,20 @@
+const express = require("express");
+const fs = require("fs");
+const path = require("path");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+// BUG: config.json has "databse" not "database"
+const config = JSON.parse(fs.readFileSync(path.join(__dirname, "config.json"), "utf-8"));
+const dbHost = config.database.host;
+const dbPort = config.database.port;
+console.log(`Connecting to database at ${dbHost}:${dbPort}`);
+
+app.get("/health", (req, res) => { res.json({ status: "ok", db: `${dbHost}:${dbPort}` }); });
+app.get("/", (req, res) => { res.json({ name: "Demo 06 — JSON Config" }); });
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/examples/demos/07-null-crash/index.js

@@ -0,0 +1,16 @@
+const express = require("express");
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+
+// BUG: null.toString() crashes at startup
+const config = null;
+const appName = config.toString();
+
+app.get("/health", (req, res) => { res.json({ status: "ok", app: appName }); });
+app.get("/", (req, res) => { res.json({ name: appName }); });
+
+app.listen(PORT, () => {
+  console.log(`${appName} server on http://localhost:${PORT}`);
+});

package/examples/run-demo.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Demo Runner — copies a demo into server/, runs wolverine, then restores.
+ *
+ * Usage:
+ *   node examples/run-demo.js 01-basic-typo
+ *   node examples/run-demo.js 02-multi-file
+ *   node examples/run-demo.js --list
+ *
+ * What it does:
+ * 1. Backs up the current server/ directory
+ * 2. Copies the demo files into server/
+ * 3. Runs wolverine against server/index.js
+ * 4. On exit, restores the original server/
+ */
+
+const { spawn, execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const ROOT = path.resolve(__dirname, "..");
+const DEMOS_DIR = path.join(__dirname, "demos");
+const SERVER_DIR = path.join(ROOT, "server");
+const BACKUP_DIR = path.join(ROOT, ".wolverine", "_server_backup");
+const BIN = path.join(ROOT, "bin", "wolverine.js");
+
+// List demos
+if (process.argv.includes("--list") || process.argv.length < 3) {
+  const demos = fs.readdirSync(DEMOS_DIR).filter(f => fs.statSync(path.join(DEMOS_DIR, f)).isDirectory());
+  console.log("\nAvailable demos:\n");
+  for (const demo of demos) {
+    const indexPath = path.join(DEMOS_DIR, demo, "index.js");
+    if (fs.existsSync(indexPath)) {
+      const content = fs.readFileSync(indexPath, "utf-8");
+      const bugMatch = content.match(/\/\/ BUG:(.+)/);
+      const bug = bugMatch ? bugMatch[1].trim() : "see source";
+      console.log(`  ${demo.padEnd(25)} ${bug}`);
+    }
+  }
+  console.log("\nUsage: node examples/run-demo.js <demo-name>\n");
+  process.exit(0);
+}
+
+const demoName = process.argv[2];
+const demoDir = path.join(DEMOS_DIR, demoName);
+
+if (!fs.existsSync(demoDir)) {
+  console.error(`Demo not found: ${demoName}`);
+  console.error(`Run with --list to see available demos.`);
+  process.exit(1);
+}
+
+// Step 1: Backup current server/
+console.log(`\n📦 Backing up server/ → .wolverine/_server_backup/`);
+copyDir(SERVER_DIR, BACKUP_DIR);
+
+// Step 2: Copy demo into server/
+console.log(`📋 Copying demo '${demoName}' → server/`);
+clearDir(SERVER_DIR);
+copyDir(demoDir, SERVER_DIR);
+
+// Step 3: Run wolverine
+console.log(`🐺 Starting wolverine with demo...\n`);
+
+const child = spawn("node", [BIN, "server/index.js"], {
+  cwd: ROOT,
+  stdio: "inherit",
+  env: { ...process.env },
+});
+
+// Step 4: Restore on exit
+function restore() {
+  console.log(`\n📦 Restoring original server/`);
+  clearDir(SERVER_DIR);
+  copyDir(BACKUP_DIR, SERVER_DIR);
+  clearDir(BACKUP_DIR);
+  try { fs.rmdirSync(BACKUP_DIR); } catch {}
+}
+
+process.on("SIGINT", () => { child.kill("SIGTERM"); restore(); process.exit(0); });
+process.on("SIGTERM", () => { child.kill("SIGTERM"); restore(); process.exit(0); });
+child.on("exit", () => { restore(); });
+
+// Helpers
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function clearDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      clearDir(p);
+      fs.rmdirSync(p);
+    } else {
+      fs.unlinkSync(p);
+    }
+  }
+}