zuppaclaude 1.0.2 → 1.1.0

package/README.md

@@ -197,26 +197,48 @@ npx zuppaclaude settings reset             # 🔄 Fabrika ayarları
 | 🔐 API key koruması | Base64 encoded saklama |
 | 🛡️ Uninstall koruması | Kaldırırken ayarları koruma opsiyonu |
 
-### 💾 Session Yedekleme
+### 💾 Yedekleme & Geri Yükleme
 
-Claude Code session'larınızı yedekleyin ve geri yükleyin. Context kaybı, format veya compacting durumlarında kullanışlı.
+Claude Code session'larınızı ve ayarlarınızı yedekleyin. Context kaybı, format veya compacting durumlarında kullanışlı.
 
+**🔄 Tam Yedekleme (Sessions + Ayarlar):**
+```bash
+npx zuppaclaude backup              # 💾 Lokal tam yedek
+npx zuppaclaude backup --cloud gdrive  # ☁️ Google Drive'a yedekle
+npx zuppaclaude restore <id>        # ♻️ Yedekten geri yükle
+npx zuppaclaude restore <id> --cloud gdrive  # ☁️ Cloud'dan geri yükle
+```
+
+**📋 Sadece Session İşlemleri:**
 ```bash
 npx zuppaclaude session list        # 📋 Tüm session'ları listele
-npx zuppaclaude session backup      # 💾 Tüm session'ları yedekle
+npx zuppaclaude session backup      # 💾 Sadece session'ları yedekle
 npx zuppaclaude session backups     # 📦 Mevcut yedekleri listele
-npx zuppaclaude session restore <id> # ♻️ Yedekten geri yükle
-npx zuppaclaude session export <id>  # 📤 Belirli session'ı export et
 ```
 
-**📁 Yedek konumu:** `~/.config/zuppaclaude/backups/`
+### ☁️ Cloud Yedekleme (rclone)
+
+Google Drive, Dropbox, OneDrive, S3, SFTP ve 40+ cloud servise yedekleme.
+
+```bash
+# Kurulum
+brew install rclone      # macOS
+rclone config            # Remote ayarla (gdrive, dropbox vs.)
+
+# Kullanım
+npx zuppaclaude cloud setup         # 📖 Kurulum talimatları
+npx zuppaclaude cloud remotes       # 📋 Mevcut remote'ları listele
+npx zuppaclaude backup --cloud gdrive  # ☁️ Yedekle ve upload et
+npx zuppaclaude cloud backups gdrive   # 📦 Cloud'daki yedekleri listele
+```
 
 **✨ Özellikler:**
 | Özellik | Açıklama |
 |---------|----------|
 | 🔒 Güvenli restore | Mevcut session'lar üzerine yazılmaz |
-| 📜 History desteği | Command history de yedeklenir |
-| 📋 Manifest | Her yedekte metadata saklanır |
+| 📜 Tam yedek | Sessions + Settings + History |
+| ☁️ 40+ cloud | rclone ile Google Drive, Dropbox, S3, SFTP... |
+| 🔐 Encryption | rclone encryption desteği |
 
 ### 🗑️ Kaldırma
 
@@ -444,26 +466,48 @@ npx zuppaclaude settings reset             # 🔄 Reset to defaults
 | 🔐 API key protection | Base64 encoded storage |
 | 🛡️ Uninstall protection | Option to preserve settings when uninstalling |
 
-### 💾 Session Backup
+### 💾 Backup & Restore
 
-Backup and restore your Claude Code sessions. Useful for context loss, formatting, or conversation compacting.
+Backup your Claude Code sessions and settings. Useful for context loss, formatting, or conversation compacting.
 
