Refine AWS profile setup flow (#146)

Author: gtsiolis

CLAUDE.md

@@ -55,6 +55,14 @@ When adding a new command that depends on configuration, wire config initializat
 
 Created automatically on first run with defaults. Supports emulator types (aws, snowflake, azure) - currently only aws is implemented.
 
+# Emulator Setup Commands
+
+Use `lstk setup <emulator>` to set up CLI integration for an emulator type:
+- `lstk setup aws` — Sets up AWS CLI profile in `~/.aws/config` and `~/.aws/credentials`
+
+This naming avoids AWS-specific "profile" terminology and uses a clear verb for mutation operations.
+The deprecated `lstk config profile` command still works but points users to `lstk setup aws`.
+
 Environment variables:
 - `LOCALSTACK_AUTH_TOKEN` - Auth token (skips browser login if set)
 

README.md

@@ -83,6 +83,14 @@ To see which config file is currently in use:
 lstk config path
 ```
 
+You can also configure AWS CLI integration:
+
+```bash
+lstk setup aws
+```
+
+This sets up a `localstack` profile in `~/.aws/config` and `~/.aws/credentials`.
+
 You can also point `lstk` at a specific config file for any command:
 
 ```bash
@@ -184,6 +192,9 @@ lstk update
 # Show resolved config file path
 lstk config path
 
+# Set up AWS CLI profile integration
+lstk setup aws
+
 ```
 
 ## Reporting bugs

cmd/config.go

@@ -6,6 +6,7 @@ import (
 	"github.com/localstack/lstk/internal/config"
 	"github.com/localstack/lstk/internal/env"
 	"github.com/localstack/lstk/internal/telemetry"
+	"github.com/localstack/lstk/internal/ui"
 	"github.com/spf13/cobra"
 )
 
@@ -14,10 +15,32 @@ func newConfigCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
 		Use:   "config",
 		Short: "Manage configuration",
 	}
+	cmd.AddCommand(newConfigProfileCmd(cfg, tel))
 	cmd.AddCommand(newConfigPathCmd(cfg, tel))
 	return cmd
 }
 
+func newConfigProfileCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
+	return &cobra.Command{
+		Use:     "profile",
+		Short:   "Deprecated: use 'lstk setup aws' instead",
+		PreRunE: initConfig,
+		RunE: commandWithTelemetry("config profile", tel, func(cmd *cobra.Command, args []string) error {
+			appConfig, err := config.Get()
+			if err != nil {
+				return fmt.Errorf("failed to get config: %w", err)
+			}
+
+			if !isInteractiveMode(cfg) {
+				return fmt.Errorf("config profile requires an interactive terminal")
+			}
+
+			// Delegate to the same handler as "lstk setup aws"
+			return ui.RunConfigProfile(cmd.Context(), appConfig.Containers, cfg.LocalStackHost)
+		}),
+	}
+}
+
 func newConfigPathCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
 	return &cobra.Command{
 		Use:   "path",

cmd/root.go

@@ -59,6 +59,7 @@ func NewRootCmd(cfg *env.Env, tel *telemetry.Client, logger log.Logger) *cobra.C
 		newLogoutCmd(cfg, tel, logger),
 		newStatusCmd(cfg, tel),
 		newLogsCmd(cfg, tel),
+		newSetupCmd(cfg, tel),
 		newConfigCmd(cfg, tel),
 		newUpdateCmd(cfg, tel),
 		newDocsCmd(),

cmd/setup.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/localstack/lstk/internal/config"
+	"github.com/localstack/lstk/internal/env"
+	"github.com/localstack/lstk/internal/telemetry"
+	"github.com/localstack/lstk/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+func newSetupCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "setup",
+		Short: "Set up emulator CLI integration",
+		Long:  "Set up emulator CLI integration (e.g., AWS, Snowflake, Azure). Currently only AWS is supported.",
+	}
+	cmd.AddCommand(newSetupAWSCmd(cfg, tel))
+	return cmd
+}
+
+func newSetupAWSCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
+	return &cobra.Command{
+		Use:     "aws",
+		Short:   "Set up the LocalStack AWS profile",
+		Long:    "Set up the LocalStack AWS profile in ~/.aws/config and ~/.aws/credentials for use with AWS CLI and SDKs.",
+		PreRunE: initConfig,
+		RunE: commandWithTelemetry("setup aws", tel, func(cmd *cobra.Command, args []string) error {
+			appConfig, err := config.Get()
+			if err != nil {
+				return fmt.Errorf("failed to get config: %w", err)
+			}
+
+			if !isInteractiveMode(cfg) {
+				return fmt.Errorf("setup aws requires an interactive terminal")
+			}
+
+			return ui.RunConfigProfile(cmd.Context(), appConfig.Containers, cfg.LocalStackHost)
+		}),
+	}
+}

internal/awsconfig/awsconfig.go

@@ -76,8 +76,12 @@ func (s profileStatus) anyNeeded() bool {
 	return s.configNeeded || s.credsNeeded
 }
 
-// checkProfileStatus determines which AWS profile files need to be written or updated.
-func checkProfileStatus(configPath, credsPath, resolvedHost string) (profileStatus, error) {
+// CheckProfileStatus determines which AWS profile files need to be written or updated.
+func CheckProfileStatus(resolvedHost string) (profileStatus, error) {
+	configPath, credsPath, err := awsPaths()
+	if err != nil {
+		return profileStatus{}, err
+	}
 	configNeeded, err := configNeedsWrite(configPath, resolvedHost)
 	if err != nil {
 		return profileStatus{}, err
@@ -184,40 +188,84 @@ func writeCredsProfile(credsPath string) error {
 	return upsertSection(credsPath, credsSectionName, credentialsDefaults())
 }
 
-// Setup checks for the localstack AWS profile and prompts to create or update it if needed.
-// resolvedHost must be a host:port string (e.g. "localhost.localstack.cloud:4566").
-// In non-interactive mode, emits a note instead of prompting.
-func Setup(ctx context.Context, sink output.Sink, interactive bool, resolvedHost string) error {
+func emitMissingProfileNote(sink output.Sink) {
+	output.EmitNote(sink, "LocalStack AWS profile is incomplete. Run 'lstk setup aws'.")
+}
+
+// checkProfileSetup returns both the profile status (which files need writing) and presence (which files exist).
+// This avoids loading the same files twice by combining needsProfileSetup and profilePresence.
+func checkProfileSetup(resolvedHost string) (profileStatus, bool, bool, error) {
 	configPath, credsPath, err := awsPaths()
 	if err != nil {
-		output.EmitWarning(sink, fmt.Sprintf("could not determine AWS config paths: %v", err))
-		return nil
+		return profileStatus{}, false, false, err
+	}
+
+	status, err := CheckProfileStatus(resolvedHost)
+	if err != nil {
+		return profileStatus{}, false, false, err
+	}
+
+	configOK, err := sectionExists(configPath, configSectionName)
+	if err != nil {
+		return profileStatus{}, false, false, err
+	}
+	credsOK, err := sectionExists(credsPath, credsSectionName)
+	if err != nil {
+		return profileStatus{}, false, false, err
 	}
 
-	status, err := checkProfileStatus(configPath, credsPath, resolvedHost)
+	return status, configOK, credsOK, nil
+}
+
+// EnsureProfile checks for the LocalStack AWS profile and either emits a note when it is incomplete
+// or triggers the interactive setup flow.
+// resolvedHost must be a host:port string (e.g. "localhost.localstack.cloud:4566").
+func EnsureProfile(ctx context.Context, sink output.Sink, interactive bool, resolvedHost string) error {
+	status, configOK, credsOK, err := checkProfileSetup(resolvedHost)
 	if err != nil {
 		output.EmitWarning(sink, fmt.Sprintf("could not check AWS profile: %v", err))
 		return nil
 	}
 	if !status.anyNeeded() {
 		return nil
 	}
+	if interactive && !configOK && !credsOK {
+		return Setup(ctx, sink, resolvedHost, status)
+	}
+
+	emitMissingProfileNote(sink)
+	return nil
+}
+
+// Setup checks for the localstack AWS profile and prompts to create or update it if needed.
+// resolvedHost must be a host:port string (e.g. "localhost.localstack.cloud:4566").
+// status is passed in from EnsureProfile to avoid re-checking the profile status.
+func Setup(ctx context.Context, sink output.Sink, resolvedHost string, status profileStatus) error {
+	if !status.anyNeeded() {
+		output.EmitNote(sink, "LocalStack AWS profile is already configured.")
+		return nil
+	}
 
-	if !interactive {
-		output.EmitNote(sink, fmt.Sprintf("No complete LocalStack AWS profile found. Run lstk interactively to configure one, or add a [profile %s] section to ~/.aws/config manually.", profileName))
+	configPath, credsPath, err := awsPaths()
+	if err != nil {
+		output.EmitWarning(sink, fmt.Sprintf("could not determine AWS config paths: %v", err))
 		return nil
 	}
 
 	responseCh := make(chan output.InputResponse, 1)
 	output.EmitUserInputRequest(sink, output.UserInputRequestEvent{
-		Prompt:     "Configure AWS profile in ~/.aws/?",
+		Prompt:     "Set up a LocalStack profile for AWS CLI and SDKs in ~/.aws?",
 		Options:    []output.InputOption{{Key: "y", Label: "Y"}, {Key: "n", Label: "n"}},
 		ResponseCh: responseCh,
 	})
 
 	select {
 	case resp := <-responseCh:
-		if resp.Cancelled || resp.SelectedKey == "n" {
+		if resp.Cancelled {
+			return nil
+		}
+		if resp.SelectedKey == "n" {
+			output.EmitNote(sink, "Skipped adding LocalStack AWS profile.")
 			return nil
 		}
 		if status.configNeeded {
@@ -232,12 +280,16 @@ func Setup(ctx context.Context, sink output.Sink, interactive bool, resolvedHost
 				return nil
 			}
 		}
-		output.EmitSuccess(sink, "AWS profile successfully configured")
-		output.EmitNote(sink, fmt.Sprintf("Try: aws s3 mb s3://test --profile %s", profileName))
+		if status.configNeeded && status.credsNeeded {
+			output.EmitSuccess(sink, "Created LocalStack profile in ~/.aws")
+		} else if status.configNeeded {
+			output.EmitSuccess(sink, "Created LocalStack profile in ~/.aws/config")
+		} else {
+			output.EmitSuccess(sink, "Updated LocalStack credentials in ~/.aws/credentials")
+		}
 	case <-ctx.Done():
 		return ctx.Err()
 	}
 
 	return nil
 }
-

internal/awsconfig/awsconfig_test.go

@@ -199,7 +199,8 @@ func TestCheckProfileStatus(t *testing.T) {
 			if tc.credsContent != "" {
 				writeFile(t, credsPath, tc.credsContent)
 			}
-			status, err := checkProfileStatus(configPath, credsPath, tc.resolvedHost)
+			t.Setenv("HOME", dir)
+			status, err := CheckProfileStatus(tc.resolvedHost)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -221,7 +222,9 @@ func TestCheckProfileStatusMalformedFile(t *testing.T) {
 	writeFile(t, configPath, "this is not valid \x00\x01\x02 ini content [[[")
 	writeFile(t, credsPath, "[localstack]\naws_access_key_id = test\naws_secret_access_key = test\n")
 
-	_, err := checkProfileStatus(configPath, credsPath, "127.0.0.1:4566")
+	// Override HOME to use our test directory
+	t.Setenv("HOME", dir)
+	_, err := CheckProfileStatus("127.0.0.1:4566")
 	if err == nil {
 		t.Error("expected error for malformed config file, got nil")
 	}

internal/config/containers.go

@@ -137,4 +137,4 @@ func (c *ContainerConfig) ProductName() (string, error) {
 		return "", fmt.Errorf("%s emulator not supported yet by lstk", c.Type)
 	}
 	return productName, nil
-}
+}

internal/container/start.go

@@ -190,7 +190,7 @@ func Start(ctx context.Context, rt runtime.Runtime, sink output.Sink, opts Start
 	// Maps emulator types to their post-start setup functions.
 	// Add an entry here to run setup for a new emulator type (e.g. Azure, Snowflake).
 	setups := map[config.EmulatorType]postStartSetupFunc{
-		config.EmulatorAWS: awsconfig.Setup,
+		config.EmulatorAWS: awsconfig.EnsureProfile,
 	}
 	return runPostStartSetups(ctx, sink, opts.Containers, interactive, opts.LocalStackHost, opts.WebAppURL, setups)
 }

internal/ui/app.go

@@ -96,10 +96,10 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		if a.pendingInput != nil {
 			if opt := resolveOption(a.pendingInput.Options, msg); opt != nil {
-				a.lines = appendLine(a.lines, styledLine{text: formatResolvedInput(*a.pendingInput, opt.Key)})
 				responseCmd := sendInputResponseCmd(a.pendingInput.ResponseCh, output.InputResponse{SelectedKey: opt.Key})
 				a.pendingInput = nil
-				a.inputPrompt = a.inputPrompt.Hide()
+				a.inputPrompt = components.NewInputPrompt()
+				a.spinner = a.spinner.SetText("")
 				return a, responseCmd
 			}
 		}
@@ -295,27 +295,6 @@ func (a *App) flushBufferedLines() {
 	a.bufferedLines = nil
 }
 
-func formatResolvedInput(req output.UserInputRequestEvent, selectedKey string) string {
-	formatted := output.FormatPrompt(req.Prompt, req.Options)
-	firstLine := strings.Split(formatted, "\n")[0]
-
-	selected := selectedKey
-	hasLabels := false
-	for _, opt := range req.Options {
-		if opt.Label != "" {
-			hasLabels = true
-		}
-		if opt.Key == selectedKey && opt.Label != "" {
-			selected = opt.Label
-		}
-	}
-
-	if selected == "" || !hasLabels || selectedKey == "any" {
-		return firstLine
-	}
-	return fmt.Sprintf("%s %s", firstLine, selected)
-}
-
 // resolveOption finds the best matching option for a key event, in priority order:
 //  1. "any" — matches any keypress
 //  2. "enter" — matches the Enter key explicitly