zuppaclaude 1.3.2 → 1.3.4

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/cloud.js

@@ -4,15 +4,28 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execSync, spawn } = require('child_process');
 const { Logger } = require('../utils/logger');
 const { Platform } = require('../utils/platform');
+const { Prompts } = require('../utils/prompts');
 
 class CloudManager {
   constructor() {
     this.platform = new Platform();
     this.logger = new Logger();
+    this.prompts = new Prompts();
     this.backupDir = path.join(this.platform.zuppaconfigDir, 'backups');
     this.cloudPath = 'zuppaclaude-backups';
+
+    // Supported providers
+    this.providers = [
+      { name: 'Google Drive', type: 'drive', remoteName: 'gdrive' },
+      { name: 'Dropbox', type: 'dropbox', remoteName: 'dropbox' },
+      { name: 'OneDrive', type: 'onedrive', remoteName: 'onedrive' },
+      { name: 'Amazon S3', type: 's3', remoteName: 's3' },
+      { name: 'SFTP', type: 'sftp', remoteName: 'sftp' },
+      { name: 'Skip (configure later)', type: null, remoteName: null }
+    ];
   }
 
   /**
@@ -76,6 +89,115 @@ class CloudManager {
     }
   }
 
+  /**
+   * Configure a cloud provider
+   */
+  async configureProvider() {
+    if (!this.isRcloneInstalled()) {
+      this.logger.error('rclone is not installed');
+      return null;
+    }
+
+    console.log('');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('\x1b[35m                    Cloud Provider Setup\x1b[0m');
+    console.log('\x1b[35m═══════════════════════════════════════════════════════════════════\x1b[0m');
+    console.log('');
+
+    // Show provider options
+    const providerNames = this.providers.map(p => p.name);
+    const selectedIndex = await this.prompts.select('Select a cloud provider:', providerNames);
+    const provider = this.providers[selectedIndex];
+
+    if (!provider.type) {
+      this.logger.info('Skipping cloud provider configuration');
+      this.logger.info('Run "rclone config" later to set up manually');
+      return null;
+    }
+
+    console.log('');
+    this.logger.step(`Configuring ${provider.name}...`);
+
+    // Check if remote already exists
+    const existingRemotes = this.getRemotes();
+    if (existingRemotes.includes(provider.remoteName)) {
+      this.logger.warning(`Remote "${provider.remoteName}" already exists`);
+      const overwrite = await this.prompts.confirm('Overwrite existing configuration?', false);
+      if (!overwrite) {
+        return provider.remoteName;
+      }
+      // Delete existing remote
+      try {
+        this.platform.exec(`rclone config delete ${provider.remoteName}`, { silent: true });
+      } catch (e) {
+        // Ignore
+      }
+    }
+
+    // Run rclone config create
+    try {
+      await this.runProviderAuth(provider);
+
+      // Verify configuration
+      if (this.getRemotes().includes(provider.remoteName)) {
+        this.logger.success(`${provider.name} configured successfully`);
+        console.log('');
+        console.log('  Backup path: \x1b[36m' + provider.remoteName + ':zuppaclaude-backups/\x1b[0m');
+        console.log('    ├── sessions/');
+        console.log('    └── settings/');
+        console.log('');
+        return provider.remoteName;
+      } else {
+        this.logger.error('Configuration failed');
+        return null;
+      }
+    } catch (error) {
+      this.logger.error(`Failed to configure ${provider.name}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Run provider-specific authentication
+   */
+  async runProviderAuth(provider) {
+    return new Promise((resolve, reject) => {
+      console.log('');
+
+      if (provider.type === 'drive' || provider.type === 'dropbox' || provider.type === 'onedrive') {
+        // OAuth providers - need browser auth
+        this.logger.info('A browser window will open for authentication...');
+        this.logger.info('Please authorize ZuppaClaude to access your ' + provider.name);
+        console.log('');
+      }
+
+      // Use spawn for interactive rclone config
+      const args = ['config', 'create', provider.remoteName, provider.type];
+
+      // Add provider-specific defaults
+      if (provider.type === 'drive') {
+        args.push('scope', 'drive');
+      }
+
+      const rclone = spawn('rclone', args, {
+        stdio: 'inherit',
+        shell: true
+      });
+
+      rclone.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`rclone exited with code ${code}`));
+        }
+      });
+
+      rclone.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
   /**
    * Verify rclone installation
    */

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/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/lib/installer.js

@@ -130,6 +130,7 @@ class Installer {
     this.logger.step('Step 7/9: Cloud Backup Setup (rclone)');
     let installRclone = false;
     let rcloneInstalled = this.cloud.isRcloneInstalled();
+    let configuredRemote = null;
 
     if (rcloneInstalled) {
       this.logger.success('rclone is already installed');
@@ -147,6 +148,19 @@ class Installer {
       }
     }
 
+    // Configure cloud provider if rclone is installed
+    if (rcloneInstalled) {
+      const existingRemotes = this.cloud.getRemotes();
+      if (existingRemotes.length === 0) {
+        const configureNow = await this.prompts.confirm('Configure a cloud provider now?', true);
+        if (configureNow) {
+          configuredRemote = await this.cloud.configureProvider();
+        }
+      } else {
+        this.logger.info(`Existing remotes: ${existingRemotes.join(', ')}`);
+      }
+    }
+
     // Step 8: Install ZuppaClaude Commands
     this.logger.step('Step 8/9: Installing ZuppaClaude Slash Commands');
     const cmdsInstalled = await this.commands.install();
@@ -170,6 +184,7 @@ class Installer {
       claudeZ: installClaudeZ,
       claudeHUD: installClaudeHUD,
       rclone: rcloneInstalled,
+      cloudRemote: configuredRemote,
       zaiApiKey: zaiApiKey ? this.settings.encodeApiKey(zaiApiKey) : null,
       installedAt: new Date().toISOString(),
       version: require('../package.json').version

package/package.json

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