zuppaclaude 1.3.5 → 1.3.7

package/bin/zuppaclaude.js

@@ -202,6 +202,21 @@ async function main() {
             }
             await cloudMgr.listCloudBackups(cloudRemote);
             break;
+          case 'delete':
+          case 'rm':
+            if (!cloudRemote) {
+              logger.error('Please specify remote');
+              logger.info('Usage: zuppaclaude cloud delete <remote> [backup-id]');
+              process.exit(1);
+            }
+            if (args[3]) {
+              // Direct delete with backup ID
+              await cloudMgr.deleteCloudBackup(cloudRemote, args[3]);
+            } else {
+              // Interactive delete menu
+              await cloudMgr.deleteCloudBackupInteractive(cloudRemote);
+            }
+            break;
           default:
             logger.error(`Unknown cloud command: ${cloudCmd}`);
             showCloudHelp();
@@ -296,6 +311,7 @@ Cloud Commands:
   cloud upload <r>     Upload backups to remote
   cloud download <r>   Download backups from remote
   cloud backups <r>    List cloud backups
+  cloud delete <r>     Delete backup from cloud (interactive)
 
 Update Commands:
   update               Check for updates
@@ -363,6 +379,7 @@ Cloud Commands (requires rclone):
   upload     Upload backups to a cloud remote
   download   Download backups from a cloud remote
   backups    List backups stored on a cloud remote
+  delete     Delete backup from cloud (interactive menu)
 
 Examples:
   zuppaclaude cloud setup                    # Setup instructions
@@ -370,6 +387,8 @@ Examples:
   zuppaclaude cloud upload gdrive            # Upload all backups
   zuppaclaude cloud download gdrive          # Download all backups
   zuppaclaude cloud backups gdrive           # List cloud backups
+  zuppaclaude cloud delete gdrive            # Interactive delete menu
+  zuppaclaude cloud delete gdrive Jan-05-2026-14.09  # Direct delete
 
 Supported providers (via rclone):
   Google Drive, Dropbox, OneDrive, S3, SFTP, FTP, and 40+ more

package/lib/components/backup.js

@@ -212,7 +212,7 @@ class BackupManager {
       console.log(`  📍 Location: ${result.path}`);
 
       if (cloud) {
-        console.log(`  ☁️ Cloud: ${cloud}:zuppaclaude-backups/${result.timestamp}`);
+        console.log(`  ☁️ Cloud: ${cloud}:zuppaclaude-backups/sessions/${result.timestamp}.zip`);
       }
     }
 

package/lib/components/cloud.js

@@ -491,7 +491,7 @@ class CloudManager {
   }
 
   /**
-   * Upload a single backup as zip
+   * Upload a single backup as separate zips (sessions + settings)
    */
   async uploadSingleBackup(remote, backupId) {
     const sessionsPath = path.join(this.backupDir, 'sessions', backupId);
@@ -507,80 +507,72 @@ class CloudManager {
     this.platform.ensureDir(tempDir);
 
     const zipFileName = `${backupId}.zip`;
-    const zipPath = path.join(tempDir, zipFileName);
+    let totalSize = 0;
+    let uploaded = 0;
 
-    this.logger.info(`Compressing ${backupId}...`);
+    // Upload sessions zip
+    this.logger.info(`Compressing sessions/${backupId}...`);
+    const sessionsZipPath = path.join(tempDir, `sessions-${zipFileName}`);
 
-    // Create a combined backup folder
-    const combinedDir = path.join(tempDir, backupId);
-    this.platform.ensureDir(combinedDir);
+    if (this.createZip(sessionsPath, sessionsZipPath)) {
+      const zipSize = fs.statSync(sessionsZipPath).size;
+      totalSize += zipSize;
+      this.logger.info(`Sessions zip: ${this.formatSize(zipSize)}`);
 
-    // Copy sessions
-    const sessionsDestDir = path.join(combinedDir, 'sessions');
-    this.platform.ensureDir(sessionsDestDir);
-    try {
-      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 });
+      try {
+        this.logger.info(`Uploading to sessions/${zipFileName}...`);
+        const cmd = `rclone copy "${sessionsZipPath}" "${remote}:${this.cloudPath}/sessions/" --progress`;
+        this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+
+        // Rename on remote to remove 'sessions-' prefix
+        this.platform.exec(`rclone moveto "${remote}:${this.cloudPath}/sessions/sessions-${zipFileName}" "${remote}:${this.cloudPath}/sessions/${zipFileName}"`, { silent: true });
+
+        uploaded++;
+      } catch (error) {
+        this.logger.error(`Failed to upload sessions: ${error.message}`);
+      }
+
+      // Cleanup
+      try { fs.unlinkSync(sessionsZipPath); } catch (e) {}
     }
 
-    // Copy settings if exists and has content
+    // Upload settings zip 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;
-    }
+        this.logger.info(`Compressing settings/${backupId}...`);
+        const settingsZipPath = path.join(tempDir, `settings-${zipFileName}`);
 
