zuppaclaude 1.3.3 → 1.3.5

package/bin/zuppaclaude.js

@@ -8,6 +8,7 @@
 const { Installer } = require('../lib/installer');
 const { Settings } = require('../lib/settings');
 const { Logger } = require('../lib/utils/logger');
+const { UpdateManager } = require('../lib/components/updater');
 
 const args = process.argv.slice(2);
 const command = args[0] || 'install';
@@ -23,11 +24,26 @@ function getCloudArg(args) {
   return null;
 }
 
+/**
+ * Check for updates at startup (non-blocking for some commands)
+ */
+async function checkUpdates(skipCommands = ['version', 'v', '-v', '--version', 'help', 'h', '-h', '--help', 'update']) {
+  if (skipCommands.includes(command)) {
+    return;
+  }
+
+  const updater = new UpdateManager();
+  await updater.checkAndUpdate();
+}
+
 async function main() {
   const logger = new Logger();
 
   logger.banner();
 
+  // Check for updates at startup
+  await checkUpdates();
+
   try {
     switch (command) {
       case 'install':
@@ -192,6 +208,37 @@ async function main() {
         }
         break;
 
+      case 'update':
+        const updateMgr = new UpdateManager();
+        const updateCmd = args[1] || 'check';
+
+        switch (updateCmd) {
+          case 'check':
+            await updateMgr.status();
+            break;
+          case 'now':
+          case 'install':
+            const result = await updateMgr.checkForUpdates();
+            if (result.hasUpdate) {
+              await updateMgr.update();
+            } else {
+              logger.success('You are already on the latest version');
+            }
+            break;
+          case 'enable':
+          case 'on':
+            updateMgr.enableAutoUpdate();
+            break;
+          case 'disable':
+          case 'off':
+            updateMgr.disableAutoUpdate();
+            break;
+          default:
+            logger.error(`Unknown update command: ${updateCmd}`);
+            showUpdateHelp();
+        }
+        break;
+
       case 'version':
       case 'v':
       case '-v':
@@ -233,6 +280,7 @@ Commands:
   settings, s         Manage settings
   session             Manage Claude Code sessions
   cloud               Manage cloud remotes (rclone)
+  update              Check for updates and manage auto-update
   version, v          Show version
   help, h             Show this help
 
@@ -249,6 +297,12 @@ Cloud Commands:
   cloud download <r>   Download backups from remote
   cloud backups <r>    List cloud backups
 
+Update Commands:
+  update               Check for updates
+  update now           Update to latest version
+  update enable        Enable auto-update (default)
+  update disable       Disable auto-update
+
 Session Commands:
   session list         List all sessions
   session backup       Backup sessions only
@@ -262,6 +316,7 @@ Examples:
   npx zuppaclaude backup --cloud gdrive        # Backup to Google Drive
   npx zuppaclaude restore 2026-01-05T12-00-00  # Restore from backup
   npx zuppaclaude cloud setup                  # Configure cloud
+  npx zuppaclaude update                       # Check for updates
 `);
 }
 
@@ -321,4 +376,20 @@ Supported providers (via rclone):
 `);
 }
 
+function showUpdateHelp() {
+  console.log(`
+Update Commands:
+  check      Check for updates (default)
+  now        Update to latest version immediately
+  enable     Enable auto-update at startup
+  disable    Disable auto-update
+
+Examples:
+  zuppaclaude update                         # Check for updates
+  zuppaclaude update now                     # Update immediately
+  zuppaclaude update enable                  # Enable auto-update
+  zuppaclaude update disable                 # Disable auto-update
+`);
+}
+
 main();

package/lib/components/backup.js

@@ -40,26 +40,30 @@ class BackupManager {
       this.logger.warning('No sessions to backup');
     }
 
-    // Step 2: Backup settings to the same directory
+    // Step 2: Backup settings to settings/{timestamp} directory
     this.logger.step('Step 2/3: Backing up ZuppaClaude settings...');
 
+    let settingsBackupPath = null;
     if (sessionResult) {
-      const settingsBackupPath = path.join(sessionResult.path, 'zc-settings.json');
+      const settingsDir = path.join(this.backupDir, 'settings', sessionResult.timestamp);
+      this.platform.ensureDir(settingsDir);
+      settingsBackupPath = path.join(settingsDir, 'zc-settings.json');
       const currentSettings = this.settings.load();
 
       if (currentSettings) {
         fs.writeFileSync(settingsBackupPath, JSON.stringify(currentSettings, null, 2));
-        this.logger.success('Settings backed up');
+        this.logger.success(`Settings backed up to settings/${sessionResult.timestamp}/`);
       } else {
         this.logger.info('No settings to backup');
       }
 
-      // Update manifest with settings info
+      // Update manifest in sessions backup with settings info
       const manifestPath = path.join(sessionResult.path, 'manifest.json');
       if (fs.existsSync(manifestPath)) {
         const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
         manifest.settings = currentSettings ? true : false;
         manifest.backupType = 'full';
+        manifest.settingsPath = `settings/${sessionResult.timestamp}`;
         fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
       }
     }
@@ -119,9 +123,10 @@ class BackupManager {
       this.logger.info('Step 1/3: Using local backup');
     }
 
-    const backupPath = path.join(this.backupDir, backupId);
+    const sessionsBackupPath = path.join(this.backupDir, 'sessions', backupId);
+    const settingsBackupDir = path.join(this.backupDir, 'settings', backupId);
 
-    if (!fs.existsSync(backupPath)) {
+    if (!fs.existsSync(sessionsBackupPath)) {
       this.logger.error(`Backup not found: ${backupId}`);
       this.logger.info('Run "npx zuppaclaude backup list" to see available backups');
       return false;
@@ -138,11 +143,11 @@ class BackupManager {
       this.logger.info('Step 2/3: Sessions restore skipped');
     }
 
-    // Step 3: Restore settings
+    // Step 3: Restore settings from settings/{timestamp}/
     if (!sessionsOnly) {
       this.logger.step('Step 3/3: Restoring settings...');
 
-      const settingsBackupPath = path.join(backupPath, 'zc-settings.json');
+      const settingsBackupPath = path.join(settingsBackupDir, 'zc-settings.json');
 
       if (fs.existsSync(settingsBackupPath)) {
         try {

package/lib/components/cloud.js

@@ -386,7 +386,57 @@ class CloudManager {
   }
 
   /**
-   * Upload backup to cloud
+   * Create zip file from directory
+   */
+  createZip(sourceDir, zipPath) {
+    try {
+      const parentDir = path.dirname(sourceDir);
+      const folderName = path.basename(sourceDir);
+
+      if (this.platform.isWindows) {
+        // Use PowerShell on Windows
+        this.platform.exec(
+          `powershell -command "Compress-Archive -Path '${sourceDir}' -DestinationPath '${zipPath}' -Force"`,
+          { silent: true }
+        );
+      } else {
+        // Use zip on macOS/Linux
+        this.platform.exec(
+          `cd "${parentDir}" && zip -r "${zipPath}" "${folderName}"`,
+          { silent: true }
+        );
+      }
+      return true;
+    } catch (error) {
+      this.logger.warning(`Failed to create zip: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Extract zip file
+   */
+  extractZip(zipPath, destDir) {
+    try {
+      this.platform.ensureDir(destDir);
+
+      if (this.platform.isWindows) {
+        this.platform.exec(
+          `powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`,
+          { silent: true }
+        );
+      } else {
+        this.platform.exec(`unzip -o "${zipPath}" -d "${destDir}"`, { silent: true });
+      }
+      return true;
+    } catch (error) {
+      this.logger.warning(`Failed to extract zip: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Upload backup to cloud (as zip)
    */
   async upload(remote, backupId = null) {
     if (!this.isRcloneInstalled()) {
@@ -401,20 +451,16 @@ class CloudManager {
       return false;
     }
 
-    // Determine what to upload
-    let sourcePath = this.backupDir;
-    let destPath = `${remote}:${this.cloudPath}`;
-
+    // Upload specific backup or all backups
     if (backupId) {
-      sourcePath = path.join(this.backupDir, backupId);
-      if (!fs.existsSync(sourcePath)) {
-        this.logger.error(`Backup not found: ${backupId}`);
-        return false;
-      }
-      destPath = `${remote}:${this.cloudPath}/${backupId}`;
+      return await this.uploadSingleBackup(remote, backupId);
     }
 
-    if (!fs.existsSync(sourcePath)) {
+    // Upload all backups (sessions and settings folders)
+    const sessionsDir = path.join(this.backupDir, 'sessions');
+    const settingsDir = path.join(this.backupDir, 'settings');
+
+    if (!fs.existsSync(sessionsDir) && !fs.existsSync(settingsDir)) {
       this.logger.error('No backups to upload');
       this.logger.info('Run "npx zuppaclaude backup" first');
       return false;
@@ -424,23 +470,130 @@ class CloudManager {
     this.logger.step(`Uploading to ${remote}...`);
     console.log('');
 
+    let uploaded = 0;
+
+    // Get all backup timestamps from sessions folder
+    if (fs.existsSync(sessionsDir)) {
+      const backupFolders = fs.readdirSync(sessionsDir).filter(name => {
+        return fs.statSync(path.join(sessionsDir, name)).isDirectory();
+      });
+
+      for (const folder of backupFolders) {
+        const success = await this.uploadSingleBackup(remote, folder);
+        if (success) uploaded++;
+      }
+    }
+
+    console.log('');
+    this.logger.success(`Uploaded ${uploaded} backup(s) to ${remote}:${this.cloudPath}/`);
+    console.log('');
+    return true;
+  }
+
+  /**
+   * Upload a single backup as zip
+   */
+  async uploadSingleBackup(remote, backupId) {
+    const sessionsPath = path.join(this.backupDir, 'sessions', backupId);
+    const settingsPath = path.join(this.backupDir, 'settings', backupId);
+
+    if (!fs.existsSync(sessionsPath)) {
+      this.logger.error(`Backup not found: ${backupId}`);
+      return false;
+    }
+
+    // Create temp directory for zip
+    const tempDir = path.join(this.backupDir, '.temp');
+    this.platform.ensureDir(tempDir);
+
+    const zipFileName = `${backupId}.zip`;
+    const zipPath = path.join(tempDir, zipFileName);
+
+    this.logger.info(`Compressing ${backupId}...`);
+
+    // Create a combined backup folder
+    const combinedDir = path.join(tempDir, backupId);
+    this.platform.ensureDir(combinedDir);
+
+    // Copy sessions
+    const sessionsDestDir = path.join(combinedDir, 'sessions');
+    this.platform.ensureDir(sessionsDestDir);
     try {
-      // Use rclone sync for efficiency
-      const cmd = `rclone sync "${sourcePath}" "${destPath}" --progress`;
+      this.platform.exec(`cp -r "${sessionsPath}"/* "${sessionsDestDir}/"`, { silent: true });
+    } catch (e) {
+      // Fallback: copy the directory itself
+      this.platform.exec(`cp -r "${sessionsPath}" "${combinedDir}/"`, { silent: true });
+    }
+
+    // Copy settings if exists and has content
+    if (fs.existsSync(settingsPath)) {
+      const settingsFiles = fs.readdirSync(settingsPath);
+      if (settingsFiles.length > 0) {
+        const settingsDestDir = path.join(combinedDir, 'settings');
+        this.platform.ensureDir(settingsDestDir);
+        try {
+          this.platform.exec(`cp -r "${settingsPath}"/* "${settingsDestDir}/"`, { silent: true });
+        } catch (e) {
+          // Ignore if empty
+        }
+      }
+    }
+
+    // Create zip
+    const zipCreated = this.createZip(combinedDir, zipPath);
+    if (!zipCreated) {
+      this.logger.error('Failed to create zip');
+      return false;
+    }
+
+    const zipSize = fs.statSync(zipPath).size;
+    this.logger.info(`Zip size: ${this.formatSize(zipSize)}`);
+
+    // Upload zip
+    const destPath = `${remote}:${this.cloudPath}/${zipFileName}`;
+
+    try {
+      this.logger.info(`Uploading ${zipFileName}...`);
+      const cmd = `rclone copy "${zipPath}" "${remote}:${this.cloudPath}/" --progress`;
       this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
 
-      console.log('');
-      this.logger.success(`Backup uploaded to ${remote}:${this.cloudPath}`);
-      console.log('');
+      this.logger.success(`Uploaded ${zipFileName}`);
+
+      // Cleanup: delete temp files
+      try {
+        fs.unlinkSync(zipPath);
+        fs.rmSync(combinedDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+
       return true;
     } catch (error) {
       this.logger.error(`Upload failed: ${error.message}`);
+
+      // Cleanup on error
+      try {
+        fs.unlinkSync(zipPath);
+        fs.rmSync(combinedDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore
+      }
+
       return false;
     }
   }
 
   /**
-   * Download backup from cloud
+   * Format file size
+   */
+  formatSize(bytes) {
+    if (bytes < 1024) return bytes + ' B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+    return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+  }
+
+  /**
+   * Download backup from cloud (downloads and extracts zip)
    */
   async download(remote, backupId = null) {
     if (!this.isRcloneInstalled()) {
@@ -454,26 +607,42 @@ class CloudManager {
       return false;
     }
 
-    let sourcePath = `${remote}:${this.cloudPath}`;
-    let destPath = this.backupDir;
-
+    // Download specific backup or all backups
     if (backupId) {
-      sourcePath = `${remote}:${this.cloudPath}/${backupId}`;
-      destPath = path.join(this.backupDir, backupId);
+      return await this.downloadSingleBackup(remote, backupId);
     }
 
-    this.platform.ensureDir(destPath);
-
+    // Download all backups
     console.log('');
     this.logger.step(`Downloading from ${remote}...`);
     console.log('');
 
     try {
-      const cmd = `rclone sync "${sourcePath}" "${destPath}" --progress`;
-      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+      // List all zip files in cloud
+      const cmd = `rclone lsf "${remote}:${this.cloudPath}/" --files-only 2>/dev/null`;
+      const output = this.platform.exec(cmd, { silent: true });
+
+      if (!output) {
+        this.logger.warning('No backups found on cloud');
+        return false;
+      }
+
+      const zipFiles = output.split('\n').filter(f => f.endsWith('.zip'));
+
+      if (zipFiles.length === 0) {
+        this.logger.warning('No backup archives found on cloud');
+        return false;
+      }
+
+      let downloaded = 0;
+      for (const zipFile of zipFiles) {
+        const backupName = zipFile.replace('.zip', '');
+        const success = await this.downloadSingleBackup(remote, backupName);
+        if (success) downloaded++;
+      }
 
       console.log('');
-      this.logger.success(`Backup downloaded from ${remote}`);
+      this.logger.success(`Downloaded ${downloaded} backup(s) from ${remote}`);
       console.log('');
       return true;
     } catch (error) {
@@ -483,7 +652,78 @@ class CloudManager {
   }
 
   /**
-   * List cloud backups
+   * Download and extract a single backup
+   */
+  async downloadSingleBackup(remote, backupId) {
+    const zipFileName = `${backupId}.zip`;
+    const tempDir = path.join(this.backupDir, '.temp');
+    this.platform.ensureDir(tempDir);
+    const zipPath = path.join(tempDir, zipFileName);
+
+    try {
+      // Download zip
+      this.logger.info(`Downloading ${zipFileName}...`);
+      const cmd = `rclone copy "${remote}:${this.cloudPath}/${zipFileName}" "${tempDir}/" --progress`;
+      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+
+      if (!fs.existsSync(zipPath)) {
+        this.logger.error(`Backup not found: ${backupId}`);
+        return false;
+      }
+
+      // Extract zip
+      this.logger.info(`Extracting ${zipFileName}...`);
+      const extractDir = path.join(tempDir, 'extract');
+      this.platform.ensureDir(extractDir);
+      this.extractZip(zipPath, extractDir);
+
+      // Move sessions and settings to proper locations
+      const extractedBackup = path.join(extractDir, backupId);
+
+      if (fs.existsSync(path.join(extractedBackup, 'sessions'))) {
+        const sessionsDir = path.join(this.backupDir, 'sessions', backupId);
+        this.platform.ensureDir(path.dirname(sessionsDir));
+        if (fs.existsSync(sessionsDir)) {
+          fs.rmSync(sessionsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(path.join(extractedBackup, 'sessions'), sessionsDir);
+      }
+
+      if (fs.existsSync(path.join(extractedBackup, 'settings'))) {
+        const settingsDir = path.join(this.backupDir, 'settings', backupId);
+        this.platform.ensureDir(path.dirname(settingsDir));
+        if (fs.existsSync(settingsDir)) {
+          fs.rmSync(settingsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(path.join(extractedBackup, 'settings'), settingsDir);
+      }
+
+      // Cleanup
+      try {
+        fs.unlinkSync(zipPath);
+        fs.rmSync(extractDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+
+      this.logger.success(`Downloaded ${backupId}`);
+      return true;
+    } catch (error) {
+      this.logger.error(`Failed to download ${backupId}: ${error.message}`);
+
+      // Cleanup on error
+      try {
+        if (fs.existsSync(zipPath)) fs.unlinkSync(zipPath);
+      } catch (e) {
+        // Ignore
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * List cloud backups (zip files)
    */
   async listCloudBackups(remote) {
     if (!this.isRcloneInstalled()) {
@@ -497,29 +737,25 @@ class CloudManager {
     }
 
     try {
-      const cmd = `rclone lsd "${remote}:${this.cloudPath}" 2>/dev/null`;
+      const cmd = `rclone lsf "${remote}:${this.cloudPath}/" --files-only 2>/dev/null`;
       const output = this.platform.exec(cmd, { silent: true });
 
+      console.log('');
+      console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+      console.log(`\x1b[35m                    Cloud Backups (${remote})\x1b[0m`);
+      console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+      console.log('');
+
       if (!output) {
-        this.logger.warning('No cloud backups found');
+        console.log('  No backups found');
+        console.log('');
         return [];
       }
 
       const backups = output
         .split('\n')
-        .filter(line => line.trim())
-        .map(line => {
-          const parts = line.trim().split(/\s+/);
-          const name = parts[parts.length - 1];
-          return name;
-        })
-        .filter(name => name && name.match(/^\d{4}-\d{2}-\d{2}T/));
-
-      console.log('');
-      console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
-      console.log(`\x1b[35m                    Cloud Backups (${remote})\x1b[0m`);
-      console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
-      console.log('');
+        .filter(f => f.endsWith('.zip'))
+        .map(f => f.replace('.zip', ''));
 
       if (backups.length === 0) {
         console.log('  No backups found');

package/lib/components/index.js

@@ -11,6 +11,7 @@ const { SessionManager } = require('./session');
 const { CloudManager } = require('./cloud');
 const { BackupManager } = require('./backup');
 const { CommandsInstaller } = require('./commands');
+const { UpdateManager } = require('./updater');
 
 module.exports = {
   SuperClaudeInstaller,
@@ -21,5 +22,6 @@ module.exports = {
   SessionManager,
   CloudManager,
   BackupManager,
-  CommandsInstaller
+  CommandsInstaller,
+  UpdateManager
 };

package/lib/components/session.js

@@ -119,6 +119,21 @@ class SessionManager {
     return projects;
   }
 
+  /**
+   * Format timestamp as Jan-05-2026-13.56
+   */
+  formatTimestamp(date = new Date()) {
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+                    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = months[date.getMonth()];
+    const day = String(date.getDate()).padStart(2, '0');
+    const year = date.getFullYear();
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+
+    return `${month}-${day}-${year}-${hours}.${minutes}`;
+  }
+
   /**
    * Backup all sessions
    */
@@ -130,10 +145,9 @@ class SessionManager {
       return null;
     }
 
-    // Create backup directory with timestamp
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const backupPath = path.join(this.backupDir, timestamp);
-    const sessionsBackupPath = path.join(backupPath, 'sessions');
+    // Create backup directory with timestamp (Jan-05-2026-13.56 format)
+    const timestamp = this.formatTimestamp();
+    const sessionsBackupPath = path.join(this.backupDir, 'sessions', timestamp);
 
     this.platform.ensureDir(sessionsBackupPath);
 
@@ -144,7 +158,8 @@ class SessionManager {
     let backedUp = 0;
     let totalSize = 0;
     const manifest = {
-      timestamp: new Date().toISOString(),
+      timestamp: timestamp,
+      timestampISO: new Date().toISOString(),
       version: require('../../package.json').version,
       projects: []
     };
@@ -186,7 +201,7 @@ class SessionManager {
     const historyPath = path.join(this.claudeDir, 'history.jsonl');
     if (fs.existsSync(historyPath)) {
       try {
-        fs.copyFileSync(historyPath, path.join(backupPath, 'history.jsonl'));
+        fs.copyFileSync(historyPath, path.join(sessionsBackupPath, 'history.jsonl'));
         const historyStats = fs.statSync(historyPath);
         manifest.history = {
           size: historyStats.size,
@@ -201,17 +216,17 @@ class SessionManager {
 
     // Save manifest
     fs.writeFileSync(
-      path.join(backupPath, 'manifest.json'),
+      path.join(sessionsBackupPath, 'manifest.json'),
       JSON.stringify(manifest, null, 2)
     );
 
     console.log('');
     this.logger.success(`Backup complete: ${backedUp} sessions, ${this.formatSize(totalSize)}`);
-    this.logger.info(`Location: ${backupPath}`);
+    this.logger.info(`Location: ${sessionsBackupPath}`);
     console.log('');
 
     return {
-      path: backupPath,
+      path: sessionsBackupPath,
       sessions: backedUp,
       size: totalSize,
       timestamp: timestamp
@@ -222,18 +237,20 @@ class SessionManager {
    * List available backups
    */
   listBackups() {
-    if (!fs.existsSync(this.backupDir)) {
+    const sessionsDir = path.join(this.backupDir, 'sessions');
+
+    if (!fs.existsSync(sessionsDir)) {
       this.logger.warning('No backups found');
       return [];
     }
 
-    const backups = fs.readdirSync(this.backupDir)
+    const backups = fs.readdirSync(sessionsDir)
       .filter(name => {
-        const backupPath = path.join(this.backupDir, name);
+        const backupPath = path.join(sessionsDir, name);
         return fs.statSync(backupPath).isDirectory();
       })
       .map(name => {
-        const backupPath = path.join(this.backupDir, name);
+        const backupPath = path.join(sessionsDir, name);
         const manifestPath = path.join(backupPath, 'manifest.json');
 
         let manifest = null;
@@ -271,7 +288,6 @@ class SessionManager {
     console.log('');
 
     for (const backup of backups) {
-      const dateStr = backup.id.replace('T', ' ').replace(/-/g, ':').slice(0, 16).replace(/:/g, '-').slice(0,10) + ' ' + backup.id.slice(11, 16).replace(/-/g, ':');
       console.log(`  📦 ${backup.id}`);
       console.log(`     ${backup.projects} projects, ${backup.sessions} sessions`);
       console.log('');
@@ -284,7 +300,7 @@ class SessionManager {
    * Restore from backup
    */
   restore(backupId) {
-    const backupPath = path.join(this.backupDir, backupId);
+    const backupPath = path.join(this.backupDir, 'sessions', backupId);
 
     if (!fs.existsSync(backupPath)) {
       this.logger.error(`Backup not found: ${backupId}`);
@@ -306,7 +322,8 @@ class SessionManager {
     let restored = 0;
 
     for (const project of manifest.projects) {
-      const projectBackupPath = path.join(backupPath, 'sessions', project.id);
+      // Sessions are directly under the backup path (not in a nested sessions folder)
+      const projectBackupPath = path.join(backupPath, project.id);
       const projectDestPath = path.join(this.projectsDir, project.id);
 
       if (!fs.existsSync(projectBackupPath)) continue;

package/lib/components/updater.js

@@ -0,0 +1,216 @@
+/**
+ * Auto-Update Manager
+ * Checks for updates and auto-updates if enabled
+ */
+
+const { execSync } = require('child_process');
+const https = require('https');
+const { Logger } = require('../utils/logger');
+const { Settings } = require('../settings');
+
+class UpdateManager {
+  constructor() {
+    this.logger = new Logger();
+    this.settings = new Settings();
+    this.packageName = 'zuppaclaude';
+    this.currentVersion = require('../../package.json').version;
+  }
+
+  /**
+   * Get latest version from npm
+   */
+  async getLatestVersion() {
+    return new Promise((resolve, reject) => {
+      const url = `https://registry.npmjs.org/${this.packageName}/latest`;
+
+      https.get(url, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.version);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }).on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Compare versions (returns true if latest > current)
+   */
+  isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map(Number);
+    const currentParts = current.split('.').map(Number);
+
+    for (let i = 0; i < 3; i++) {
+      if (latestParts[i] > currentParts[i]) return true;
+      if (latestParts[i] < currentParts[i]) return false;
+    }
+    return false;
+  }
+
+  /**
+   * Check for updates
+   */
+  async checkForUpdates(silent = false) {
+    try {
+      const latestVersion = await this.getLatestVersion();
+      const hasUpdate = this.isNewerVersion(latestVersion, this.currentVersion);
+
+      if (hasUpdate && !silent) {
+        console.log('');
+        console.log('\x1b[33m╔═══════════════════════════════════════════════════════════════════╗\x1b[0m');
+        console.log('\x1b[33m║   Update Available!                                               ║\x1b[0m');
+        console.log('\x1b[33m╚═══════════════════════════════════════════════════════════════════╝\x1b[0m');
+        console.log('');
+        console.log(`  Current version: \x1b[31m${this.currentVersion}\x1b[0m`);
+        console.log(`  Latest version:  \x1b[32m${latestVersion}\x1b[0m`);
+        console.log('');
+      }
+
+      return {
+        hasUpdate,
+        currentVersion: this.currentVersion,
+        latestVersion
+      };
+    } catch (error) {
+      // Silently fail - don't interrupt user workflow
+      return {
+        hasUpdate: false,
+        currentVersion: this.currentVersion,
+        latestVersion: null,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Update to latest version
+   */
+  async update() {
+    try {
+      this.logger.step('Updating ZuppaClaude...');
+
+      // Use npm to update globally
+      execSync(`npm install -g ${this.packageName}@latest`, {
+        stdio: 'inherit'
+      });
+
+      // Verify update
+      const newVersion = await this.getLatestVersion();
+      this.logger.success(`Updated to v${newVersion}`);
+
+      return true;
+    } catch (error) {
+      this.logger.error(`Update failed: ${error.message}`);
+      this.logger.info(`Manual update: npm install -g ${this.packageName}@latest`);
+      return false;
+    }
+  }
+
+  /**
+   * Check and auto-update if enabled
+   * Called at startup
+   */
+  async checkAndUpdate() {
+    const userSettings = this.settings.load() || {};
+    const autoUpdate = userSettings.autoUpdate !== false; // Default true
+
+    const result = await this.checkForUpdates(true);
+
+    if (result.hasUpdate) {
+      if (autoUpdate) {
+        console.log('');
+        console.log(`\x1b[36m[i]\x1b[0m New version available: v${result.latestVersion}`);
+        console.log('\x1b[36m[i]\x1b[0m Auto-updating...');
+        console.log('');
+
+        const updated = await this.update();
+
+        if (updated) {
+          console.log('');
+          console.log('\x1b[32m[✓]\x1b[0m Update complete! Please restart to use the new version.');
+          console.log('');
+          return { updated: true, version: result.latestVersion };
+        }
+      } else {
+        // Just notify
+        console.log('');
+        console.log(`\x1b[33m[!]\x1b[0m Update available: v${this.currentVersion} → v${result.latestVersion}`);
+        console.log(`\x1b[33m[!]\x1b[0m Run: npm install -g ${this.packageName}@latest`);
+        console.log('');
+        return { updated: false, version: result.latestVersion };
+      }
+    }
+
+    return { updated: false, version: this.currentVersion };
+  }
+
+  /**
+   * Enable auto-update
+   */
+  enableAutoUpdate() {
+    const userSettings = this.settings.load() || {};
+    userSettings.autoUpdate = true;
+    this.settings.save(userSettings);
+    this.logger.success('Auto-update enabled');
+  }
+
+  /**
+   * Disable auto-update
+   */
+  disableAutoUpdate() {
+    const userSettings = this.settings.load() || {};
+    userSettings.autoUpdate = false;
+    this.settings.save(userSettings);
+    this.logger.success('Auto-update disabled');
+  }
+
+  /**
+   * Show update status
+   */
+  async status() {
+    const userSettings = this.settings.load() || {};
+    const autoUpdate = userSettings.autoUpdate !== false;
+
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    Update Status\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+    console.log(`  Current version: \x1b[36m${this.currentVersion}\x1b[0m`);
+    console.log(`  Auto-update:     ${autoUpdate ? '\x1b[32menabled\x1b[0m' : '\x1b[31mdisabled\x1b[0m'}`);
+    console.log('');
+
+    this.logger.info('Checking for updates...');
+    const result = await this.checkForUpdates(true);
+
+    if (result.latestVersion) {
+      console.log(`  Latest version:  \x1b[36m${result.latestVersion}\x1b[0m`);
+
+      if (result.hasUpdate) {
+        console.log('');
+        console.log('  \x1b[33mUpdate available!\x1b[0m');
+        console.log(`  Run: \x1b[36mnpm install -g ${this.packageName}@latest\x1b[0m`);
+      } else {
+        console.log('');
+        console.log('  \x1b[32mYou are up to date!\x1b[0m');
+      }
+    } else {
+      console.log('  \x1b[31mCould not check for updates\x1b[0m');
+    }
+
+    console.log('');
+  }
+}
+
+module.exports = { UpdateManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuppaclaude",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Claude Code power-up installer - SuperClaude + Spec Kit + Claude-Z + Claude HUD",
   "main": "lib/index.js",
   "bin": {