+**🔄 Full Backup (Sessions + Settings):**
+```bash
+npx zuppaclaude backup              # 💾 Local full backup
+npx zuppaclaude backup --cloud gdrive  # ☁️ Backup to Google Drive
+npx zuppaclaude restore <id>        # ♻️ Restore from backup
+npx zuppaclaude restore <id> --cloud gdrive  # ☁️ Restore from cloud
+```
+
+**📋 Session-only Operations:**
 ```bash
 npx zuppaclaude session list        # 📋 List all sessions
-npx zuppaclaude session backup      # 💾 Backup all sessions
+npx zuppaclaude session backup      # 💾 Backup sessions only
 npx zuppaclaude session backups     # 📦 List available backups
-npx zuppaclaude session restore <id> # ♻️ Restore from backup
-npx zuppaclaude session export <id>  # 📤 Export specific session
 ```
 
-**📁 Backup location:** `~/.config/zuppaclaude/backups/`
+### ☁️ Cloud Backup (rclone)
+
+Backup to Google Drive, Dropbox, OneDrive, S3, SFTP, and 40+ cloud services.
+
+```bash
+# Setup
+brew install rclone      # macOS
+rclone config            # Configure remote (gdrive, dropbox, etc.)
+
+# Usage
+npx zuppaclaude cloud setup         # 📖 Setup instructions
+npx zuppaclaude cloud remotes       # 📋 List configured remotes
+npx zuppaclaude backup --cloud gdrive  # ☁️ Backup and upload
+npx zuppaclaude cloud backups gdrive   # 📦 List cloud backups
+```
 
 **✨ Features:**
 | Feature | Description |
 |---------|-------------|
 | 🔒 Safe restore | Existing sessions are not overwritten |
-| 📜 History support | Command history is also backed up |
-| 📋 Manifest | Metadata saved with each backup |
+| 📜 Full backup | Sessions + Settings + History |
+| ☁️ 40+ clouds | Google Drive, Dropbox, S3, SFTP via rclone |
+| 🔐 Encryption | rclone encryption support |
 
 ### 🗑️ Uninstall
 

package/bin/zuppaclaude.js

@@ -12,6 +12,17 @@ const { Logger } = require('../lib/utils/logger');
 const args = process.argv.slice(2);
 const command = args[0] || 'install';
 