-    const zipSize = fs.statSync(zipPath).size;
-    this.logger.info(`Zip size: ${this.formatSize(zipSize)}`);
+        if (this.createZip(settingsPath, settingsZipPath)) {
+          const zipSize = fs.statSync(settingsZipPath).size;
+          totalSize += zipSize;
+          this.logger.info(`Settings zip: ${this.formatSize(zipSize)}`);
 
-    // Upload zip
-    const destPath = `${remote}:${this.cloudPath}/${zipFileName}`;
+          try {
+            this.logger.info(`Uploading to settings/${zipFileName}...`);
+            const cmd = `rclone copy "${settingsZipPath}" "${remote}:${this.cloudPath}/settings/" --progress`;
+            this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
 
-    try {
-      this.logger.info(`Uploading ${zipFileName}...`);
-      const cmd = `rclone copy "${zipPath}" "${remote}:${this.cloudPath}/" --progress`;
-      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+            // Rename on remote
+            this.platform.exec(`rclone moveto "${remote}:${this.cloudPath}/settings/settings-${zipFileName}" "${remote}:${this.cloudPath}/settings/${zipFileName}"`, { silent: true });
 
-      this.logger.success(`Uploaded ${zipFileName}`);
+            uploaded++;
+          } catch (error) {
+            this.logger.error(`Failed to upload settings: ${error.message}`);
+          }
 
-      // Cleanup: delete temp files
-      try {
-        fs.unlinkSync(zipPath);
-        fs.rmSync(combinedDir, { recursive: true, force: true });
-      } catch (e) {
-        // Ignore cleanup errors
+          // Cleanup
+          try { fs.unlinkSync(settingsZipPath); } catch (e) {}
+        }
       }
+    }
 
+    if (uploaded > 0) {
+      this.logger.success(`Uploaded ${backupId} (${this.formatSize(totalSize)})`);
       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;
     }
+
+    return false;
   }
 
   /**
@@ -652,78 +644,218 @@ class CloudManager {
   }
 
   /**
-   * Download and extract a single backup
+   * Download and extract a single backup (from sessions/ and settings/ folders)
    */
   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);
 
