wolverine-ai 2.6.0 → 2.6.2

package/README.md

@@ -535,14 +535,22 @@ All demos use the `server/` directory pattern. Each demo:
 
 ## Backup System
 
-Full `server/` directory snapshots with lifecycle management:
+All backups stored in **`~/.wolverine-safe-backups/`** — outside the project directory. Survives `git pull`, `npm install`, `rm -rf .wolverine`, even deleting the project entirely.
 
-- Created before every repair attempt and every smart edit (with reason string)
+```
+~/.wolverine-safe-backups/
+  manifest.json        ← backup registry
+  snapshots/           ← heal snapshots (per fix attempt)
+  updates/             ← pre-update snapshots (before framework upgrades)
+```
+
+- Created before every repair attempt and every framework update (with reason string)
 - Created on graceful shutdown (`createShutdownBackup()`)
 - Includes all files: `.js`, `.json`, `.sql`, `.db`, `.yaml`, configs
+- Old `.wolverine/backups/` auto-migrated to safe location on first run
 - **Status lifecycle**: UNSTABLE → VERIFIED (fix passed) → STABLE (30min+ uptime)
 - **Retention**: unstable/verified pruned after 7 days, stable keeps 1/day after 7 days
-- Atomic writes prevent corruption on kill
+- Protected files never overwritten during rollback: `settings.json`, `db.js`, `.env.local`
 
 **Rollback & Recovery:**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.6.0",
+  "version": "2.6.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/src/backup/backup-manager.js

@@ -14,9 +14,13 @@ const { redact } = require("../security/secret-redactor");
  * Stable backups older than 7 days → keep 1 per day (most recent).
  */
 
