move to two flag approach to match prompt

Author: kkemple

.cursor/rules/always-recommend-test-updates.mdc

@@ -0,0 +1,13 @@
+---
+description: 
+globs: *.go
+alwaysApply: false
+---
+After modifying any Go file:
+1. Check for a corresponding _test.go file in the same directory
+2. If found, inspect the test file to identify test cases related to your changes
+3. Recommend any tests to add, update, or remove to cover the new implementation and behavior
+
+When adding new flags or command options, be sure to add:
+1. Tests for the flag parsing/presence in help text
+2. Tests for the actual behavior when the flag is set or not set

.cursor/rules/cleanup-after-changes.mdc

@@ -0,0 +1,11 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+After modifying any file:
+1. Use grep and/or search project index for the old feature name/variable names that were replaced
+2. Check for references in documentation, comments, and test files
+3. Look for any deprecated or unused code that can be safely removed or updated
+4. Update all related tests to reflect the new implementation
+5. Verify any usage examples in documentation are consistent with code changes

.gitignore

@@ -34,9 +34,6 @@ package-lock.json
 # VSCode extensions
 *.http
 
-# Cursor rules
-.cursor/rules
-
 # Temp log files
 *.log
 

cmd/upgrade/upgrade.go

@@ -31,7 +31,8 @@ var checkForUpdatesFunc = checkForUpdates
 const changelogURL = "https://docs.slack.dev/changelog"
 
 func NewCommand(clients *shared.ClientFactory) *cobra.Command {
-	var autoApprove bool
+	var cli bool
+	var sdk bool
 
 	cmd := &cobra.Command{
 		Use:     "upgrade",
@@ -46,21 +47,24 @@ func NewCommand(clients *shared.ClientFactory) *cobra.Command {
 		}, "\n"),
 		Example: style.ExampleCommandsf([]style.ExampleCommand{
 			{Command: "upgrade", Meaning: "Check for any available updates"},
-			{Command: "upgrade --auto-approve", Meaning: "Check for updates and automatically upgrade without confirmation"},
+			{Command: "upgrade --cli", Meaning: "Check for CLI updates and automatically upgrade without confirmation"},
+			{Command: "upgrade --sdk", Meaning: "Check for SDK updates and automatically upgrade without confirmation"},
+			{Command: "upgrade --cli --sdk", Meaning: "Check for updates and automatically upgrade both CLI and SDK without confirmation"},
 		}),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return checkForUpdatesFunc(clients, cmd, autoApprove)
+			return checkForUpdatesFunc(clients, cmd, cli, sdk)
 		},
 	}
 
-	cmd.Flags().BoolVar(&autoApprove, "auto-approve", false, "automatically approve and install updates without prompting")
+	cmd.Flags().BoolVar(&cli, "cli", false, "automatically approve and install CLI updates without prompting")
+	cmd.Flags().BoolVar(&sdk, "sdk", false, "automatically approve and install SDK updates without prompting")
 
 	return cmd
 }
 
 // checkForUpdates will check for CLI/SDK updates and print a message when no updates are available.
 // When there are updates, the function will *not* print a message because the root command handles printing update notifications.
