zuppaclaude 1.3.4 → 1.3.5

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/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/package.json

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