Add auto-upgrade with settings toggle (#2)

Auto-upgrade runs after every command (1h cooldown), silently
downloading and replacing the binary. Takes effect on next invocation.

Skipped for local dev builds (dirty/dev versions) so developers
can test without the binary being overwritten.

Users can disable: vctl settings set auto-upgrade off
View current: vctl settings

Also refactored upgrade.go to share fetch/download helpers from
the update package instead of duplicating them.

Author: raamsri

cmd/root.go

@@ -7,7 +7,6 @@ import (
 	"github.com/smallest-inc/velocity-cli/internal/api"
 	"github.com/smallest-inc/velocity-cli/internal/config"
 	"github.com/smallest-inc/velocity-cli/internal/update"
-	"github.com/smallest-inc/velocity-cli/internal/ui"
 	"github.com/spf13/cobra"
 )
 
@@ -83,14 +82,14 @@ var rootCmd = &cobra.Command{
 			return
 		}
 
-		// Show cached update notification (local file read, zero latency)
-		if msg := update.Notify(version); msg != "" {
-			fmt.Println()
-			ui.Info(msg)
+		// Auto-upgrade: check for new version and silently upgrade after
+		// the user's command completes. Respects a 1h cooldown between checks.
+		// Skipped for dirty/dev builds and when disabled via `vctl settings set auto-upgrade off`.
+		autoUpgradeEnabled := true
+		if cfg != nil {
+			autoUpgradeEnabled = cfg.IsAutoUpgradeEnabled()
 		}
-
-		// Kick off background check for next time (non-blocking)
-		update.CheckInBackground(version)
+		update.AutoUpgrade(version, Quiet, autoUpgradeEnabled)
 	},
 	SilenceUsage:  true,
 	SilenceErrors: true,

cmd/settings.go

@@ -0,0 +1,79 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/smallest-inc/velocity-cli/internal/config"
+	"github.com/smallest-inc/velocity-cli/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var settingsCmd = &cobra.Command{
+	Use:   "settings",
+	Short: "View and manage CLI settings",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		c, err := config.Load()
+		if err != nil {
+			return err
+		}
+
+		autoUpgrade := "on (default)"
+		if c.AutoUpgrade != nil {
+			if *c.AutoUpgrade {
+				autoUpgrade = "on"
+			} else {
+				autoUpgrade = "off"
+			}
+		}
+
+		fmt.Printf("  auto-upgrade:  %s\n", autoUpgrade)
+		return nil
+	},
+}
+
+var settingsSetCmd = &cobra.Command{
+	Use:   "set <key> <value>",
+	Short: "Set a CLI setting",
+	Long: `Set a CLI setting. Available settings:
+
+  auto-upgrade  on|off   Auto-upgrade vctl after each command (default: on)`,
+	Args: cobra.ExactArgs(2),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		key := args[0]
+		value := strings.ToLower(args[1])
+
+		c, err := config.Load()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "auto-upgrade":
+			switch value {
+			case "on", "true", "1":
+				v := true
+				c.AutoUpgrade = &v
+			case "off", "false", "0":
+				v := false
+				c.AutoUpgrade = &v
+			default:
+				return fmt.Errorf("invalid value %q for auto-upgrade (use on/off)", value)
+			}
+		default:
+			return fmt.Errorf("unknown setting %q (available: auto-upgrade)", key)
+		}
+
+		if err := config.Save(c); err != nil {
+			return fmt.Errorf("failed to save settings: %w", err)
+		}
+
+		ui.Success(fmt.Sprintf("%s = %s", key, value))
+		return nil
+	},
+}
+
+func init() {
+	settingsCmd.AddCommand(settingsSetCmd)
+	rootCmd.AddCommand(settingsCmd)
+}

cmd/upgrade.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"archive/tar"
 	"compress/gzip"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -12,45 +11,22 @@ import (
 	"strings"
 
 	"github.com/smallest-inc/velocity-cli/internal/ui"
+	"github.com/smallest-inc/velocity-cli/internal/update"
 	"github.com/spf13/cobra"
 )
 