+    let downloaded = 0;
+
+    // Download sessions zip
+    const sessionsZipPath = path.join(tempDir, `sessions-${zipFileName}`);
     try {
-      // Download zip
-      this.logger.info(`Downloading ${zipFileName}...`);
-      const cmd = `rclone copy "${remote}:${this.cloudPath}/${zipFileName}" "${tempDir}/" --progress`;
+      this.logger.info(`Downloading sessions/${zipFileName}...`);
+      const cmd = `rclone copy "${remote}:${this.cloudPath}/sessions/${zipFileName}" "${tempDir}/" --progress`;
       this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
 
-      if (!fs.existsSync(zipPath)) {
-        this.logger.error(`Backup not found: ${backupId}`);
-        return false;
+      // Check if downloaded (rclone names it as the original)
+      const downloadedPath = path.join(tempDir, zipFileName);
+      if (fs.existsSync(downloadedPath)) {
+        fs.renameSync(downloadedPath, sessionsZipPath);
       }
 
-      // 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'))) {
+      if (fs.existsSync(sessionsZipPath)) {
+        this.logger.info(`Extracting 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 });
+        this.platform.ensureDir(sessionsDir);
+        this.extractZip(sessionsZipPath, sessionsDir);
+
+        // Move contents up if nested
+        const nestedDir = path.join(sessionsDir, backupId);
+        if (fs.existsSync(nestedDir)) {
+          const files = fs.readdirSync(nestedDir);
+          for (const file of files) {
+            fs.renameSync(path.join(nestedDir, file), path.join(sessionsDir, file));
+          }
+          fs.rmdirSync(nestedDir);
         }
-        fs.renameSync(path.join(extractedBackup, 'sessions'), sessionsDir);
+
+        downloaded++;
+        try { fs.unlinkSync(sessionsZipPath); } catch (e) {}
+      }
+    } catch (error) {
+      this.logger.warning(`Sessions not found or failed: ${error.message}`);
+    }
+
+    // Download settings zip
+    const settingsZipPath = path.join(tempDir, `settings-${zipFileName}`);
+    try {
+      this.logger.info(`Downloading settings/${zipFileName}...`);
+      const cmd = `rclone copy "${remote}:${this.cloudPath}/settings/${zipFileName}" "${tempDir}/" --progress`;
+      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+
+      const downloadedPath = path.join(tempDir, zipFileName);
+      if (fs.existsSync(downloadedPath)) {
+        fs.renameSync(downloadedPath, settingsZipPath);
       }
 
-      if (fs.existsSync(path.join(extractedBackup, 'settings'))) {
+      if (fs.existsSync(settingsZipPath)) {
+        this.logger.info(`Extracting 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 });
+        this.platform.ensureDir(settingsDir);
+        this.extractZip(settingsZipPath, settingsDir);
+
+        // Move contents up if nested
+        const nestedDir = path.join(settingsDir, backupId);
+        if (fs.existsSync(nestedDir)) {
+          const files = fs.readdirSync(nestedDir);
+          for (const file of files) {
+            fs.renameSync(path.join(nestedDir, file), path.join(settingsDir, file));
+          }
+          fs.rmdirSync(nestedDir);
         }
-        fs.renameSync(path.join(extractedBackup, 'settings'), settingsDir);
-      }
 
-      // Cleanup
-      try {
-        fs.unlinkSync(zipPath);
-        fs.rmSync(extractDir, { recursive: true, force: true });
-      } catch (e) {
-        // Ignore cleanup errors
+        downloaded++;
+        try { fs.unlinkSync(settingsZipPath); } catch (e) {}
       }
+    } catch (error) {
+      // Settings might not exist, that's ok
+    }
 
