zuppaclaude 1.3.6 → 1.3.8

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
-        }
-      }
-    }
+        this.logger.info(`Compressing settings/${backupId}...`);
+        const settingsZipPath = path.join(tempDir, `settings-${zipFileName}`);
 
-    // Create zip
-    const zipCreated = this.createZip(combinedDir, zipPath);
-    if (!zipCreated) {
-      this.logger.error('Failed to create zip');
-      return false;
-    }
+        if (this.createZip(settingsPath, settingsZipPath)) {
+          const zipSize = fs.statSync(settingsZipPath).size;
+          totalSize += zipSize;
+          this.logger.info(`Settings zip: ${this.formatSize(zipSize)}`);
 
-    const zipSize = fs.statSync(zipPath).size;
-    this.logger.info(`Zip size: ${this.formatSize(zipSize)}`);
+          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' });
 
-    // Upload zip
-    const destPath = `${remote}:${this.cloudPath}/${zipFileName}`;
+            // Rename on remote
+            this.platform.exec(`rclone moveto "${remote}:${this.cloudPath}/settings/settings-${zipFileName}" "${remote}:${this.cloudPath}/settings/${zipFileName}"`, { silent: true });
 
-    try {
-      this.logger.info(`Uploading ${zipFileName}...`);
-      const cmd = `rclone copy "${zipPath}" "${remote}:${this.cloudPath}/" --progress`;
-      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
-
-      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,97 @@ 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
-      }
-
-      return false;
     }
+
+    this.logger.error(`Backup not found: ${backupId}`);
+    return false;
   }
 
   /**
-   * Delete a backup from cloud
+   * Delete a backup from cloud (both sessions and settings)
    */
   async deleteCloudBackup(remote, backupId) {
     if (!this.isRcloneInstalled()) {
@@ -737,29 +748,35 @@ class CloudManager {
     }
 
     const zipFileName = `${backupId}.zip`;
+    let deleted = 0;
 
-    try {
-      // Check if backup exists
-      const cmd = `rclone lsf "${remote}:${this.cloudPath}/${zipFileName}" 2>/dev/null`;
-      const output = this.platform.exec(cmd, { silent: true });
+    this.logger.step(`Deleting ${backupId} from ${remote}...`);
 
-      if (!output || !output.trim()) {
-        this.logger.error(`Backup not found on cloud: ${backupId}`);
-        return false;
-      }
-
-      this.logger.step(`Deleting ${zipFileName} 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 the backup
-      const deleteCmd = `rclone delete "${remote}:${this.cloudPath}/${zipFileName}"`;
-      this.platform.exec(deleteCmd, { silent: true });
+    // 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;
-    } catch (error) {
-      this.logger.error(`Failed to delete: ${error.message}`);
-      return false;
     }
+
+    this.logger.error(`Backup not found on cloud: ${backupId}`);
+    return false;
   }
 
   /**
@@ -819,11 +836,11 @@ class CloudManager {
   }
 
   /**
-   * Get list of cloud backups (without printing)
+   * Get list of cloud backups (without printing) - looks in sessions folder
    */
   async getCloudBackupList(remote) {
     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 });
 
       if (!output) return [];
@@ -838,7 +855,7 @@ class CloudManager {
   }
 
   /**
-   * List cloud backups (zip files)
+   * List cloud backups (from sessions folder)
    */
   async listCloudBackups(remote) {
     if (!this.isRcloneInstalled()) {
@@ -852,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('');
@@ -860,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');
@@ -877,6 +896,7 @@ class CloudManager {
       } else {
         for (const backup of backups) {
           console.log(`  📦 ${backup}`);
+          console.log(`     └── sessions/${backup}.zip`);
         }
       }
 

package/lib/installer.js

@@ -204,6 +204,9 @@ class Installer {
       commands: cmdsInstalled
     });
 
+    // Close readline interface
+    this.prompts.close();
+
     return true;
   }
 

package/lib/uninstaller.js

@@ -43,6 +43,7 @@ class Uninstaller {
     const confirm = await this.prompts.confirm('Are you sure you want to uninstall ZuppaClaude?', false);
     if (!confirm) {
       this.logger.info('Uninstallation cancelled');
+      this.prompts.close();
       return false;
     }
 
@@ -74,6 +75,9 @@ class Uninstaller {
     // Print summary
     this.printSummary(results, preserveSettings);
 
+    // Close readline interface
+    this.prompts.close();
+
     return true;
   }
 

package/package.json

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