+/**
+ * Extract --cloud <remote> argument
+ */
+function getCloudArg(args) {
+  const cloudIndex = args.indexOf('--cloud');
+  if (cloudIndex !== -1 && args[cloudIndex + 1]) {
+    return args[cloudIndex + 1];
+  }
+  return null;
+}
+
 async function main() {
   const logger = new Logger();
 
@@ -114,6 +125,73 @@ async function main() {
         }
         break;
 
+      case 'backup':
+        const { BackupManager } = require('../lib/components/backup');
+        const backupMgr = new BackupManager();
+        const cloudArg = getCloudArg(args);
+        await backupMgr.backup({ cloud: cloudArg });
+        break;
+
+      case 'restore':
+        const { BackupManager: RestoreBackupManager } = require('../lib/components/backup');
+        const restoreMgr = new RestoreBackupManager();
+        const restoreId = args[1];
+        const restoreCloud = getCloudArg(args);
+
+        if (!restoreId || restoreId.startsWith('--')) {
+          logger.error('Please specify backup ID');
+          logger.info('Usage: zuppaclaude restore <backup-id> [--cloud <remote>]');
+          logger.info('Run "zuppaclaude backup list" to see available backups');
+          process.exit(1);
+        }
+
+        await restoreMgr.restore(restoreId, { cloud: restoreCloud });
+        break;
+
+      case 'cloud':
+        const { CloudManager } = require('../lib/components/cloud');
+        const cloudMgr = new CloudManager();
+        const cloudCmd = args[1] || 'remotes';
+        const cloudRemote = args[2];
+
+        switch (cloudCmd) {
+          case 'setup':
+            cloudMgr.showSetupInstructions();
+            break;
+          case 'remotes':
+          case 'list':
+            cloudMgr.listRemotes();
+            break;
+          case 'upload':
+            if (!cloudRemote) {
+              logger.error('Please specify remote');
+              logger.info('Usage: zuppaclaude cloud upload <remote> [backup-id]');
+              process.exit(1);
+            }
+            await cloudMgr.upload(cloudRemote, args[3]);
+            break;
+          case 'download':
+            if (!cloudRemote) {
+              logger.error('Please specify remote');
+              logger.info('Usage: zuppaclaude cloud download <remote> [backup-id]');
+              process.exit(1);
+            }
+            await cloudMgr.download(cloudRemote, args[3]);
+            break;
+          case 'backups':
+            if (!cloudRemote) {
+              logger.error('Please specify remote');
+              logger.info('Usage: zuppaclaude cloud backups <remote>');
+              process.exit(1);
+            }
+            await cloudMgr.listCloudBackups(cloudRemote);
+            break;
+          default:
+            logger.error(`Unknown cloud command: ${cloudCmd}`);
+            showCloudHelp();
+        }
+        break;
+
       case 'version':
       case 'v':
       case '-v':
@@ -150,32 +228,40 @@ Usage: zuppaclaude [command] [options]
 Commands:
   install, i          Install ZuppaClaude components (default)
   uninstall, u        Uninstall ZuppaClaude components
+  backup              Full backup (sessions + settings) with cloud support
+  restore             Restore from backup
   settings, s         Manage settings
   session             Manage Claude Code sessions
+  cloud               Manage cloud remotes (rclone)
   version, v          Show version
   help, h             Show this help
 
-Settings Commands:
-  settings show       Display current settings
-  settings export     Export settings to file
-  settings import     Import settings from file
-  settings reset      Reset settings to default
-  settings path       Show settings file path
+Backup Commands:
+  backup                         Local backup (sessions + settings)
+  backup --cloud <remote>        Backup and upload to cloud
+  restore <id>                   Restore from local backup
+  restore <id> --cloud <remote>  Download and restore from cloud
+
+Cloud Commands:
+  cloud setup          Show rclone setup instructions
+  cloud remotes        List configured remotes
+  cloud upload <r>     Upload backups to remote
+  cloud download <r>   Download backups from remote
+  cloud backups <r>    List cloud backups
 
 Session Commands:
-  session list        List all sessions
-  session backup      Backup all sessions
-  session backups     List available backups
-  session restore     Restore from backup
-  session export      Export a specific session
+  session list         List all sessions
+  session backup       Backup sessions only
+  session backups      List available backups
+  session restore      Restore sessions only
+  session export       Export a specific session
 
 Examples:
-  npx zuppaclaude                    # Install
-  npx zuppaclaude install            # Install
-  npx zuppaclaude uninstall          # Uninstall
-  npx zuppaclaude settings show      # View settings
-  npx zuppaclaude session backup     # Backup sessions
-  npx zuppaclaude session restore 2026-01-05T12-00-00
+  npx zuppaclaude                              # Install
+  npx zuppaclaude backup                       # Full local backup
+  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
 `);
 }
 
@@ -214,4 +300,25 @@ Examples:
 `);
 }
 
+function showCloudHelp() {
+  console.log(`
+Cloud Commands (requires rclone):
+  setup      Show rclone installation and configuration instructions
+  remotes    List configured cloud remotes
+  upload     Upload backups to a cloud remote
+  download   Download backups from a cloud remote
+  backups    List backups stored on a cloud remote
+
+Examples:
+  zuppaclaude cloud setup                    # Setup instructions
+  zuppaclaude cloud remotes                  # List remotes
+  zuppaclaude cloud upload gdrive            # Upload all backups
+  zuppaclaude cloud download gdrive          # Download all backups
+  zuppaclaude cloud backups gdrive           # List cloud backups
+
+Supported providers (via rclone):
+  Google Drive, Dropbox, OneDrive, S3, SFTP, FTP, and 40+ more
+`);
+}
+
 main();

package/lib/components/backup.js