-const WOLVERINE_DIR = ".wolverine";
-const BACKUPS_DIR = path.join(WOLVERINE_DIR, "backups");
-const MANIFEST_FILE = path.join(BACKUPS_DIR, "manifest.json");
+const os = require("os");
+
+// Safe backup location — OUTSIDE the project directory.
+// Survives git pull, npm install, rm -rf .wolverine, project deletion.
+// All backup infrastructure (heal snapshots, update snapshots, rollbacks) uses this.
+const SAFE_BACKUP_ROOT = path.join(os.homedir(), ".wolverine-safe-backups");
+const MANIFEST_FILE_NAME = "manifest.json";
 const STABILITY_THRESHOLD_MS = 30 * 60 * 1000;
 const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -33,9 +37,11 @@ const NEVER_ROLLBACK = [
 class BackupManager {
   constructor(projectRoot) {
     this.projectRoot = path.resolve(projectRoot);
-    this.backupsDir = path.join(this.projectRoot, BACKUPS_DIR);
-    this.manifestPath = path.join(this.projectRoot, MANIFEST_FILE);
+    // All backups in safe home directory — never inside the project
+    this.backupsDir = path.join(SAFE_BACKUP_ROOT, "snapshots");
+    this.manifestPath = path.join(SAFE_BACKUP_ROOT, MANIFEST_FILE_NAME);
     this._ensureDirs();
+    this._migrateOldBackups(); // one-time migration from .wolverine/backups/
     this.manifest = this._loadManifest();
   }
 
@@ -276,7 +282,37 @@ class BackupManager {
 
   // -- Private --
 
-  _ensureDirs() { fs.mkdirSync(this.backupsDir, { recursive: true }); }
+  _ensureDirs() {
+    fs.mkdirSync(this.backupsDir, { recursive: true });
+    fs.mkdirSync(SAFE_BACKUP_ROOT, { recursive: true });
+  }
+
+  /**
+   * One-time migration: move backups from old .wolverine/backups/ to safe location.
+   */
+  _migrateOldBackups() {
+    const oldDir = path.join(this.projectRoot, ".wolverine", "backups");
+    const oldManifest = path.join(oldDir, "manifest.json");
+    if (!fs.existsSync(oldManifest) || fs.existsSync(this.manifestPath)) return;
+
+    try {
+      // Copy manifest
+      fs.copyFileSync(oldManifest, this.manifestPath);
+      // Copy backup dirs
+      for (const entry of fs.readdirSync(oldDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const src = path.join(oldDir, entry.name);
+        const dest = path.join(this.backupsDir, entry.name);
+        if (!fs.existsSync(dest)) {
+          fs.mkdirSync(dest, { recursive: true });
+          for (const file of fs.readdirSync(src)) {
+            fs.copyFileSync(path.join(src, file), path.join(dest, file));
+          }
+        }
+      }
+      console.log(chalk.gray(`  📦 Migrated backups to safe location: ${SAFE_BACKUP_ROOT}`));
+    } catch {}
+  }
 
   _loadManifest() {
     if (fs.existsSync(this.manifestPath)) {
@@ -323,4 +359,4 @@ class BackupManager {
   }
 }
 
-module.exports = { BackupManager, STABILITY_THRESHOLD_MS };
+module.exports = { BackupManager, STABILITY_THRESHOLD_MS, SAFE_BACKUP_ROOT };

package/src/brain/brain.js

@@ -38,7 +38,7 @@ const SEED_DOCS = [
     metadata: { topic: "heal-pipeline" },
   },
   {
-    text: "Wolverine backup system: full server/ directory snapshots with lifecycle management. Every fix creates a backup with a reason string before patching. Status lifecycle: UNSTABLE (just created) → VERIFIED (fix passed boot probe) → STABLE (server ran 30min+ without crash). Features: rollbackTo(backupId) creates pre-rollback backup then restores files and restarts server. undoRollback() restores pre-rollback state. Hot-load: admin can load any backup as current server state from dashboard. Shutdown backup on graceful exit. Retention: unstable/verified pruned after 7 days. Stable backups older than 7 days keep 1 per day. Rollback log tracks all rollback/undo operations with timestamps and success status. Dashboard endpoints: POST /api/backups/:id/rollback, POST /api/backups/undo, POST /api/backups/:id/hotload (all require admin auth).",
+    text: "Wolverine backup system: ALL backups stored in ~/.wolverine-safe-backups/ (OUTSIDE project, survives git pull/npm install/rm -rf). Structure: snapshots/ (heal backups per fix attempt), updates/ (pre-update snapshots), manifest.json (backup registry). Old .wolverine/backups/ auto-migrated on first run. Full server/ directory snapshots with lifecycle management. Every fix creates a backup with a reason string before patching. Status lifecycle: UNSTABLE (just created) → VERIFIED (fix passed boot probe) → STABLE (server ran 30min+ without crash). Features: rollbackTo(backupId) creates pre-rollback backup then restores files and restarts server. undoRollback() restores pre-rollback state. Hot-load: admin can load any backup as current server state from dashboard. Shutdown backup on graceful exit. Retention: unstable/verified pruned after 7 days. Stable backups older than 7 days keep 1 per day. Rollback log tracks all rollback/undo operations with timestamps and success status. Dashboard endpoints: POST /api/backups/:id/rollback, POST /api/backups/undo, POST /api/backups/:id/hotload (all require admin auth).",
     metadata: { topic: "backup-system" },
   },
   {
@@ -238,7 +238,7 @@ const SEED_DOCS = [
     metadata: { topic: "skill-deps" },
   },
   {
-    text: "CRITICAL: Never run raw 'npm install wolverine-ai' or 'git pull' to update — these OVERWRITE server/, .wolverine/ (brain, backups, events), and .env.local. Always use the safe update skill: wolverine --update (CLI), safeUpdate(cwd) (programmatic), or let auto-update handle it. The update skill: (1) creates safe backup in ~/.wolverine-safe-backups/ (outside project, survives everything), (2) backs up server/ + .wolverine/ + .env to memory, (3) selectively updates ONLY src/ bin/ package.json via git checkout, (4) restores all user files, (5) signals brain to merge new seed docs. Restore with: wolverine --restore <backup-name>. List backups: wolverine --backups.",
+    text: "CRITICAL: Never run raw 'npm install wolverine-ai' or 'git pull' to update — these OVERWRITE server/, .wolverine/ (brain, backups, events), and .env.local. Always use the safe update skill: wolverine --update (CLI), safeUpdate(cwd) (programmatic), or let auto-update handle it. ALL backups (heal snapshots + update snapshots) stored in ~/.wolverine-safe-backups/ (OUTSIDE project, survives git clean, rm -rf, project deletion). Structure: ~/.wolverine-safe-backups/snapshots/ (heal backups), ~/.wolverine-safe-backups/updates/ (pre-update snapshots), ~/.wolverine-safe-backups/manifest.json (backup registry). Old .wolverine/backups/ auto-migrated on first run. Restore with: wolverine --restore <name>. List: wolverine --backups.",
     metadata: { topic: "safe-update-warning" },
   },
   {

package/src/skills/update.js

@@ -27,6 +27,7 @@ const chalk = require("chalk");
 
 const PACKAGE_NAME = "wolverine-ai";
 const SAFE_BACKUP_DIR = path.join(require("os").homedir(), ".wolverine-safe-backups");
+const SAFE_SNAPSHOTS_DIR = path.join(SAFE_BACKUP_DIR, "snapshots");
 
 /**
  * Create a safe backup snapshot outside the project directory.
@@ -34,7 +35,7 @@ const SAFE_BACKUP_DIR = path.join(require("os").homedir(), ".wolverine-safe-back
  */
 function createSafeBackup(cwd) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = path.join(SAFE_BACKUP_DIR, timestamp);
+  const backupDir = path.join(SAFE_BACKUP_DIR, "updates", timestamp);
   fs.mkdirSync(backupDir, { recursive: true });
 
   const dirsToBackup = [
@@ -76,12 +77,13 @@ function createSafeBackup(cwd) {
  * List available safe backups.
  */
 function listSafeBackups() {
-  if (!fs.existsSync(SAFE_BACKUP_DIR)) return [];
-  return fs.readdirSync(SAFE_BACKUP_DIR)
-    .filter(d => fs.statSync(path.join(SAFE_BACKUP_DIR, d)).isDirectory())
+  const updatesDir = path.join(SAFE_BACKUP_DIR, "updates");
+  if (!fs.existsSync(updatesDir)) return [];
+  return fs.readdirSync(updatesDir)
+    .filter(d => fs.statSync(path.join(updatesDir, d)).isDirectory())
     .map(d => {
       try {
-        const manifest = JSON.parse(fs.readFileSync(path.join(SAFE_BACKUP_DIR, d, "manifest.json"), "utf-8"));
+        const manifest = JSON.parse(fs.readFileSync(path.join(SAFE_BACKUP_DIR, "updates", d, "manifest.json"), "utf-8"));
         return { dir: d, ...manifest };
       } catch { return { dir: d }; }
     })
@@ -92,7 +94,7 @@ function listSafeBackups() {
  * Restore from a safe backup.
  */
 function restoreFromSafeBackup(cwd, backupName) {
-  const backupDir = path.join(SAFE_BACKUP_DIR, backupName);
+  const backupDir = path.join(SAFE_BACKUP_DIR, "updates", backupName);
   if (!fs.existsSync(backupDir)) throw new Error(`Backup not found: ${backupName}`);
 
   const dirsToRestore = [".wolverine", "server"];