teleportation-cli 1.0.0

package/lib/backup/manager.js

@@ -0,0 +1,461 @@
+/**
+ * Backup Manager for Teleportation
+ *
+ * Handles backup and rollback of configuration files before setup/changes.
+ * Ensures users can safely restore previous state if something goes wrong.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+
+const HOME_DIR = os.homedir();
+const BACKUP_DIR = path.join(HOME_DIR, '.teleportation', 'backups');
+const MAX_BACKUPS = 10;
+const MIN_BACKUP_AGE_DAYS = 7;
+
+/**
+ * Files and directories that may be modified during setup
+ */
+const BACKUP_TARGETS = [
+  {
+    name: 'claude-settings',
+    path: path.join(HOME_DIR, '.claude', 'settings.json'),
+    type: 'file',
+    description: 'Claude Code settings'
+  },
+  {
+    name: 'claude-hooks',
+    path: path.join(HOME_DIR, '.claude', 'hooks'),
+    type: 'directory',
+    description: 'Claude Code hooks'
+  },
+  {
+    name: 'teleportation-config',
+    path: path.join(HOME_DIR, '.teleportation', 'config.json'),
+    type: 'file',
+    description: 'Teleportation configuration'
+  },
+  {
+    name: 'teleportation-credentials',
+    path: path.join(HOME_DIR, '.teleportation', 'credentials'),
+    type: 'file',
+    description: 'Teleportation credentials'
+  }
+];
+
+export class BackupManager {
+  constructor() {
+    this.backupDir = BACKUP_DIR;
+  }
+
+  /**
+   * Create a backup of all relevant files before making changes
+   * @param {string} reason - Why this backup is being created (e.g., "teleportation setup")
+   * @returns {Promise<{backupPath: string, manifest: object}>}
+   */
+  async createBackup(reason) {
+    // Add random suffix to prevent collisions if multiple backups in same millisecond
+    const randomSuffix = crypto.randomBytes(3).toString('hex');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-') + '-' + randomSuffix;
+    const backupPath = path.join(this.backupDir, timestamp);
+
+    // Ensure backup directory exists
+    fs.mkdirSync(backupPath, { recursive: true });
+
+    const manifest = {
+      timestamp: new Date().toISOString(),
+      reason,
+      version: '1.0.0',
+      files: []
+    };
+
+    // Backup each target
+    for (const target of BACKUP_TARGETS) {
+      if (!fs.existsSync(target.path)) {
+        continue; // Skip if doesn't exist
+      }
+
+      const backupName = target.type === 'directory'
+        ? target.name
+        : `${target.name}.json`;
+      const backupTarget = path.join(backupPath, backupName);
+
+      try {
+        if (target.type === 'directory') {
+          await this._copyDirectoryWithPermissions(target.path, backupTarget);
+          const files = fs.readdirSync(target.path);
+          manifest.files.push({
+            original: target.path,
+            backup: backupName,
+            type: 'directory',
+            existed: true,
+            fileCount: files.length,
+            files: files,
+            description: target.description
+          });
+        } else {
+          // Copy file and preserve permissions
+          fs.copyFileSync(target.path, backupTarget);
+          const srcStat = fs.statSync(target.path);
+          fs.chmodSync(backupTarget, srcStat.mode);
+          const hash = await this._hashFile(target.path);
+          manifest.files.push({
+            original: target.path,
+            backup: backupName,
+            type: 'file',
+            existed: true,
+            hash: target.name.includes('credentials') ? undefined : hash,
+            description: target.description
+          });
+        }
+      } catch (err) {
+        console.error(`Warning: Failed to backup ${target.path}: ${err.message}`);
+      }
+    }
+
+    // Save manifest
+    manifest.canRollback = manifest.files.length > 0;
+    fs.writeFileSync(
+      path.join(backupPath, 'manifest.json'),
+      JSON.stringify(manifest, null, 2)
+    );
+
+    // Update 'latest' symlink
+    await this._updateLatestLink(timestamp);
+
+    // Cleanup old backups
+    await this._cleanupOldBackups();
+
+    return { backupPath, manifest };
+  }
+
+  /**
+   * Restore from a backup
+   * @param {string|null} backupId - Specific backup ID or null for latest
+   * @returns {Promise<{manifest: object, restoredFiles: string[]}>}
+   */
+  async restore(backupId = null) {
+    let backupPath;
+
+    if (backupId) {
+      backupPath = path.join(this.backupDir, backupId);
+    } else {
+      // Use latest (with symlink fallback support)
+      backupPath = this._resolveLatest();
+      if (!backupPath) {
+        throw new Error('No backups found');
+      }
+    }
+
+    const manifestPath = path.join(backupPath, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+      throw new Error(`No backup manifest found at ${backupPath}`);
+    }
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const restoredFiles = [];
+    const failedFiles = [];
+
+    for (const file of manifest.files) {
+      const backupFile = path.join(backupPath, file.backup);
+
+      if (!fs.existsSync(backupFile)) {
+        console.error(`Warning: Backup file not found: ${backupFile}`);
+        failedFiles.push({ path: file.original, reason: 'Backup file not found' });
+        continue;
+      }
+
+      try {
+        if (file.type === 'directory') {
+          // Remove existing directory first
+          if (fs.existsSync(file.original)) {
+            fs.rmSync(file.original, { recursive: true, force: true });
+          }
+          await this._copyDirectoryWithPermissions(backupFile, file.original);
+        } else {
+          // Ensure parent directory exists
+          const parentDir = path.dirname(file.original);
+          if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+          }
+          // Copy file and preserve permissions
+          fs.copyFileSync(backupFile, file.original);
+          const backupStat = fs.statSync(backupFile);
+          fs.chmodSync(file.original, backupStat.mode);
+        }
+        restoredFiles.push(file.original);
+      } catch (err) {
+        console.error(`Warning: Failed to restore ${file.original}: ${err.message}`);
+        failedFiles.push({ path: file.original, reason: err.message });
+      }
+    }
+
+    return { manifest, restoredFiles, failedFiles };
+  }
+
+  /**
+   * List all available backups
+   * @returns {Array<{id: string, timestamp: string, reason: string, fileCount: number}>}
+   */
+  listBackups() {
+    if (!fs.existsSync(this.backupDir)) {
+      return [];
+    }
+
+    const backups = [];
+    const entries = fs.readdirSync(this.backupDir);
+
+    for (const entry of entries) {
+      if (entry === 'latest') continue;
+
+      const entryPath = path.join(this.backupDir, entry);
+      const stat = fs.statSync(entryPath);
+
+      if (!stat.isDirectory()) continue;
+
+      const manifestPath = path.join(entryPath, 'manifest.json');
+      if (!fs.existsSync(manifestPath)) continue;
+
+      try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        backups.push({
+          id: entry,
+          timestamp: manifest.timestamp,
+          reason: manifest.reason,
+          fileCount: manifest.files.length,
+          canRollback: manifest.canRollback
+        });
+      } catch (err) {
+        // Skip invalid manifests
+      }
+    }
+
+    // Sort by timestamp descending (newest first)
+    return backups.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  }
+
+  /**
+   * Get details of a specific backup
+   * @param {string} backupId
+   * @returns {object|null}
+   */
+  getBackupDetails(backupId) {
+    const manifestPath = path.join(this.backupDir, backupId, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  }
+
+  /**
+   * Check if there are any files that would be modified
+   * @returns {Array<{path: string, description: string, exists: boolean}>}
+   */
+  checkExistingFiles() {
+    const existing = [];
+
+    for (const target of BACKUP_TARGETS) {
+      if (fs.existsSync(target.path)) {
+        const info = {
+          path: target.path,
+          description: target.description,
+          exists: true
+        };
+
+        if (target.type === 'directory') {
+          const files = fs.readdirSync(target.path);
+          info.fileCount = files.length;
+          info.files = files;
+        }
+
+        existing.push(info);
+      }
+    }
+
+    return existing;
+  }
+
+  /**
+   * Delete a specific backup
+   * @param {string} backupId
+   */
+  deleteBackup(backupId) {
+    const backupPath = path.join(this.backupDir, backupId);
+    if (fs.existsSync(backupPath)) {
+      fs.rmSync(backupPath, { recursive: true, force: true });
+    }
+
+    // Update latest link if needed (handles both symlink and fallback file)
+    const latestLink = path.join(this.backupDir, 'latest');
+    if (fs.existsSync(latestLink)) {
+      try {
+        const stat = fs.lstatSync(latestLink);
+        let latestTarget;
+
+        if (stat.isSymbolicLink()) {
+          // It's a symlink - read target directly
+          latestTarget = fs.readlinkSync(latestLink);
+        } else {
+          // It's a fallback file (Windows compat) - read content as target ID
+          latestTarget = fs.readFileSync(latestLink, 'utf8').trim();
+        }
+
+        if (latestTarget === backupId) {
+          fs.unlinkSync(latestLink);
+          // Point to next most recent
+          const backups = this.listBackups();
+          if (backups.length > 0) {
+            // Use _updateLatestLink to handle symlink/fallback consistently
+            this._updateLatestLink(backups[0].id);
+          }
+        }
+      } catch (err) {
+        // If we can't read the latest link, just remove it
+        try {
+          fs.unlinkSync(latestLink);
+        } catch {
+          // Ignore errors removing latest link
+        }
+      }
+    }
+  }
+
+  /**
+   * Clean up old backups beyond retention limit
+   */
+  async _cleanupOldBackups() {
+    const backups = this.listBackups();
+
+    if (backups.length <= MAX_BACKUPS) {
+      return;
+    }
+
+    const now = Date.now();
+    const minAgeMs = MIN_BACKUP_AGE_DAYS * 24 * 60 * 60 * 1000;
+
+    // Keep MAX_BACKUPS, but never delete backups less than MIN_BACKUP_AGE_DAYS old
+    const toDelete = backups.slice(MAX_BACKUPS).filter(backup => {
+      const backupTime = new Date(backup.timestamp).getTime();
+      return (now - backupTime) > minAgeMs;
+    });
+
+    for (const backup of toDelete) {
+      this.deleteBackup(backup.id);
+    }
+  }
+
+  /**
+   * Update the 'latest' symlink (with fallback to regular file for Windows compatibility)
+   */
+  async _updateLatestLink(targetId) {
+    const latestLink = path.join(this.backupDir, 'latest');
+
+    try {
+      // Remove existing link/file
+      if (fs.existsSync(latestLink)) {
+        fs.unlinkSync(latestLink);
+      }
+
+      // Try to create symlink first
+      try {
+        fs.symlinkSync(targetId, latestLink);
+      } catch (symlinkErr) {
+        // Fallback: create a regular file containing the target ID (Windows compatibility)
+        fs.writeFileSync(latestLink, targetId, 'utf8');
+      }
+    } catch (err) {
+      // Symlinks might fail on some systems, that's ok
+      console.error(`Warning: Could not create latest symlink: ${err.message}`);
+    }
+  }
+
+  /**
+   * Resolve 'latest' to actual backup path (supports both symlink and fallback file)
+   */
+  _resolveLatest() {
+    const latestLink = path.join(this.backupDir, 'latest');
+
+    if (!fs.existsSync(latestLink)) {
+      return null;
+    }
+
+    try {
+      // Try symlink first
+      const stat = fs.lstatSync(latestLink);
+      if (stat.isSymbolicLink()) {
+        return fs.realpathSync(latestLink);
+      }
+
+      // Fallback: read as file containing target ID
+      const targetId = fs.readFileSync(latestLink, 'utf8').trim();
+      const targetPath = path.join(this.backupDir, targetId);
+      if (fs.existsSync(targetPath)) {
+        return targetPath;
+      }
+    } catch (err) {
+      // Try direct realpath as last resort
+      try {
+        return fs.realpathSync(latestLink);
+      } catch {
+        return null;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Copy a directory recursively (basic, without permission preservation)
+   */
+  async _copyDirectory(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this._copyDirectory(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Copy a directory recursively with permission preservation
+   */
+  async _copyDirectoryWithPermissions(src, dest) {
+    const srcStat = fs.statSync(src);
+    fs.mkdirSync(dest, { recursive: true, mode: srcStat.mode });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this._copyDirectoryWithPermissions(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+        const fileStat = fs.statSync(srcPath);
+        fs.chmodSync(destPath, fileStat.mode);
+      }
+    }
+  }
+
+  /**
+   * Calculate SHA256 hash of a file
+   */
+  async _hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return 'sha256:' + crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  }
+}
+
+export default BackupManager;