+    if (downloaded > 0) {
       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
-      }
+    this.logger.error(`Backup not found: ${backupId}`);
+    return false;
+  }
+
+  /**
+   * Delete a backup from cloud (both sessions and settings)
+   */
+  async deleteCloudBackup(remote, backupId) {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      return false;
+    }
+
+    if (!this.remoteExists(remote)) {
+      this.logger.error(`Remote not found: ${remote}`);
+      return false;
+    }
+
+    const zipFileName = `${backupId}.zip`;
+    let deleted = 0;
+
+    this.logger.step(`Deleting ${backupId} from ${remote}...`);
+
+    // Delete sessions zip
+    try {
+      const sessionsPath = `${remote}:${this.cloudPath}/sessions/${zipFileName}`;
+      this.platform.exec(`rclone delete "${sessionsPath}"`, { silent: true });
+      deleted++;
+    } catch (e) {
+      // Ignore
+    }
+
+    // Delete settings zip
+    try {
+      const settingsPath = `${remote}:${this.cloudPath}/settings/${zipFileName}`;
+      this.platform.exec(`rclone delete "${settingsPath}"`, { silent: true });
+      deleted++;
+    } catch (e) {
+      // Ignore
+    }
+
+    if (deleted > 0) {
+      this.logger.success(`Deleted ${backupId} from ${remote}`);
+      return true;
+    }
+
+    this.logger.error(`Backup not found on cloud: ${backupId}`);
+    return false;
+  }
+
+  /**
+   * Interactive delete - show list and let user choose
+   */
+  async deleteCloudBackupInteractive(remote) {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      return false;
+    }
+
+    if (!this.remoteExists(remote)) {
+      this.logger.error(`Remote not found: ${remote}`);
+      return false;
+    }
+
+    // Get list of backups
+    const backups = await this.getCloudBackupList(remote);
+
+    if (backups.length === 0) {
+      this.logger.warning('No backups found on cloud');
+      return false;
+    }
 
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log(`\x1b[35m                    Delete Cloud Backup (${remote})\x1b[0m`);
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    // Show numbered list
+    for (let i = 0; i < backups.length; i++) {
+      console.log(`  ${i + 1}. 📦 ${backups[i]}`);
+    }
+    console.log(`  ${backups.length + 1}. ❌ Cancel`);
+    console.log('');
+
+    // Get user choice
+    const choice = await this.prompts.number(`Select backup to delete (1-${backups.length + 1}):`, 1, backups.length + 1);
+
+    if (choice === backups.length + 1 || choice === null) {
+      this.logger.info('Cancelled');
       return false;
     }
+
+    const selectedBackup = backups[choice - 1];
+
+    // Confirm deletion
+    const confirm = await this.prompts.confirm(`Delete "${selectedBackup}" from ${remote}?`, false);
+
+    if (!confirm) {
+      this.logger.info('Cancelled');
+      return false;
+    }
+
+    return await this.deleteCloudBackup(remote, selectedBackup);
   }
 
   /**
-   * List cloud backups (zip files)
+   * Get list of cloud backups (without printing) - looks in sessions folder
+   */
+  async getCloudBackupList(remote) {
+    try {
+      const cmd = `rclone lsf "${remote}:${this.cloudPath}/sessions/" --files-only 2>/dev/null`;
+      const output = this.platform.exec(cmd, { silent: true });
+
+      if (!output) return [];
+
+      return output
+        .split('\n')
+        .filter(f => f.endsWith('.zip'))
+        .map(f => f.replace('.zip', ''));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * List cloud backups (from sessions folder)
    */
   async listCloudBackups(remote) {
     if (!this.isRcloneInstalled()) {
@@ -737,7 +869,7 @@ class CloudManager {
     }
 
     try {
-      const cmd = `rclone lsf "${remote}:${this.cloudPath}/" --files-only 2>/dev/null`;
+      const cmd = `rclone lsf "${remote}:${this.cloudPath}/sessions/" --files-only 2>/dev/null`;
       const output = this.platform.exec(cmd, { silent: true });
 
       console.log('');
@@ -745,6 +877,8 @@ class CloudManager {
       console.log(`\x1b[35m                    Cloud Backups (${remote})\x1b[0m`);
       console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
       console.log('');
+      console.log(`  Path: ${remote}:${this.cloudPath}/`);
+      console.log('');
 
       if (!output) {
         console.log('  No backups found');
@@ -762,6 +896,7 @@ class CloudManager {
       } else {
         for (const backup of backups) {
           console.log(`  📦 ${backup}`);
+          console.log(`     └── sessions/${backup}.zip`);
         }
       }
 

package/lib/utils/prompts.js

@@ -129,6 +129,24 @@ class Prompts {
       });
     });
   }
+
+  /**
+   * Ask for a number within a range
+   */
+  async number(question, min = 1, max = 10) {
+    const rl = this.createInterface();
+
+    return new Promise((resolve) => {
+      rl.question(`${question} `, (answer) => {
+        const num = parseInt(answer, 10);
+        if (!isNaN(num) && num >= min && num <= max) {
+          resolve(num);
+        } else {
+          resolve(null);
+        }
+      });
+    });
+  }
 }
 
 module.exports = { Prompts };

package/package.json

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