wolverine-ai 2.4.3 → 2.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "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/platform/auto-update.js

@@ -38,19 +38,42 @@ function getCurrentVersion() {
 }
 
 /**
- * Check npm registry for the latest published version.
- * Uses `npm view` — no network dependency beyond npm.
+ * Check for the latest available version.
+ * For git repos: checks remote for newer commits via `git ls-remote`.
+ * For npm installs: checks npm registry via `npm view`.
  */
-function getLatestVersion() {
+function getLatestVersion(cwd) {
+  // Try npm registry first (works for both git and npm installs)
   try {
     const result = execSync(`npm view ${PACKAGE_NAME} version 2>/dev/null`, {
       encoding: "utf-8",
       timeout: 15000,
+      cwd: cwd || process.cwd(),
     }).trim();
-    return result || null;
-  } catch {
-    return null;
-  }
+    if (result) return result;
+  } catch {}
+
+  // Fallback for git repos: check if remote has newer commits
+  try {
+    if (isGitRepo(cwd || process.cwd())) {
+      execSync("git fetch origin --quiet", { cwd: cwd || process.cwd(), stdio: "pipe", timeout: 15000 });
+      const behind = execSync("git rev-list HEAD..origin/master --count", {
+        cwd: cwd || process.cwd(), encoding: "utf-8", timeout: 5000,
+      }).trim();
+      if (parseInt(behind, 10) > 0) {
+        // There are newer commits — read version from remote package.json
+        try {
+          const remoteVersion = execSync("git show origin/master:package.json", {
+            cwd: cwd || process.cwd(), encoding: "utf-8", timeout: 5000,
+          });
+          const pkg = JSON.parse(remoteVersion);
+          return pkg.version || null;
+        } catch {}
+      }
+    }
+  } catch {}
+
+  return null;
 }
 
 /**
@@ -68,25 +91,46 @@ function isNewer(latest, current) {
 }
 
 /**
- * Protect config files before update and restore after.
+ * Protect ALL user files before update and restore after.
+ * The entire server/ directory is sacred — auto-update must never touch it.
+ * Also protects .env files and any user config.
  */
-function backupConfigs(cwd) {
-  const configs = [
-    "server/config/settings.json",
-    ".env.local",
-    ".env",
-  ];
+function backupUserFiles(cwd) {
   const backups = {};
-  for (const file of configs) {
+
+  // Protect individual config files
+  const protectedFiles = [".env.local", ".env", ".wolverine/mcp.json", ".wolverine/pricing.json"];
+  for (const file of protectedFiles) {
     const fullPath = path.join(cwd, file);
     if (fs.existsSync(fullPath)) {
       backups[file] = fs.readFileSync(fullPath, "utf-8");
     }
   }
+
+  // Protect entire server/ directory (recursive)
+  const serverDir = path.join(cwd, "server");
+  if (fs.existsSync(serverDir)) {
+    const walk = (dir, base) => {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name === "node_modules") continue;
+          const fullPath = path.join(dir, entry.name);
+          const relPath = path.join(base, entry.name).replace(/\\/g, "/");
+          if (entry.isDirectory()) { walk(fullPath, relPath); }
+          else {
+            try { backups[relPath] = fs.readFileSync(fullPath, "utf-8"); } catch {}
+          }
+        }
+      } catch {}
+    };
+    walk(serverDir, "server");
+  }
+
   return backups;
 }
 