-const (
-	releaseAPI = "https://api.github.com/repos/smallest-inc/velocity-cli/releases/latest"
-)
-
-type githubRelease struct {
-	TagName string        `json:"tag_name"`
-	Assets  []githubAsset `json:"assets"`
-}
-
-type githubAsset struct {
-	Name               string `json:"name"`
-	BrowserDownloadURL string `json:"browser_download_url"`
-}
-
 var upgradeCmd = &cobra.Command{
 	Use:   "upgrade",
 	Short: "Upgrade vctl to the latest version",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		ui.Step(Verbose, "Checking for latest release")
 		stop := ui.Spinner("Checking for updates")
 
-		resp, err := http.Get(releaseAPI)
+		release, err := update.FetchLatestRelease()
 		stop()
 		if err != nil {
 			return fmt.Errorf("failed to check for updates: %w", err)
 		}
-		defer resp.Body.Close()
-
-		if resp.StatusCode != 200 {
-			return fmt.Errorf("failed to check for updates (HTTP %d)", resp.StatusCode)
-		}
-
-		var release githubRelease
-		if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
-			return fmt.Errorf("failed to parse release info: %w", err)
-		}
 
 		latestVersion := strings.TrimPrefix(release.TagName, "v")
 		if latestVersion == version {
@@ -60,16 +36,15 @@ var upgradeCmd = &cobra.Command{
 
 		ui.Info(fmt.Sprintf("Current: %s → Latest: %s", version, latestVersion))
 
-		// Find matching asset
-		targetAsset := findAsset(release.Assets)
-		if targetAsset == nil {
+		asset := update.FindAsset(release.Assets)
+		if asset == nil {
 			return fmt.Errorf("no release binary for %s/%s", runtime.GOOS, runtime.GOARCH)
 		}
 
-		ui.Step(Verbose, fmt.Sprintf("Downloading %s", targetAsset.Name))
+		ui.Step(Verbose, fmt.Sprintf("Downloading %s", asset.Name))
 		stop = ui.Spinner(fmt.Sprintf("Downloading %s", latestVersion))
 
-		binResp, err := http.Get(targetAsset.BrowserDownloadURL)
+		binResp, err := http.Get(asset.BrowserDownloadURL)
 		stop()
 		if err != nil {
 			return fmt.Errorf("failed to download: %w", err)
@@ -80,21 +55,18 @@ var upgradeCmd = &cobra.Command{
 			return fmt.Errorf("download failed (HTTP %d)", binResp.StatusCode)
 		}
 
-		// Extract binary from tar.gz
 		newBinary, err := extractBinary(binResp.Body)
 		if err != nil {
 			return fmt.Errorf("failed to extract binary: %w", err)
 		}
 
-		// Replace current binary
 		execPath, err := os.Executable()
 		if err != nil {
 			return fmt.Errorf("failed to find current binary: %w", err)
 		}
 
 		ui.Step(Verbose, fmt.Sprintf("Replacing %s", execPath))
 
-		// Write to temp file, then rename (atomic on same filesystem)
 		tmpPath := execPath + ".new"
 		if err := os.WriteFile(tmpPath, newBinary, 0755); err != nil {
 			return fmt.Errorf("failed to write new binary: %w", err)
@@ -110,18 +82,6 @@ var upgradeCmd = &cobra.Command{
 	},
 }
 
-func findAsset(assets []githubAsset) *githubAsset {
-	// Match by OS and arch anywhere in the filename
-	// goreleaser names: vctl_0.1.0_darwin_amd64.tar.gz
-	osArch := fmt.Sprintf("%s_%s", runtime.GOOS, runtime.GOARCH)
-	for i := range assets {
-		if strings.Contains(assets[i].Name, osArch) && strings.HasSuffix(assets[i].Name, ".tar.gz") {
-			return &assets[i]
-		}
-	}
-	return nil
-}
-
 func extractBinary(r io.Reader) ([]byte, error) {
 	gz, err := gzip.NewReader(r)
 	if err != nil {

internal/config/config.go

@@ -21,6 +21,15 @@ type Config struct {
 	ProjectDisplayName string `yaml:"project_display_name,omitempty"`
 	InstanceID         string `yaml:"instance_id,omitempty"`
 	InstanceName       string `yaml:"instance_name,omitempty"`
+	AutoUpgrade        *bool  `yaml:"auto_upgrade,omitempty"` // nil = default (on), true = on, false = off
+}
+
+// IsAutoUpgradeEnabled returns true if auto-upgrade is enabled (default: true).
+func (c *Config) IsAutoUpgradeEnabled() bool {
+	if c.AutoUpgrade == nil {
+		return true // default on
+	}
+	return *c.AutoUpgrade
 }
 
 // Credentials stores authentication tokens.