feat: add auto-update command for one-click binary updates

Add `claude-code-sync update` command that automatically:
- Checks GitHub for latest release
- Prompts user (with --yes flag for automation)
- Downloads binary for current platform
- Extracts archive (tar.gz for Unix, zip for Windows)
- Backs up old binary
- Installs new binary with executable permissions
- Cleans up on success or restores backup on failure

Supports interactive and non-interactive modes for both manual
updates and CI/CD automation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: FelixIsaac

internal/cmd/root.go

@@ -38,6 +38,7 @@ func init() {
 	rootCmd.AddCommand(unlinkCmd)
 	rootCmd.AddCommand(doctorCmd)
 	rootCmd.AddCommand(checkUpdateCmd)
+	rootCmd.AddCommand(updateCmd)
 }
 
 // UI helpers

internal/cmd/update.go

@@ -1,9 +1,16 @@
 package cmd
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"bufio"
+	"compress/gzip"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
+	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"time"
@@ -32,6 +39,18 @@ var checkUpdateCmd = &cobra.Command{
 	RunE:  runCheckUpdate,
 }
 
+var updateCmd = &cobra.Command{
+	Use:   "update",
+	Short: "Download and install latest version",
+	RunE:  runUpdate,
+}
+
+var updateAutoConfirm bool
+
+func init() {
+	updateCmd.Flags().BoolVarP(&updateAutoConfirm, "yes", "y", false, "Auto-confirm update without prompting")
+}
+
 func runCheckUpdate(cmd *cobra.Command, args []string) error {
 	logInfo("Checking for updates...")
 
@@ -132,3 +151,249 @@ func compareVersions(a, b string) int {
 
 	return len(aParts) - len(bParts)
 }
+
+// runUpdate handles the automatic update flow
+func runUpdate(cmd *cobra.Command, args []string) error {
+	logInfo("Checking for updates...")
+
+	// Check for latest release
+	latest, err := getLatestRelease()
+	if err != nil {
+		return fmt.Errorf("failed to check for updates: %w", err)
+	}
+
+	latestVer := strings.TrimPrefix(latest.TagName, "v")
+	currentVer := version
+
+	// Check if update is needed
+	if compareVersions(latestVer, currentVer) <= 0 {
+		logSuccess(fmt.Sprintf("Already on latest version (v%s)", currentVer))
+		return nil
+	}
+
+	// Prompt user unless --yes flag
+	if !updateAutoConfirm {
+		fmt.Printf("Update available: v%s → v%s\n", currentVer, latestVer)
+		fmt.Printf("Update to v%s? [Y/n]: ", latestVer)
+
+		reader := bufio.NewReader(os.Stdin)
+		response, err := reader.ReadString('\n')
+		if err != nil && err != io.EOF {
+			return fmt.Errorf("failed to read input: %w", err)
+		}
+
+		response = strings.TrimSpace(strings.ToLower(response))
+		if response != "" && response != "y" && response != "yes" {
+			logInfo("Update cancelled")
+			return nil
+		}
+	}
+
+	// Get asset info
+	assetName := getAssetName()
+	var downloadURL string
+	for _, asset := range latest.Assets {
+		if asset.Name == assetName {
+			downloadURL = asset.BrowserDownloadURL
+			break
+		}
+	}
+
+	if downloadURL == "" {
+		return fmt.Errorf("no binary available for %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+
+	logInfo(fmt.Sprintf("Downloading %s...", assetName))
+	tmpFile, err := downloadToTemp(downloadURL)
+	if err != nil {
+		return fmt.Errorf("download failed: %w", err)
+	}
+	defer os.Remove(tmpFile)
+
+	// Extract binary
+	logInfo("Extracting binary...")
+	extractedBinary, err := extractBinary(tmpFile)
+	if err != nil {
+		return fmt.Errorf("extraction failed: %w", err)
+	}
+	defer os.RemoveAll(filepath.Dir(extractedBinary))
+
+	// Get current binary path
+	currentBinary, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("failed to locate current binary: %w", err)
+	}
+
+	// Check permissions
+	logInfo("Installing update...")
+	if err := checkWritePermission(currentBinary); err != nil {
+		return fmt.Errorf("insufficient permissions: %w", err)
+	}
+
+	// Create backup
+	backup := currentBinary + ".old"
+	if err := os.Rename(currentBinary, backup); err != nil {
+		return fmt.Errorf("failed to backup current binary: %w", err)
+	}
+
+	// Move new binary into place
+	if err := os.Rename(extractedBinary, currentBinary); err != nil {
+		// Restore backup on failure
+		os.Rename(backup, currentBinary)
+		return fmt.Errorf("failed to install update: %w", err)
+	}
+
+	// Ensure executable permissions
+	os.Chmod(currentBinary, 0755)
+
+	// Clean up backup
+	os.Remove(backup)
+
+	logSuccess(fmt.Sprintf("Updated to v%s!", latestVer))
+	return nil
+}
+
+// downloadToTemp downloads a file from URL to a temp file
+func downloadToTemp(url string) (string, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+
+	tmpFile, err := os.CreateTemp("", "claude-code-sync-*.tmp")
+	if err != nil {
+		return "", err
+	}
+	defer tmpFile.Close()
+
+	if _, err := io.Copy(tmpFile, resp.Body); err != nil {
+		os.Remove(tmpFile.Name())
+		return "", err
+	}
+
+	return tmpFile.Name(), nil
+}
+
+// extractBinary extracts the binary from the archive
+func extractBinary(archivePath string) (string, error) {
+	tmpDir, err := os.MkdirTemp("", "update-")
+	if err != nil {
+		return "", err
+	}
+
+	var binaryPath string
+
+	if strings.HasSuffix(archivePath, ".zip") {
+		binaryPath, err = extractZip(archivePath, tmpDir)
+	} else {
+		binaryPath, err = extractTarGz(archivePath, tmpDir)
+	}
+
+	if err != nil {
+		os.RemoveAll(tmpDir)
+		return "", err
+	}
+
+	return binaryPath, nil
+}
+
+// extractZip extracts binary from zip archive
+func extractZip(zipPath, destDir string) (string, error) {
+	reader, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return "", err
+	}
+	defer reader.Close()
+
+	for _, file := range reader.File {
+		if strings.Contains(file.Name, "claude-code-sync") && !strings.Contains(file.Name, "/") {
+			// Found the binary at root level
+			src, err := file.Open()
+			if err != nil {
+				return "", err
+			}
+			defer src.Close()
+
+			destPath := filepath.Join(destDir, file.Name)
+			dest, err := os.Create(destPath)
+			if err != nil {
+				return "", err
+			}
+			defer dest.Close()
+
+			if _, err := io.Copy(dest, src); err != nil {
+				return "", err
+			}
+
+			return destPath, nil
+		}
+	}
+
+	return "", fmt.Errorf("binary not found in archive")
+}
+
+// extractTarGz extracts binary from tar.gz archive
+func extractTarGz(tarPath, destDir string) (string, error) {
+	file, err := os.Open(tarPath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	gz, err := gzip.NewReader(file)
+	if err != nil {
+		return "", err
+	}
+	defer gz.Close()
+
+	tr := tar.NewReader(gz)
+
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return "", err
+		}
+
+		if strings.Contains(header.Name, "claude-code-sync") && !strings.Contains(header.Name, "/") {
+			// Found the binary
+			destPath := filepath.Join(destDir, header.Name)
+			dest, err := os.Create(destPath)
+			if err != nil {
+				return "", err
+			}
+			defer dest.Close()
+
+			if _, err := io.Copy(dest, tr); err != nil {
+				return "", err
+			}
+
+			return destPath, nil
+		}
+	}
+
+	return "", fmt.Errorf("binary not found in archive")
+}
+
+// checkWritePermission checks if we can write to the binary location
+func checkWritePermission(binaryPath string) error {
+	parent := filepath.Dir(binaryPath)
+	tmpFile := filepath.Join(parent, ".write-test")
+
+	if err := os.WriteFile(tmpFile, []byte("test"), 0644); err != nil {
+		if runtime.GOOS != "windows" {
+			return fmt.Errorf("try: sudo %s update", os.Args[0])
+		}
+		return err
+	}
+
+	os.Remove(tmpFile)
+	return nil
+}