-function restoreConfigs(cwd, backups) {
+function restoreUserFiles(cwd, backups) {
   for (const [file, content] of Object.entries(backups)) {
     const fullPath = path.join(cwd, file);
     try {
@@ -96,8 +140,19 @@ function restoreConfigs(cwd, backups) {
   }
 }
 
+/**
+ * Detect if this is a git repo or an npm install.
+ */
+function isGitRepo(cwd) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe", timeout: 3000 });
+    return true;
+  } catch { return false; }
+}
+
 /**
  * Perform the upgrade. Returns { success, from, to, error? }
+ * Supports both npm-installed and git-cloned wolverine.
  */
 function upgrade(cwd, logger) {
   const current = getCurrentVersion();
@@ -110,23 +165,35 @@ function upgrade(cwd, logger) {
   console.log(chalk.blue(`\n  🔄 Wolverine update available: ${current} → ${latest}`));
   if (logger) logger.info("update.start", `Upgrading ${current} → ${latest}`, { from: current, to: latest });
 
-  // Back up configs
-  const configBackups = backupConfigs(cwd);
-  console.log(chalk.gray(`  🔒 Backed up ${Object.keys(configBackups).length} config files`));
+  // Back up ALL user files (server/, .env, configs)
+  const userBackups = backupUserFiles(cwd);
+  console.log(chalk.gray(`  🔒 Backed up ${Object.keys(userBackups).length} user files (server/ protected)`));
 
   try {
-    // Determine install method: global or local
-    const isGlobal = __dirname.includes("node_modules") && !cwd.includes("node_modules");
-    const cmd = isGlobal
-      ? `npm install -g ${PACKAGE_NAME}@${latest}`
-      : `npm install ${PACKAGE_NAME}@${latest}`;
+    const useGit = isGitRepo(cwd);
 
-    console.log(chalk.blue(`  📦 Running: ${cmd}`));
-    execSync(cmd, { cwd, stdio: "pipe", timeout: 120000 });
+    if (useGit) {
+      // Git-cloned: ONLY update framework files, NEVER touch server/
+      // Fetch latest, then selectively checkout only framework dirs
+      console.log(chalk.blue(`  📦 Git repo — selective framework update (server/ untouched)`));
+      execSync("git fetch origin master", { cwd, stdio: "pipe", timeout: 30000 });
+      // Only update: src/, bin/, package.json, examples/, tests/, CLAUDE.md, README.md, CHANGELOG.md
+      const frameworkPaths = "src/ bin/ package.json package-lock.json examples/ tests/ CLAUDE.md README.md CHANGELOG.md .npmignore";
+      execSync(`git checkout origin/master -- ${frameworkPaths}`, { cwd, stdio: "pipe", timeout: 30000 });
+      execSync("npm install", { cwd, stdio: "pipe", timeout: 120000 });
+    } else {
+      // npm-installed: update the package
+      const isGlobal = __dirname.includes("node_modules") && !cwd.includes("node_modules");
+      const cmd = isGlobal
+        ? `npm install -g ${PACKAGE_NAME}@${latest}`
+        : `npm install ${PACKAGE_NAME}@${latest}`;
+      console.log(chalk.blue(`  📦 Running: ${cmd}`));
+      execSync(cmd, { cwd, stdio: "pipe", timeout: 120000 });
+    }
 
-    // Restore configs (npm might have overwritten them)
-    restoreConfigs(cwd, configBackups);
-    console.log(chalk.gray(`  🔒 Restored config files`));
+    // Restore ALL user files (server/, .env, configs) — belt AND suspenders
+    restoreUserFiles(cwd, userBackups);
+    console.log(chalk.gray(`  🔒 Restored ${Object.keys(userBackups).length} user files`));
 
     // Clear version cache
     _currentVersion = null;
@@ -149,12 +216,12 @@ function upgrade(cwd, logger) {
  * Check for updates (non-blocking). Logs if update available.
  * Call upgrade() separately to actually apply.
  */
-function checkForUpdate() {
+function checkForUpdate(cwd) {
   if (_checking) return null;
   _checking = true;
   try {
     const current = getCurrentVersion();
-    const latest = getLatestVersion();
+    const latest = getLatestVersion(cwd);
     _checking = false;
     if (latest && isNewer(latest, current)) {
       console.log(chalk.blue(`  🔄 Update available: ${PACKAGE_NAME} ${current} → ${latest}`));
@@ -184,7 +251,7 @@ function startAutoUpdate({ cwd, logger, onUpdate, intervalMs }) {
   console.log(chalk.gray(`  🔄 Auto-update scheduled: first check in 30s, then every ${Math.round(interval / 60000)}min`));
   setTimeout(() => {
     console.log(chalk.gray(`  🔄 Checking for updates (v${getCurrentVersion()})...`));
-    const result = checkForUpdate();
+    const result = checkForUpdate(cwd);
     if (result?.available) {
       const upgraded = upgrade(cwd, logger);
       if (upgraded.success && onUpdate) {
@@ -200,7 +267,7 @@ function startAutoUpdate({ cwd, logger, onUpdate, intervalMs }) {
 
   // Periodic check
   _timer = setInterval(() => {
-    const result = checkForUpdate();
+    const result = checkForUpdate(cwd);
     if (result?.available) {
       const upgraded = upgrade(cwd, logger);
       if (upgraded.success && onUpdate) {