@@ -0,0 +1,235 @@
+/**
+ * Unified Backup Manager - Sessions + Settings + Cloud
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Logger } = require('../utils/logger');
+const { Platform } = require('../utils/platform');
+const { SessionManager } = require('./session');
+const { CloudManager } = require('./cloud');
+const { Settings } = require('../settings');
+
+class BackupManager {
+  constructor() {
+    this.platform = new Platform();
+    this.logger = new Logger();
+    this.sessionManager = new SessionManager();
+    this.cloudManager = new CloudManager();
+    this.settings = new Settings();
+    this.backupDir = path.join(this.platform.zuppaconfigDir, 'backups');
+  }
+
+  /**
+   * Full backup - sessions + settings
+   */
+  async backup(options = {}) {
+    const { cloud } = options;
+
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    ZuppaClaude Full Backup\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    // Step 1: Backup sessions
+    this.logger.step('Step 1/3: Backing up Claude Code sessions...');
+    const sessionResult = this.sessionManager.backup();
+
+    if (!sessionResult) {
+      this.logger.warning('No sessions to backup');
+    }
+
+    // Step 2: Backup settings to the same directory
+    this.logger.step('Step 2/3: Backing up ZuppaClaude settings...');
+
+    if (sessionResult) {
+      const settingsBackupPath = path.join(sessionResult.path, 'zc-settings.json');
+      const currentSettings = this.settings.load();
+
+      if (currentSettings) {
+        fs.writeFileSync(settingsBackupPath, JSON.stringify(currentSettings, null, 2));
+        this.logger.success('Settings backed up');
+      } else {
+        this.logger.info('No settings to backup');
+      }
+
+      // Update manifest 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';
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      }
+    }
+
+    // Step 3: Upload to cloud if specified
+    if (cloud) {
+      this.logger.step('Step 3/3: Uploading to cloud...');
+
+      if (!this.cloudManager.isRcloneInstalled()) {
+        this.logger.warning('rclone not installed, skipping cloud upload');
+        this.cloudManager.showSetupInstructions();
+      } else if (!this.cloudManager.remoteExists(cloud)) {
+        this.logger.error(`Remote not found: ${cloud}`);
+        this.cloudManager.listRemotes();
+      } else {
+        await this.cloudManager.upload(cloud, sessionResult?.timestamp);
+      }
+    } else {
+      this.logger.step('Step 3/3: Cloud upload skipped (use --cloud <remote>)');
+    }
+
+    // Summary
+    this.printBackupSummary(sessionResult, cloud);
+
+    return sessionResult;
+  }
+
+  /**
+   * Full restore - sessions + settings
+   */
+  async restore(backupId, options = {}) {
+    const { cloud, settingsOnly, sessionsOnly } = options;
+
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    ZuppaClaude Restore\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    // Step 1: Download from cloud if specified
+    if (cloud) {
+      this.logger.step('Step 1/3: Downloading from cloud...');
+
+      if (!this.cloudManager.isRcloneInstalled()) {
+        this.logger.error('rclone not installed');
+        this.cloudManager.showSetupInstructions();
+        return false;
+      }
+
+      if (!this.cloudManager.remoteExists(cloud)) {
+        this.logger.error(`Remote not found: ${cloud}`);
+        return false;
+      }
+
+      await this.cloudManager.download(cloud, backupId);
+    } else {
+      this.logger.info('Step 1/3: Using local backup');
+    }
+
+    const backupPath = path.join(this.backupDir, backupId);
+
+    if (!fs.existsSync(backupPath)) {
+      this.logger.error(`Backup not found: ${backupId}`);
+      this.logger.info('Run "npx zuppaclaude backup list" to see available backups');
+      return false;
+    }
+
+    let sessionsRestored = false;
+    let settingsRestored = false;
+
+    // Step 2: Restore sessions
+    if (!settingsOnly) {
+      this.logger.step('Step 2/3: Restoring sessions...');
+      sessionsRestored = this.sessionManager.restore(backupId);
+    } else {
+      this.logger.info('Step 2/3: Sessions restore skipped');
+    }
+
+    // Step 3: Restore settings
+    if (!sessionsOnly) {
+      this.logger.step('Step 3/3: Restoring settings...');
+
+      const settingsBackupPath = path.join(backupPath, 'zc-settings.json');
+
+      if (fs.existsSync(settingsBackupPath)) {
+        try {
+          const backupSettings = JSON.parse(fs.readFileSync(settingsBackupPath, 'utf8'));
+          this.settings.save(backupSettings);
+          this.logger.success('Settings restored');
+          settingsRestored = true;
+        } catch (error) {
+          this.logger.warning(`Failed to restore settings: ${error.message}`);
+        }
+      } else {
+        this.logger.info('No settings in backup');
+      }
+    } else {
+      this.logger.info('Step 3/3: Settings restore skipped');
+    }
+
+    // Summary
+    console.log('');
+    console.log('\x1b[32m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[32m                    Restore Complete\x1b[0m');
+    console.log('\x1b[32m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+    console.log(`  Sessions: ${sessionsRestored ? '✅ Restored' : '⏭️ Skipped'}`);
+    console.log(`  Settings: ${settingsRestored ? '✅ Restored' : '⏭️ Skipped'}`);
+    console.log('');
+    console.log('  Restart Claude Code to see restored sessions');
+    console.log('');
+
+    return true;
+  }
+
+  /**
+   * List all backups (local + cloud)
+   */
+  async list(options = {}) {
+    const { cloud } = options;
+
+    // List local backups
+    this.sessionManager.listBackups();
+
+    // List cloud backups if remote specified
+    if (cloud) {
+      await this.cloudManager.listCloudBackups(cloud);
+    }
+  }
+
+  /**
+   * Print backup summary
+   */
+  printBackupSummary(result, cloud) {
+    console.log('');
+    console.log('\x1b[32m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[32m                    Backup Complete\x1b[0m');
+    console.log('\x1b[32m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    if (result) {
+      console.log(`  📦 Backup ID: ${result.timestamp}`);
+      console.log(`  📁 Sessions: ${result.sessions}`);
+      console.log(`  💾 Size: ${this.formatSize(result.size)}`);
+      console.log(`  📍 Location: ${result.path}`);
+
+      if (cloud) {
+        console.log(`  ☁️ Cloud: ${cloud}:zuppaclaude-backups/${result.timestamp}`);
+      }
+    }
+
+    console.log('');
+    console.log('  Restore with:');
+    if (result) {
+      console.log(`  \x1b[36mnpx zuppaclaude restore ${result.timestamp}\x1b[0m`);
+      if (cloud) {
+        console.log(`  \x1b[36mnpx zuppaclaude restore ${result.timestamp} --cloud ${cloud}\x1b[0m`);
+      }
+    }
+    console.log('');
+  }
+
+  /**
+   * 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';
+  }
+}
+
+module.exports = { BackupManager };

package/lib/components/cloud.js

@@ -0,0 +1,335 @@
+/**
+ * Cloud Backup Manager - rclone integration for cloud sync
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Logger } = require('../utils/logger');
+const { Platform } = require('../utils/platform');
+
+class CloudManager {
+  constructor() {
+    this.platform = new Platform();
+    this.logger = new Logger();
+    this.backupDir = path.join(this.platform.zuppaconfigDir, 'backups');
+    this.cloudPath = 'zuppaclaude-backups';
+  }
+
+  /**
+   * Check if rclone is installed
+   */
+  isRcloneInstalled() {
+    return this.platform.commandExists('rclone');
+  }
+
+  /**
+   * Get available rclone remotes
+   */
+  getRemotes() {
+    if (!this.isRcloneInstalled()) {
+      return [];
+    }
+
+    try {
+      const output = this.platform.exec('rclone listremotes', { silent: true });
+      if (!output) return [];
+
+      return output
+        .split('\n')
+        .map(r => r.trim().replace(/:$/, ''))
+        .filter(r => r.length > 0);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Check remote exists
+   */
+  remoteExists(remote) {
+    const remotes = this.getRemotes();
+    return remotes.includes(remote);
+  }
+
+  /**
+   * Show rclone setup instructions
+   */
+  showSetupInstructions() {
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    Cloud Backup Setup\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    if (!this.isRcloneInstalled()) {
+      console.log('\x1b[33m[!]\x1b[0m rclone is not installed.');
+      console.log('');
+      console.log('Install rclone:');
+      console.log('');
+      if (this.platform.isMac) {
+        console.log('  \x1b[36mbrew install rclone\x1b[0m');
+      } else if (this.platform.isLinux) {
+        console.log('  \x1b[36mcurl https://rclone.org/install.sh | sudo bash\x1b[0m');
+      } else {
+        console.log('  \x1b[36mwinget install Rclone.Rclone\x1b[0m');
+      }
+      console.log('');
+      console.log('Or visit: https://rclone.org/install/');
+      console.log('');
+      return false;
+    }
+
+    console.log('\x1b[32m[✓]\x1b[0m rclone is installed');
+    console.log('');
+
+    const remotes = this.getRemotes();
+
+    if (remotes.length === 0) {
+      console.log('\x1b[33m[!]\x1b[0m No cloud remotes configured.');
+      console.log('');
+      console.log('Configure a remote:');
+      console.log('');
+      console.log('  \x1b[36mrclone config\x1b[0m');
+      console.log('');
+      console.log('Popular options:');
+      console.log('  • Google Drive: Choose "drive"');
+      console.log('  • Dropbox: Choose "dropbox"');
+      console.log('  • OneDrive: Choose "onedrive"');
+      console.log('  • S3/Minio: Choose "s3"');
+      console.log('  • SFTP: Choose "sftp"');
+      console.log('  • FTP: Choose "ftp"');
+      console.log('');
+      return false;
+    }
+
+    console.log('Available remotes:');
+    console.log('');
+    for (const remote of remotes) {
+      console.log(`  \x1b[36m${remote}\x1b[0m`);
+    }
+    console.log('');
+    console.log('Usage:');
+    console.log('');
+    console.log(`  \x1b[36mnpx zuppaclaude backup --cloud ${remotes[0]}\x1b[0m`);
+    console.log(`  \x1b[36mnpx zuppaclaude restore --cloud ${remotes[0]}\x1b[0m`);
+    console.log('');
+
+    return true;
+  }
+
+  /**
+   * List remotes
+   */
+  listRemotes() {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      this.showSetupInstructions();
+      return [];
+    }
+
+    const remotes = this.getRemotes();
+
+    if (remotes.length === 0) {
+      this.logger.warning('No remotes configured');
+      this.showSetupInstructions();
+      return [];
+    }
+
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    Available Cloud Remotes\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    for (const remote of remotes) {
+      // Try to get remote type
+      let type = 'unknown';
+      try {
+        const config = this.platform.exec(`rclone config show ${remote}`, { silent: true });
+        const typeMatch = config?.match(/type\s*=\s*(\w+)/);
+        if (typeMatch) type = typeMatch[1];
+      } catch (e) {
+        // Ignore
+      }
+
+      const icon = this.getRemoteIcon(type);
+      console.log(`  ${icon} \x1b[36m${remote}\x1b[0m (${type})`);
+    }
+
+    console.log('');
+    return remotes;
+  }
+
+  /**
+   * Get icon for remote type
+   */
+  getRemoteIcon(type) {
+    const icons = {
+      'drive': '📁',
+      'dropbox': '📦',
+      'onedrive': '☁️',
+      's3': '🪣',
+      'sftp': '🔐',
+      'ftp': '📡',
+      'b2': '🅱️',
+      'box': '📥',
+      'mega': '🔷',
+      'pcloud': '☁️'
+    };
+    return icons[type] || '☁️';
+  }
+
+  /**
+   * Upload backup to cloud
+   */
+  async upload(remote, backupId = null) {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      this.showSetupInstructions();
+      return false;
+    }
+
+    if (!this.remoteExists(remote)) {
+      this.logger.error(`Remote not found: ${remote}`);
+      this.logger.info('Run "npx zuppaclaude cloud remotes" to see available remotes');
+      return false;
+    }
+
+    // Determine what to upload
+    let sourcePath = this.backupDir;
+    let destPath = `${remote}:${this.cloudPath}`;
+
+    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}`;
+    }
+
+    if (!fs.existsSync(sourcePath)) {
+      this.logger.error('No backups to upload');
+      this.logger.info('Run "npx zuppaclaude backup" first');
+      return false;
+    }
+
+    console.log('');
+    this.logger.step(`Uploading to ${remote}...`);
+    console.log('');
+
+    try {
+      // Use rclone sync for efficiency
+      const cmd = `rclone sync "${sourcePath}" "${destPath}" --progress`;
+      this.platform.exec(cmd, { silent: false, stdio: 'inherit' });
+
+      console.log('');
+      this.logger.success(`Backup uploaded to ${remote}:${this.cloudPath}`);
+      console.log('');
+      return true;
+    } catch (error) {
+      this.logger.error(`Upload failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Download backup from cloud
+   */
+  async download(remote, backupId = null) {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      this.showSetupInstructions();
+      return false;
+    }
+
+    if (!this.remoteExists(remote)) {
+      this.logger.error(`Remote not found: ${remote}`);
+      return false;
+    }
+
+    let sourcePath = `${remote}:${this.cloudPath}`;
+    let destPath = this.backupDir;
+
+    if (backupId) {
+      sourcePath = `${remote}:${this.cloudPath}/${backupId}`;
+      destPath = path.join(this.backupDir, backupId);
+    }
+
+    this.platform.ensureDir(destPath);
+
+    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' });
+
+      console.log('');
+      this.logger.success(`Backup downloaded from ${remote}`);
+      console.log('');
+      return true;
+    } catch (error) {
+      this.logger.error(`Download failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * List cloud backups
+   */
+  async listCloudBackups(remote) {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      return [];
+    }
+
+    if (!this.remoteExists(remote)) {
+      this.logger.error(`Remote not found: ${remote}`);
+      return [];
+    }
+
+    try {
+      const cmd = `rclone lsd "${remote}:${this.cloudPath}" 2>/dev/null`;
+      const output = this.platform.exec(cmd, { silent: true });
+
+      if (!output) {
+        this.logger.warning('No cloud backups found');
+        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('');
+
+      if (backups.length === 0) {
+        console.log('  No backups found');
+      } else {
+        for (const backup of backups) {
+          console.log(`  📦 ${backup}`);
+        }
+      }
+
+      console.log('');
+      return backups;
+    } catch (error) {
+      this.logger.warning('Could not list cloud backups');
+      return [];
+    }
+  }
+}
+
+module.exports = { CloudManager };

package/lib/components/index.js

@@ -8,6 +8,8 @@ const { ConfigInstaller } = require('./config');
 const { ClaudeZInstaller } = require('./claudez');
 const { ClaudeHUDInstaller } = require('./claudehud');
 const { SessionManager } = require('./session');
+const { CloudManager } = require('./cloud');
+const { BackupManager } = require('./backup');
 
 module.exports = {
   SuperClaudeInstaller,
@@ -15,5 +17,7 @@ module.exports = {
   ConfigInstaller,
   ClaudeZInstaller,
   ClaudeHUDInstaller,
-  SessionManager
+  SessionManager,
+  CloudManager,
+  BackupManager
 };

package/package.json

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