-func checkForUpdates(clients *shared.ClientFactory, cmd *cobra.Command, autoApprove bool) error {
+func checkForUpdates(clients *shared.ClientFactory, cmd *cobra.Command, cli bool, sdk bool) error {
 	ctx := cmd.Context()
 	updateNotification := update.New(clients, version.Get(), "SLACK_SKIP_UPDATE")
 
@@ -77,9 +81,9 @@ func checkForUpdates(clients *shared.ClientFactory, cmd *cobra.Command, autoAppr
 	// Update notification messages are printed by the root command's persistent post-run (cmd/root.go).
 	// So this command only needs to print a message when everything is up-to-date.
 	if updateNotification.HasUpdate() {
-		if autoApprove {
-			// Automatically install updates without prompting when auto-approve flag is set
-			if err := updateNotification.InstallUpdatesWithoutPrompt(cmd); err != nil {
+		// Automatically install updates without prompting when cli or sdk flags are set
+		if cli || sdk {
+			if err := updateNotification.InstallUpdatesWithComponentFlags(cmd, cli, sdk); err != nil {
 				return err
 			}
 			return nil

cmd/upgrade/upgrade_test.go

@@ -29,8 +29,8 @@ type UpdatePkgMock struct {
 	mock.Mock
 }
 
-func (m *UpdatePkgMock) CheckForUpdates(clients *shared.ClientFactory, cmd *cobra.Command, autoApprove bool) error {
-	args := m.Called(clients, cmd, autoApprove)
+func (m *UpdatePkgMock) CheckForUpdates(clients *shared.ClientFactory, cmd *cobra.Command, cli bool, sdk bool) error {
+	args := m.Called(clients, cmd, cli, sdk)
 	return args.Error(0)
 }
 
@@ -49,32 +49,62 @@ func TestUpgradeCommand(t *testing.T) {
 	updatePkgMock := new(UpdatePkgMock)
 	checkForUpdatesFunc = updatePkgMock.CheckForUpdates
 
-	// Test default behavior (no auto-approve)
-	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, false).Return(nil)
+	// Test default behavior (no flags)
+	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, false, false).Return(nil)
 	err := cmd.ExecuteContext(ctx)
 	if err != nil {
 		assert.Fail(t, "cmd.Upgrade had unexpected error")
 	}
-	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, false)
+	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, false, false)
 
-	// Test with auto-approve flag
+	// Test with CLI flag
 	cmd = NewCommand(clients)
 	testutil.MockCmdIO(clients.IO, cmd)
-	cmd.SetArgs([]string{"--auto-approve"})
+	cmd.SetArgs([]string{"--cli"})
 
 	updatePkgMock = new(UpdatePkgMock)
 	checkForUpdatesFunc = updatePkgMock.CheckForUpdates
-	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, true).Return(nil)
+	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, true, false).Return(nil)
 
 	err = cmd.ExecuteContext(ctx)
 	if err != nil {
-		assert.Fail(t, "cmd.Upgrade with auto-approve had unexpected error")
+		assert.Fail(t, "cmd.Upgrade with cli flag had unexpected error")
 	}
-	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, true)
+	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, true, false)
+
+	// Test with SDK flag
+	cmd = NewCommand(clients)
+	testutil.MockCmdIO(clients.IO, cmd)
+	cmd.SetArgs([]string{"--sdk"})
+
+	updatePkgMock = new(UpdatePkgMock)
+	checkForUpdatesFunc = updatePkgMock.CheckForUpdates
+	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, false, true).Return(nil)
+
+	err = cmd.ExecuteContext(ctx)
+	if err != nil {
+		assert.Fail(t, "cmd.Upgrade with sdk flag had unexpected error")
+	}
+	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, false, true)
+
+	// Test with both CLI and SDK flags
+	cmd = NewCommand(clients)
+	testutil.MockCmdIO(clients.IO, cmd)
+	cmd.SetArgs([]string{"--cli", "--sdk"})
+
+	updatePkgMock = new(UpdatePkgMock)
+	checkForUpdatesFunc = updatePkgMock.CheckForUpdates
+	updatePkgMock.On("CheckForUpdates", mock.Anything, mock.Anything, true, true).Return(nil)
+
+	err = cmd.ExecuteContext(ctx)
+	if err != nil {
+		assert.Fail(t, "cmd.Upgrade with both cli and sdk flags had unexpected error")
+	}
+	updatePkgMock.AssertCalled(t, "CheckForUpdates", mock.Anything, mock.Anything, true, true)
 }
 
