feat(bolt-install): support using 'install' command with remote manifests

cmd/app/add.go

@@ -85,38 +85,36 @@ func preRunAddCommand(ctx context.Context, clients *shared.ClientFactory) error
 	if !clients.Config.WithExperimentOn(experiment.BoltFrameworks) {
 		return nil
 	}
-	manifestSource, err := clients.Config.ProjectConfig.GetManifestSource(ctx)
-	if err != nil {
-		return err
-	}
-	if manifestSource.Equals(config.ManifestSourceRemote) {
-		return slackerror.New(slackerror.ErrAppInstall).
-			WithMessage("Apps cannot be installed due to project configurations").
-			WithRemediation(
-				"Install an app on app settings: %s\nLink an app to this project with %s\nList apps saved with this project using %s",
-				style.LinkText("https://api.slack.com/apps"),
-				style.Commandf("app link", false),
-				style.Commandf("app list", false),
-			).
-			WithDetails(slackerror.ErrorDetails{
-				slackerror.ErrorDetail{
-					Code:    slackerror.ErrProjectConfigManifestSource,
-					Message: "Cannot install apps with manifests sourced from app settings",
-				},
-			})
-	}
 	return nil
 }
 
 // RunAddCommand executes the workspace install command, prints output, and returns any errors.
 func RunAddCommand(ctx context.Context, clients *shared.ClientFactory, selection *prompts.SelectedApp, orgGrantWorkspaceID string) (context.Context, types.InstallState, types.App, error) {
 	if selection == nil {
-		selected, err := teamAppSelectPromptFunc(ctx, clients, prompts.ShowHostedOnly, prompts.ShowAllApps)
+		// Prompt for deployed or local app environment.
+		isProductionApp, err := promptIsProduction(ctx, clients)
+		if err != nil {
+			return ctx, "", types.App{}, err
+		}
+
+		var appEnvironmentType prompts.AppEnvironmentType
+		if isProductionApp {
+			appEnvironmentType = prompts.ShowHostedOnly
+		} else {
+			appEnvironmentType = prompts.ShowLocalOnly
+		}
+
+		selected, err := teamAppSelectPromptFunc(ctx, clients, appEnvironmentType, prompts.ShowAllApps)
 		if err != nil {
 			return ctx, "", types.App{}, err
 		}
 		selection = &selected
+
+		if !isProductionApp {
+			selection.App.IsDev = true
+		}
 	}
+
 	if selection.Auth.TeamDomain == "" {
 		return ctx, "", types.App{}, slackerror.New(slackerror.ErrCredentialsNotFound)
 	}

cmd/app/add_test.go

@@ -24,11 +24,11 @@ import (
 	"github.com/slackapi/slack-cli/internal/cmdutil"
 	"github.com/slackapi/slack-cli/internal/config"
 	"github.com/slackapi/slack-cli/internal/experiment"
+	"github.com/slackapi/slack-cli/internal/iostreams"
 	"github.com/slackapi/slack-cli/internal/prompts"
 	"github.com/slackapi/slack-cli/internal/shared"
 	"github.com/slackapi/slack-cli/internal/shared/types"
 	"github.com/slackapi/slack-cli/internal/slackerror"
-	"github.com/slackapi/slack-cli/internal/style"
 	"github.com/slackapi/slack-cli/test/testutil"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/mock"
@@ -85,40 +85,27 @@ func TestAppAddCommandPreRun(t *testing.T) {
 				cf.SDKConfig.WorkingDirectory = "."
 			},
 		},
-		"errors if manifest.source is remote with the bolt experiment": {
-			ExpectedError: slackerror.New(slackerror.ErrAppInstall).
-				WithMessage("Apps cannot be installed due to project configurations").
-				WithRemediation(
-					"Install an app on app settings: %s\nLink an app to this project with %s\nList apps saved with this project using %s",
-					style.LinkText("https://api.slack.com/apps"),
-					style.Commandf("app link", false),
-					style.Commandf("app list", false),
-				).
-				WithDetails(slackerror.ErrorDetails{
-					slackerror.ErrorDetail{
-						Code:    slackerror.ErrProjectConfigManifestSource,
-						Message: "Cannot install apps with manifests sourced from app settings",
-					},
-				}),
+		"proceeds if manifest.source is local with the bolt experiment": {
+			ExpectedError: nil,
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
 				cf.SDKConfig.WorkingDirectory = "."
 				cm.AddDefaultMocks()
 				cm.Config.ExperimentsFlag = append(cm.Config.ExperimentsFlag, string(experiment.BoltFrameworks))
 				cm.Config.LoadExperiments(ctx, cm.IO.PrintDebug)
 				mockProjectConfig := config.NewProjectConfigMock()
-				mockProjectConfig.On("GetManifestSource", mock.Anything).Return(config.ManifestSourceRemote, nil)
+				mockProjectConfig.On("GetManifestSource", mock.Anything).Return(config.ManifestSourceLocal, nil)
 				cm.Config.ProjectConfig = mockProjectConfig
 			},
 		},
-		"proceeds if manifest.source is local with the bolt experiment": {
+		"proceeds if manifest.source is remote with the bolt experiment": {
 			ExpectedError: nil,
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
 				cf.SDKConfig.WorkingDirectory = "."
 				cm.AddDefaultMocks()
 				cm.Config.ExperimentsFlag = append(cm.Config.ExperimentsFlag, string(experiment.BoltFrameworks))
 				cm.Config.LoadExperiments(ctx, cm.IO.PrintDebug)
 				mockProjectConfig := config.NewProjectConfigMock()
-				mockProjectConfig.On("GetManifestSource", mock.Anything).Return(config.ManifestSourceLocal, nil)
+				mockProjectConfig.On("GetManifestSource", mock.Anything).Return(config.ManifestSourceRemote, nil)
 				cm.Config.ProjectConfig = mockProjectConfig
 			},
 		},
@@ -130,13 +117,84 @@ func TestAppAddCommandPreRun(t *testing.T) {
 }
 
 func TestAppAddCommand(t *testing.T) {
-
 	testutil.TableTestCommand(t, testutil.CommandTests{
+		"adds a new local app": {
+			CmdArgs:         []string{},
+			ExpectedOutputs: []string{"Creating app manifest", "Installing"},
+			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
+				prepareAddMocks(t, cf, cm, "local")
+
+				// Mock TeamSelector prompt to return "team1"
+				appSelectMock := prompts.NewAppSelectMock()
+				teamAppSelectPromptFunc = appSelectMock.TeamAppSelectPrompt
+				appSelectMock.On("TeamAppSelectPrompt").Return(prompts.SelectedApp{Auth: mockAuthTeam1}, nil)
+
+				// Mock valid session for team1
+				cm.API.On("ValidateSession", mock.Anything, mock.Anything).Return(api.AuthSession{
+					UserID:   &mockAuthTeam1.UserID,
+					TeamID:   &mockAuthTeam1.TeamID,
+					TeamName: &mockAuthTeam1.TeamDomain,
+				}, nil)
+
+				// Mock a clean ValidateAppManifest result
+				cm.API.On("ValidateAppManifest", mock.Anything, mockAuthTeam1.Token, mock.Anything, mock.Anything).Return(
+					api.ValidateAppManifestResult{
+						Warnings: slackerror.Warnings{},
+					}, nil,
+				)
+
+				// Mock Host
+				cm.API.On("Host").Return("")
+
+				// Mock a successful CreateApp call and return our mocked AppID
+				cm.API.On("CreateApp", mock.Anything, mockAuthTeam1.Token, mock.Anything, mock.Anything).Return(
+					api.CreateAppResult{
+						AppID: mockAppTeam1.AppID,
+					},
+					nil,
+				)
+
+				// Mock a successful DeveloperAppInstall
+				cm.API.On("DeveloperAppInstall", mock.Anything, mock.Anything, mockAuthTeam1.Token, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
+					api.DeveloperAppInstallResult{
+						AppID: mockAppTeam1.AppID,
+						APIAccessTokens: struct {
+							Bot      string "json:\"bot,omitempty\""
+							AppLevel string "json:\"app_level,omitempty\""
+							User     string "json:\"user,omitempty\""
+						}{},
+					},
+					types.InstallSuccess,
+					nil,
+				)
+
+				// Mock existing and updated cache
+				cm.API.On(
+					"ExportAppManifest",
+					mock.Anything,
+					mock.Anything,
+					mock.Anything,
+				).Return(
+					api.ExportAppResult{},
+					nil,
+				)
+				mockProjectCache := cache.NewCacheMock()
+				mockProjectCache.On("GetManifestHash", mock.Anything, mock.Anything).
+					Return(cache.Hash(""), nil)
+				mockProjectCache.On("NewManifestHash", mock.Anything, mock.Anything).
+					Return(cache.Hash("xoxo"), nil)
+				mockProjectCache.On("SetManifestHash", mock.Anything, mock.Anything, mock.Anything).
+					Return(nil)
+				mockProjectConfig := config.NewProjectConfigMock()
+				mockProjectConfig.On("Cache").Return(mockProjectCache)
+				cm.Config.ProjectConfig = mockProjectConfig
+			},
+		},
 		"adds a new deployed app": {
 			CmdArgs:         []string{},
 			ExpectedOutputs: []string{"Creating app manifest", "Installing"},
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 
 				// Mock TeamSelector prompt to return "team1"
 				appSelectMock := prompts.NewAppSelectMock()
@@ -208,7 +266,7 @@ func TestAppAddCommand(t *testing.T) {
 			CmdArgs:         []string{},
 			ExpectedOutputs: []string{"Updated app manifest"},
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 
 				// Mock TeamSelector prompt to return "team1"
 				appSelectMock := prompts.NewAppSelectMock()
@@ -290,7 +348,7 @@ func TestAppAddCommand(t *testing.T) {
 			CmdArgs:       []string{},
 			ExpectedError: slackerror.New(slackerror.ErrCredentialsNotFound),
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 				appSelectMock := prompts.NewAppSelectMock()
 				teamAppSelectPromptFunc = appSelectMock.TeamAppSelectPrompt
 				appSelectMock.On("TeamAppSelectPrompt").Return(prompts.SelectedApp{App: mockAppTeam1}, nil)
@@ -300,7 +358,7 @@ func TestAppAddCommand(t *testing.T) {
 			CmdArgs:         []string{"--" + cmdutil.OrgGrantWorkspaceFlag, "T123"},
 			ExpectedOutputs: []string{"Creating app manifest", "Installing"},
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 				// Select workspace
 				appSelectMock := prompts.NewAppSelectMock()
 				teamAppSelectPromptFunc = appSelectMock.TeamAppSelectPrompt
@@ -360,7 +418,7 @@ func TestAppAddCommand(t *testing.T) {
 			CmdArgs:         []string{"--" + cmdutil.OrgGrantWorkspaceFlag, "T123"},
 			ExpectedOutputs: []string{"Creating app manifest", "Installing", "Your request to install the app is pending", "complete installation by re-running"},
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 				// Select workspace
 				appSelectMock := prompts.NewAppSelectMock()
 				teamAppSelectPromptFunc = appSelectMock.TeamAppSelectPrompt
@@ -416,7 +474,7 @@ func TestAppAddCommand(t *testing.T) {
 			CmdArgs:         []string{"--" + cmdutil.OrgGrantWorkspaceFlag, "T123"},
 			ExpectedOutputs: []string{"Creating app manifest", "Installing", "Your request to install the app has been cancelled"},
 			Setup: func(t *testing.T, ctx context.Context, cm *shared.ClientsMock, cf *shared.ClientFactory) {
-				prepareAddMocks(t, cf, cm)
+				prepareAddMocks(t, cf, cm, "deployed")
 				// Select workspace
 				appSelectMock := prompts.NewAppSelectMock()
 				teamAppSelectPromptFunc = appSelectMock.TeamAppSelectPrompt
@@ -475,7 +533,7 @@ func TestAppAddCommand(t *testing.T) {
 	})
 }
 
-func prepareAddMocks(t *testing.T, clients *shared.ClientFactory, clientsMock *shared.ClientsMock) {
+func prepareAddMocks(t *testing.T, clients *shared.ClientFactory, clientsMock *shared.ClientsMock, appEnvironment string) {
 	clientsMock.AddDefaultMocks()
 
 	clientsMock.Auth.On("ResolveAPIHost", mock.Anything, mock.Anything, mock.Anything).
@@ -498,4 +556,16 @@ func prepareAddMocks(t *testing.T, clients *shared.ClientFactory, clientsMock *s
 	listPkgMock := new(ListPkgMock)
 	listFunc = listPkgMock.List
 	listPkgMock.On("List").Return(nil)
+
+	// Mock the prompt to select the app environment.
+	clientsMock.IO.On("SelectPrompt",
+		mock.Anything,
+		"Choose the app environment",
+		mock.Anything,
+		mock.Anything,
+		mock.Anything,
+	).Return(iostreams.SelectPromptResponse{
+		Flag:   true,
+		Option: appEnvironment,
+	}, nil)
 }

cmd/platform/deploy.go

@@ -163,16 +163,24 @@ func hasValidDeploymentMethod(
 		return err
 	}
 	switch {
+	// When the manifest source is local, we can get the manifest from the local project.
 	case manifestSource.Equals(config.ManifestSourceLocal):
 		manifest, err = clients.AppClient().Manifest.GetManifestLocal(ctx, clients.SDKConfig, clients.HookExecutor)
 		if err != nil {
 			return err
 		}
-	case manifestSource.Equals(config.ManifestSourceRemote):
+	// When the manifest source is remote and the app exists, we can get the manifest from the the API.
+	case manifestSource.Equals(config.ManifestSourceRemote) && app.AppID != "":
 		manifest, err = clients.AppClient().Manifest.GetManifestRemote(ctx, auth.Token, app.AppID)
 		if err != nil {
 			return err
 		}
+	// When the app does not exist, we need to get the manifest from the local project.
+	default:
+		manifest, err = clients.AppClient().Manifest.GetManifestLocal(ctx, clients.SDKConfig, clients.HookExecutor)
+		if err != nil {
+			return err
+		}
 	}
 	if manifest.FunctionRuntime() == types.SlackHosted {
 		return nil

cmd/platform/deploy_test.go

@@ -111,6 +111,7 @@ func TestDeployCommand(t *testing.T) {
 
 func TestDeployCommand_HasValidDeploymentMethod(t *testing.T) {
 	tests := map[string]struct {
+		app            types.App
 		manifest       types.SlackYaml
 		manifestError  error
 		manifestSource config.ManifestSource
@@ -144,6 +145,20 @@ func TestDeployCommand_HasValidDeploymentMethod(t *testing.T) {
 			manifestSource: config.ManifestSourceLocal,
 			expectedError:  slackerror.New(slackerror.ErrSDKHookNotFound),
 		},
+		"succeeds if the app exists and the manifest source is remote": {
+			app: types.App{
+				AppID: "A123",
+			},
+			manifestSource: config.ManifestSourceRemote,
+			expectedError:  slackerror.New(slackerror.ErrSDKHookNotFound),
+		},
+		"succeeds if the app does not exist and the manifest source is remote": {
+			app: types.App{
+				AppID: "",
+			},
+			manifestSource: config.ManifestSourceRemote,
+			expectedError:  slackerror.New(slackerror.ErrSDKHookNotFound),
+		},
 	}
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
@@ -152,6 +167,7 @@ func TestDeployCommand_HasValidDeploymentMethod(t *testing.T) {
 			clients := shared.NewClientFactory(clientsMock.MockClientFactory(), func(clients *shared.ClientFactory) {
 				manifestMock := &app.ManifestMockObject{}
 				manifestMock.On("GetManifestLocal", mock.Anything, mock.Anything, mock.Anything).Return(tt.manifest, tt.manifestError)
+				manifestMock.On("GetManifestRemote", mock.Anything, mock.Anything, mock.Anything).Return(tt.manifest, tt.manifestError)
 				clients.AppClient().Manifest = manifestMock
 				projectConfigMock := config.NewProjectConfigMock()
 				projectConfigMock.On("GetManifestSource", mock.Anything).
@@ -160,7 +176,11 @@ func TestDeployCommand_HasValidDeploymentMethod(t *testing.T) {
 				clients.SDKConfig = hooks.NewSDKConfigMock()
 				clients.SDKConfig.Hooks.Deploy.Command = tt.deployScript
 			})
-			err := hasValidDeploymentMethod(ctx, clients, types.App{}, types.SlackAuth{})
+			app := types.App{}
+			if tt.app.AppID != "" {
+				app = tt.app
+			}
+			err := hasValidDeploymentMethod(ctx, clients, app, types.SlackAuth{})
 			if tt.expectedError != nil {
 				require.Error(t, err)
 				assert.Equal(

cmd/triggers/create.go

@@ -51,7 +51,6 @@ type createCmdFlags struct {
 
 var createFlags createCmdFlags
 
-// TODO(mcodik) figure out a way to mock this more nicely
 var createAppSelectPromptFunc = prompts.AppSelectPrompt
 var workspaceInstallAppFunc = app.RunAddCommand
 var createPromptShouldRetryWithInteractivityFunc = promptShouldRetryCreateWithInteractivity

docs/reference/experiments.md

@@ -8,13 +8,14 @@ The following is a list of currently available experiments. We'll remove experim
 
 * `bolt-install`: enables creating, installing, and running Bolt projects that manage their app manifest on app settings (remote manifest).
     * `slack create` and `slack init` now set manifest source to "app settings" (remote) for Bolt JS & Bolt Python projects ([PR#96](https://github.com/slackapi/slack-cli/pull/96)).
+    * `slack run` and `slack install` support creating and installing Bolt Framework apps that have the manifest source set to "app settings (remote)" ([PR#111](https://github.com/slackapi/slack-cli/pull/111), [PR#TODO](https://github.com/slackapi/slack-cli/pull/TODO)).
 * `read-only-collaborators`: enables creating and modifying collaborator permissions via the `slack collaborator` commands.
 
 ## Experiments changelog
 
 Below is a list of updates related to experiments.
 
-* **June 2025**: 
+* **June 2025**:
     * Updated the `slack run` command to create and install new and existing Bolt framework projects configured with app settings as the source of truth (remote manifest).
     * Added support for creating, installing, and running Bolt projects that manage their app manifest on app settings (remote manifest). New Bolt projects are now configured to have apps managed by app settings rather than by project. When running a project for local development, the app and bot tokens are automatically set, and no longer require developers to export them as environment variables. Existing Bolt projects will continue to work with a project (local) manifest, and linking an app from app settings will configure the project to be managed by app settings (remote manifest). In an upcoming release, support for installing and deploying apps managed by app settings will be implemented.
 * **May 2025**: Added the experiment `bolt-install` to enable creating, installing, and running Bolt projects that manage their app manifest on app settings (remote manifest).