bus-agent 2.3.0

package/lib/backup.js

@@ -0,0 +1,256 @@
+/**
+ * CoCo Backup & Restore — Bus State Management Module
+ *
+ * Export functions, no process.exit, accepts busDir as parameter.
+ * Used by: coco-cli.js, backup.js (thin CLI wrapper)
+ */
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const crypto = require('crypto');
+
+const BACKUP_DIR_NAME = '.backups';
+
+/**
+ * Create a compressed backup of the bus directory
+ */
+function createBackup(busDir, outFile) {
+  if (!fs.existsSync(busDir)) throw new Error(`Bus directory not found: ${busDir}`);
+
+  const backupDir = path.join(path.dirname(busDir), BACKUP_DIR_NAME);
+  if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const output = outFile || path.join(backupDir, `coco-bus-${timestamp}.coco`);
+
+  console.log(`\n  CoCo Backup — Creating backup...`);
+  console.log(`  Source: ${busDir}`);
+  console.log(`  Output: ${output}\n`);
+
+  // Collect all bus files
+  const entries = [];
+  function walk(dir, relativePath = '') {
+    if (!fs.existsSync(dir)) return;
+    for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, item.name);
+      const rel = relativePath ? `${relativePath}/${item.name}` : item.name;
+      if (item.isDirectory()) walk(full, rel);
+      else if (item.isFile()) {
+        try { entries.push({ path: rel, content: fs.readFileSync(full, 'utf-8') }); }
+        catch (err) { console.warn(`  ⚠️  Cannot read: ${rel} (${err.message})`); }
+      }
+    }
+  }
+  walk(busDir);
+
+  const metadata = {
+    version: '2.1.0', tool: 'coco-backup', created_at: new Date().toISOString(),
+    hostname: require('os').hostname(), bus_path: busDir, file_count: entries.length,
+    checksum: crypto.createHash('sha256').update(entries.map(e => e.path + e.content).join('')).digest('hex'),
+  };
+
+  const compressed = zlib.gzipSync(JSON.stringify({ metadata, entries }));
+  fs.writeFileSync(output, compressed);
+
+  const sizeKB = (compressed.length / 1024).toFixed(1);
+  console.log(`  ✅ Backup complete: ${entries.length} files, ${sizeKB} KB`);
+  console.log(`  Checksum: ${metadata.checksum.substring(0, 16)}...\n`);
+
+  return output;
+}
+
+/**
+ * Restore bus from a backup file
+ */
+function restoreBackup(file, busDir) {
+  if (!fs.existsSync(file)) throw new Error(`Backup file not found: ${file}`);
+
+  console.log(`\n  CoCo Restore — Restoring from backup...`);
+  console.log(`  Source: ${file}`);
+
+  let archive;
+  try {
+    archive = JSON.parse(zlib.gunzipSync(fs.readFileSync(file)).toString('utf-8'));
+  } catch (err) { throw new Error(`Cannot read backup: ${err.message}`); }
+
+  const meta = archive.metadata;
+  console.log(`  Backup: ${meta.created_at}`);
+  console.log(`  Files:  ${meta.file_count}`);
+  console.log(`  Host:   ${meta.hostname}\n`);
+
+  const actualChecksum = crypto.createHash('sha256').update(archive.entries.map(e => e.path + e.content).join('')).digest('hex');
+  if (actualChecksum !== meta.checksum) throw new Error('Backup checksum mismatch — file may be corrupted');
+  console.log('  ✅ Checksum verified');
+
+  // Pre-restore backup
+  const backupDir = path.join(path.dirname(busDir), BACKUP_DIR_NAME);
+  const preBackupPath = path.join(backupDir, 'pre-restore-auto.coco');
+  console.log('  Creating pre-restore backup...');
+  try { createBackup(busDir, preBackupPath); console.log(`  Pre-restore backup saved: ${preBackupPath}`); } catch {}
+
+  // Restore files
+  let restored = 0, errors = 0;
+  for (const entry of archive.entries) {
+    const targetPath = path.join(busDir, entry.path);
+    try {
+      if (!fs.existsSync(path.dirname(targetPath))) fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      fs.writeFileSync(targetPath, entry.content, 'utf-8');
+      restored++;
+    } catch (err) { console.error(`  ❌ Failed to restore ${entry.path}: ${err.message}`); errors++; }
+  }
+
+  console.log(`\n  ✅ Restore complete: ${restored} files${errors > 0 ? `, ${errors} errors` : ''}\n`);
+  return { restored, errors };
+}
+
+/**
+ * List available backups
+ */
+function listBackups(busDir) {
+  const backupDir = path.join(path.dirname(busDir), BACKUP_DIR_NAME);
+  if (!fs.existsSync(backupDir)) { console.log('No backups found.'); return []; }
+
+  const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.coco')).sort().reverse();
+  if (files.length === 0) { console.log('No backups found.'); return []; }
+
+  console.log(`\n  CoCo Backups (${files.length} total):`);
+  console.log('  ──────────────────────────────────────────────');
+
+  let totalSize = 0;
+  for (const f of files) {
+    const filePath = path.join(backupDir, f);
+    const sizeKB = (fs.statSync(filePath).size / 1024).toFixed(1);
+    totalSize += fs.statSync(filePath).size;
+    try {
+      const meta = JSON.parse(zlib.gunzipSync(fs.readFileSync(filePath)).toString('utf-8')).metadata;
+      console.log(`  ${f.substring(0, 40).padEnd(42)} ${sizeKB.padStart(7)} KB  (${meta.file_count} files, ${meta.created_at.substring(0, 19)})`);
+    } catch { console.log(`  ${f.substring(0, 40).padEnd(42)} ${sizeKB.padStart(7)} KB  (corrupted?)`); }
+  }
+
+  console.log(`  ──────────────────────────────────────────────`);
+  console.log(`  Total: ${(totalSize / 1024 / 1024).toFixed(2)} MB\n`);
+  return files;
+}
+
+/**
+ * Show backup info
+ */
+function backupInfo(file) {
+  if (!fs.existsSync(file)) throw new Error(`File not found: ${file}`);
+  const archive = JSON.parse(zlib.gunzipSync(fs.readFileSync(file)).toString('utf-8'));
+  const meta = archive.metadata;
+
+  console.log(`\n  Backup Info: ${path.basename(file)}`);
+  console.log('  ──────────────────────────────────────────────');
+  console.log(`  Created:     ${meta.created_at}`);
+  console.log(`  Hostname:    ${meta.hostname}`);
+  console.log(`  Bus path:    ${meta.bus_path}`);
+  console.log(`  File count:  ${meta.file_count}`);
+  console.log(`  Checksum:    ${meta.checksum.substring(0, 24)}...`);
+
+  const dirs = {};
+  for (const entry of archive.entries) {
+    const dir = path.dirname(entry.path) || '.';
+    dirs[dir] = (dirs[dir] || 0) + 1;
+  }
+  console.log('  Contents:');
+  for (const [dir, count] of Object.entries(dirs).sort()) console.log(`    ${dir.padEnd(30)} ${count} file(s)`);
+  console.log();
+}
+
+/**
+ * Diff backup vs current state
+ */
+function diffBackup(file, busDir) {
+  if (!fs.existsSync(file)) throw new Error(`Backup file not found: ${file}`);
+  const archive = JSON.parse(zlib.gunzipSync(fs.readFileSync(file)).toString('utf-8'));
+
+  console.log(`\n  CoCo Diff — Backup vs Current State`);
+  console.log(`  Backup: ${archive.metadata.created_at}`);
+  console.log('  ──────────────────────────────────────────────');
+
+  const backupIndex = {};
+  for (const entry of archive.entries) backupIndex[entry.path] = entry.content;
+
+  const currentIndex = {};
+  function walk(dir, rel = '') {
+    if (!fs.existsSync(dir)) return;
+    for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, item.name);
+      const r = rel ? `${rel}/${item.name}` : item.name;
+      if (item.isDirectory()) walk(full, r);
+      else if (item.isFile()) { try { currentIndex[r] = fs.readFileSync(full, 'utf-8'); } catch {} }
+    }
+  }
+  walk(busDir);
+
+  let added = 0, removed = 0, modified = 0, unchanged = 0;
+  const allPaths = new Set([...Object.keys(backupIndex), ...Object.keys(currentIndex)]);
+  for (const p of allPaths) {
+    const inB = p in backupIndex, inC = p in currentIndex;
+    if (!inB && inC) { added++; console.log(`  ➕ Added:    ${p}`); }
+    else if (inB && !inC) { removed++; console.log(`  ➖ Removed:  ${p}`); }
+    else if (backupIndex[p] === currentIndex[p]) unchanged++;
+    else { modified++; console.log(`  ✏️  Modified: ${p} (${(backupIndex[p].length / 1024).toFixed(1)} KB → ${(currentIndex[p].length / 1024).toFixed(1)} KB)`); }
+  }
+  console.log(`  ──────────────────────────────────────────────`);
+  console.log(`  Added: ${added}, Removed: ${removed}, Modified: ${modified}, Unchanged: ${unchanged}\n`);
+}
+
+/**
+ * Cleanup old backups
+ */
+function cleanupBackups(busDir, maxAgeDays = 30) {
+  const backupDir = path.join(path.dirname(busDir), BACKUP_DIR_NAME);
+  if (!fs.existsSync(backupDir)) { console.log('No backups to clean up.'); return; }
+
+  const cutoff = Date.now() - (maxAgeDays * 86400000);
+  const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.coco'))
+    .map(f => ({ name: f, path: path.join(backupDir, f), stat: fs.statSync(path.join(backupDir, f)) }))
+    .filter(f => f.stat.mtimeMs < cutoff).sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs);
+
+  if (files.length === 0) { console.log(`No backups older than ${maxAgeDays} days.`); return; }
+
+  let deleted = 0, freed = 0;
+  for (const f of files) {
+    const sizeKB = (f.stat.size / 1024).toFixed(1);
+    fs.unlinkSync(f.path);
+    deleted++; freed += f.stat.size;
+    console.log(`  🗑️  ${f.name.substring(0, 40).padEnd(42)} ${sizeKB} KB`);
+  }
+  console.log(`\n  ✅ Deleted ${deleted} backups, freed ${(freed / 1024).toFixed(1)} KB\n`);
+}
+
+/**
+ * Auto-backup — only if changes detected
+ */
+function autoBackup(busDir) {
+  const backupDir = path.join(path.dirname(busDir), BACKUP_DIR_NAME);
+  if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+
+  const existing = fs.readdirSync(backupDir).filter(f => f.endsWith('.coco')).sort().reverse();
+  let lastChecksum = null;
+  if (existing.length > 0) {
+    try { lastChecksum = JSON.parse(zlib.gunzipSync(fs.readFileSync(path.join(backupDir, existing[0]))).toString('utf-8')).metadata.checksum; } catch {}
+  }
+
+  const backupPath = createBackup(busDir);
+  if (lastChecksum) {
+    try {
+      const newChecksum = JSON.parse(zlib.gunzipSync(fs.readFileSync(backupPath)).toString('utf-8')).metadata.checksum;
+      if (newChecksum === lastChecksum) { fs.unlinkSync(backupPath); console.log('  ℹ️  No changes since last backup — skipped.\n'); return { skipped: true }; }
+    } catch {}
+  }
+  return { skipped: false, path: backupPath };
+}
+
+function watchMode(busDir, intervalMinutes = 30) {
+  const intervalMs = intervalMinutes * 60 * 1000;
+  console.log(`\n  CoCo Auto-Backup — Every ${intervalMinutes} minutes`);
+  console.log(`  Bus:   ${busDir}`);
+  console.log(`  Press Ctrl+C to stop\n`);
+  autoBackup(busDir);
+  setInterval(() => { console.log(`[${new Date().toISOString()}] Auto-backup check...`); autoBackup(busDir); }, intervalMs);
+}
+
+module.exports = { createBackup, restoreBackup, listBackups, backupInfo, diffBackup, cleanupBackups, autoBackup, watchMode, BACKUP_DIR_NAME };