-func TestUpgradeCommandWithAutoApproveError(t *testing.T) {
-	// Create a mock of UpdateNotification that returns an error on InstallUpdatesWithoutPrompt
+func TestUpgradeCommandWithFlagError(t *testing.T) {
+	// Create a mock of UpdateNotification that returns an error on InstallUpdatesWithComponentFlags
 	originalCheckForUpdates := checkForUpdatesFunc
 	defer func() {
 		checkForUpdatesFunc = originalCheckForUpdates
@@ -87,23 +117,47 @@ func TestUpgradeCommandWithAutoApproveError(t *testing.T) {
 	// Create clients that is mocked for testing
 	clients := shared.NewClientFactory(clientsMock.MockClientFactory())
 
-	// Mock the checkForUpdates function to simulate an error during auto-approve updates
-	checkForUpdatesFunc = func(clients *shared.ClientFactory, cmd *cobra.Command, autoApprove bool) error {
-		if autoApprove {
-			return assert.AnError // Simulate error when auto-approve is true
+	// Mock the checkForUpdates function to simulate an error during flag-based updates
+	checkForUpdatesFunc = func(clients *shared.ClientFactory, cmd *cobra.Command, cli bool, sdk bool) error {
+		if cli || sdk {
+			return assert.AnError // Simulate error when either flag is true
 		}
 		return nil
 	}
 
-	// Create the command with auto-approve flag
+	// Test with CLI flag causing error
 	cmd := NewCommand(clients)
 	testutil.MockCmdIO(clients.IO, cmd)
-	cmd.SetArgs([]string{"--auto-approve"})
+	cmd.SetArgs([]string{"--cli"})
 
 	// Execute the command and verify it returns the error
 	err := cmd.ExecuteContext(ctx)
 
 	// Verify the error was properly propagated
 	assert.Error(t, err)
 	assert.Equal(t, assert.AnError, err)
+
+	// Test with SDK flag causing error
+	cmd = NewCommand(clients)
+	testutil.MockCmdIO(clients.IO, cmd)
+	cmd.SetArgs([]string{"--sdk"})
+
+	// Execute the command and verify it returns the error
+	err = cmd.ExecuteContext(ctx)
+
+	// Verify the error was properly propagated
+	assert.Error(t, err)
+	assert.Equal(t, assert.AnError, err)
+
+	// Test with both flags causing error
+	cmd = NewCommand(clients)
+	testutil.MockCmdIO(clients.IO, cmd)
+	cmd.SetArgs([]string{"--cli", "--sdk"})
+
+	// Execute the command and verify it returns the error
+	err = cmd.ExecuteContext(ctx)
+
+	// Verify the error was properly propagated
+	assert.Error(t, err)
+	assert.Equal(t, assert.AnError, err)
 }

docs/reference/commands/slack_upgrade.md

@@ -18,14 +18,17 @@ slack upgrade [flags]
 
 ```
 $ slack upgrade  # Check for any available updates
-$ slack upgrade --auto-approve  # Check for updates and automatically upgrade without confirmation
+$ slack upgrade --cli  # Check for CLI updates and automatically upgrade without confirmation
+$ slack upgrade --sdk  # Check for SDK updates and automatically upgrade without confirmation
+$ slack upgrade --cli --sdk  # Check for updates and automatically upgrade both CLI and SDK without confirmation
 ```
 
 ### Options
 
 ```
-      --auto-approve   automatically approve and install updates without prompting
+      --cli            automatically approve and install CLI updates without prompting
   -h, --help           help for upgrade
+      --sdk            automatically approve and install SDK updates without prompting
 ```
 
 ### Options inherited from parent commands

internal/update/cli.go

@@ -94,10 +94,10 @@ func (c *CLIDependency) PrintUpdateNotification(cmd *cobra.Command) (bool, error
 			style.CommandText("https://tools.slack.dev/slack-cli"),
 		)
 
-		// Check for auto-approve from upgrade command
-		if cmd.Name() == "upgrade" && cmd.Flags().Changed("auto-approve") {
-			autoApprove, _ := cmd.Flags().GetBool("auto-approve")
-			if autoApprove {
+		// Check for cli flag from upgrade command
+		if cmd.Name() == "upgrade" && cmd.Flags().Changed("cli") {
+			cli, _ := cmd.Flags().GetBool("cli")
+			if cli {
 				return true, nil
 			}
 		}

internal/update/sdk.go

@@ -319,10 +319,10 @@ func (c *SDKDependency) PrintUpdateNotification(cmd *cobra.Command) (bool, error
 
 	// If `install-update` hook available, prompt to auto-update
 	if c.clients.SDKConfig.Hooks.InstallUpdate.IsAvailable() {
-		// Check for auto-approve from upgrade command
-		if cmd.Name() == "upgrade" && cmd.Flags().Changed("auto-approve") {
-			autoApprove, _ := cmd.Flags().GetBool("auto-approve")
-			if autoApprove {
+		// Check for sdk flag from upgrade command
+		if cmd.Name() == "upgrade" && cmd.Flags().Changed("sdk") {
+			sdk, _ := cmd.Flags().GetBool("sdk")
+			if sdk {
 				return true, nil
 			}
 		}

internal/update/update.go

@@ -30,6 +30,17 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// Functions for type checking that can be replaced in tests
+var isDependencyCLI = func(d Dependency) bool {
+	_, isCLI := d.(*CLIDependency)
+	return isCLI
+}
+
+var isDependencySDK = func(d Dependency) bool {
+	_, isSDK := d.(*SDKDependency)
+	return isSDK
+}
+
 // UpdateNotification checks for an update (non-blocking in the background or blocking).
 // It provides the release information for the latest update of each dependency.
 type UpdateNotification struct {
@@ -254,7 +265,7 @@ func newHTTPClient() (*http.Client, error) {
 }
 
 // InstallUpdatesWithoutPrompt automatically installs updates without prompting the user
-// This is used by the upgrade command when the --auto-approve flag is set
+// This is a legacy method maintained for backward compatibility
 func (u *UpdateNotification) InstallUpdatesWithoutPrompt(cmd *cobra.Command) error {
 	ctx := cmd.Context()
 
@@ -280,3 +291,40 @@ func (u *UpdateNotification) InstallUpdatesWithoutPrompt(cmd *cobra.Command) err
 	}
 	return nil
 }
+
+// InstallUpdatesWithComponentFlags automatically installs updates for specified components
+// without prompting the user. This is used by the upgrade command when the --cli
+// or --sdk flags are set.
+func (u *UpdateNotification) InstallUpdatesWithComponentFlags(cmd *cobra.Command, cli bool, sdk bool) error {
+	ctx := cmd.Context()
+
+	for _, dependency := range u.Dependencies() {
+		// Skip dependencies that don't match the specified flags
+		if isDependencyCLI(dependency) && !cli {
+			continue
+		}
+		if isDependencySDK(dependency) && !sdk {
+			continue
+		}
+
+		hasUpdate, err := dependency.HasUpdate()
+		if err != nil {
+			return slackerror.Wrap(err, "An error occurred while fetching a dependency")
+		}
+
+		if hasUpdate {
+			// Print update notification but skip the confirmation prompt
+			_, err := dependency.PrintUpdateNotification(cmd)
+			if err != nil {
+				return err
+			}
+
+			// Install the update without prompting
+			cmd.Printf("%s Installing update automatically...\n", style.Styler().Green("✓").String())
+			if err := dependency.InstallUpdate(ctx); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}