Replace profile option with loading spinner

cmd/aws.go

@@ -0,0 +1,50 @@
+package cmd
+
+import (
+	"github.com/localstack/lstk/internal/awscli"
+	"github.com/localstack/lstk/internal/config"
+	"github.com/localstack/lstk/internal/endpoint"
+	"github.com/localstack/lstk/internal/env"
+	"github.com/localstack/lstk/internal/telemetry"
+	"github.com/spf13/cobra"
+)
+
+func newAWSCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
+	return &cobra.Command{
+		Use:   "aws [args...]",
+		Short: "Run AWS CLI commands against LocalStack",
+		Long: `Proxy AWS CLI commands to LocalStack with endpoint, credentials, and region pre-configured.
+
+Equivalent to running:
+  aws --endpoint-url http://localhost:4566 <args>
+with AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_DEFAULT_REGION set automatically.
+
+Examples:
+  lstk aws s3 ls
+  lstk aws sqs list-queues
+  lstk aws s3 mb s3://my-bucket`,
+		DisableFlagParsing: true,
+		RunE: commandWithTelemetry("aws", tel, func(cmd *cobra.Command, args []string) error {
+			port := resolveAWSPort()
+			host, _ := endpoint.ResolveHost(port, cfg.LocalStackHost)
+			return awscli.Exec(cmd.Context(), "http://"+host, args)
+		}),
+	}
+}
+
+func resolveAWSPort() string {
+	const defaultPort = "4566"
+	if err := config.Init(); err != nil {
+		return defaultPort
+	}
+	appCfg, err := config.Get()
+	if err != nil {
+		return defaultPort
+	}
+	for _, c := range appCfg.Containers {
+		if c.Type == config.EmulatorAWS {
+			return c.Port
+		}
+	}
+	return defaultPort
+}

cmd/root.go

@@ -62,6 +62,7 @@ func NewRootCmd(cfg *env.Env, tel *telemetry.Client, logger log.Logger) *cobra.C
 		newConfigCmd(cfg, tel),
 		newUpdateCmd(cfg, tel),
 		newDocsCmd(),
+		newAWSCmd(cfg, tel),
 	)
 
 	return root

internal/awscli/exec.go

@@ -0,0 +1,90 @@
+package awscli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"github.com/localstack/lstk/internal/output"
+)
+
+// stopOnWriteWriter wraps a writer and stops the spinner on first write
+type stopOnWriteWriter struct {
+	w       io.Writer
+	spinner *spinner
+	once    sync.Once
+}
+
+func (s *stopOnWriteWriter) Write(p []byte) (int, error) {
+	s.once.Do(func() {
+		s.spinner.Stop()
+	})
+	return s.w.Write(p)
+}
+
+func Exec(ctx context.Context, endpointURL string, args []string) error {
+	awsBin, err := exec.LookPath("aws")
+	if err != nil {
+		return fmt.Errorf("aws CLI not found in PATH — install it from https://aws.amazon.com/cli/")
+	}
+
+	cmdArgs := make([]string, 0, len(args)+2)
+	cmdArgs = append(cmdArgs, "--endpoint-url", endpointURL)
+	cmdArgs = append(cmdArgs, args...)
+
+	cmd := exec.CommandContext(ctx, awsBin, cmdArgs...)
+	cmd.Stdin = os.Stdin
+	cmd.Env = BuildEnv(os.Environ())
+
+	var s *spinner
+	if isTerminal(os.Stderr) {
+		s = newSpinner(os.Stderr, "Loading...")
+		s.Start()
+
+		// Wrap stdout/stderr to stop spinner on first output
+		stopWriter := &stopOnWriteWriter{w: os.Stdout, spinner: s}
+		cmd.Stdout = stopWriter
+		cmd.Stderr = &stopOnWriteWriter{w: os.Stderr, spinner: s}
+	} else {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+	}
+
+	err = cmd.Run()
+
+	if err == nil {
+		return nil
+	}
+
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) {
+		return output.NewSilentError(output.NewExitCodeError(exitErr.ExitCode(), err))
+	}
+	return err
+}
+
+func BuildEnv(base []string) []string {
+	env := make([]string, len(base), len(base)+3)
+	copy(env, base)
+
+	setIfAbsent(&env, "AWS_ACCESS_KEY_ID", "test")
+	setIfAbsent(&env, "AWS_SECRET_ACCESS_KEY", "test")
+	setIfAbsent(&env, "AWS_DEFAULT_REGION", "us-east-1")
+
+	return env
+}
+
+func setIfAbsent(env *[]string, key, value string) {
+	prefix := key + "="
+	for _, e := range *env {
+		if strings.HasPrefix(e, prefix) {
+			return
+		}
+	}
+	*env = append(*env, prefix+value)
+}

internal/awscli/exec_test.go

@@ -0,0 +1,53 @@
+package awscli
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildEnvSetsDefaultsWhenAbsent(t *testing.T) {
+	base := []string{"PATH=/usr/bin", "HOME=/home/user"}
+	env := BuildEnv(base)
+
+	assert.Contains(t, env, "AWS_ACCESS_KEY_ID=test")
+	assert.Contains(t, env, "AWS_SECRET_ACCESS_KEY=test")
+	assert.Contains(t, env, "AWS_DEFAULT_REGION=us-east-1")
+	assert.Contains(t, env, "PATH=/usr/bin")
+	assert.Contains(t, env, "HOME=/home/user")
+}
+
+func TestBuildEnvPreservesExistingValues(t *testing.T) {
+	base := []string{
+		"AWS_ACCESS_KEY_ID=custom-key",
+		"AWS_SECRET_ACCESS_KEY=custom-secret",
+		"AWS_DEFAULT_REGION=eu-west-1",
+	}
+	env := BuildEnv(base)
+
+	assert.Contains(t, env, "AWS_ACCESS_KEY_ID=custom-key")
+	assert.Contains(t, env, "AWS_SECRET_ACCESS_KEY=custom-secret")
+	assert.Contains(t, env, "AWS_DEFAULT_REGION=eu-west-1")
+	assert.NotContains(t, env, "AWS_ACCESS_KEY_ID=test")
+	assert.NotContains(t, env, "AWS_SECRET_ACCESS_KEY=test")
+	assert.NotContains(t, env, "AWS_DEFAULT_REGION=us-east-1")
+}
+
+func TestBuildEnvDoesNotMutateInput(t *testing.T) {
+	base := []string{"PATH=/usr/bin"}
+	original := make([]string, len(base))
+	copy(original, base)
+
+	BuildEnv(base)
+
+	assert.Equal(t, original, base)
+}
+
+func TestBuildEnvPartialOverride(t *testing.T) {
+	base := []string{"AWS_ACCESS_KEY_ID=custom-key"}
+	env := BuildEnv(base)
+
+	assert.Contains(t, env, "AWS_ACCESS_KEY_ID=custom-key")
+	assert.Contains(t, env, "AWS_SECRET_ACCESS_KEY=test")
+	assert.Contains(t, env, "AWS_DEFAULT_REGION=us-east-1")
+}

internal/awscli/spinner.go

@@ -0,0 +1,84 @@
+package awscli
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+var dotFrames = []string{"⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"}
+
+// ANSI color codes matching lstk's spinner style (color 69 blue) and secondary (color 241 gray)
+const (
+	spinnerColor   = "\033[38;5;69m"
+	secondaryColor = "\033[38;5;241m"
+	resetColor     = "\033[0m"
+)
+
+type spinner struct {
+	out   io.Writer
+	label string
+	stop  chan struct{}
+	done  chan struct{}
+	mu    sync.Mutex
+}
+
+func newSpinner(out io.Writer, label string) *spinner {
+	return &spinner{
+		out:   out,
+		label: label,
+		stop:  make(chan struct{}),
+		done:  make(chan struct{}),
+	}
+}
+
+func (s *spinner) Start() {
+	go func() {
+		defer close(s.done)
+		tick := time.NewTicker(100 * time.Millisecond)
+		defer tick.Stop()
+
+		i := 0
+		for {
+			s.mu.Lock()
+			_, _ = fmt.Fprintf(s.out, "\r%s%s%s %s%s%s", spinnerColor, dotFrames[i%len(dotFrames)], resetColor, secondaryColor, s.label, resetColor)
+			s.mu.Unlock()
+
+			select {
+			case <-s.stop:
+				s.clearLine()
+				return
+			case <-tick.C:
+				i++
+			}
+		}
+	}()
+}
+
+func (s *spinner) Stop() {
+	close(s.stop)
+	<-s.done
+}
+
+func (s *spinner) clearLine() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	width := len(s.label) + 10
+	_, _ = fmt.Fprintf(s.out, "\r%s\r", strings.Repeat(" ", width))
+}
+
+// isTerminal returns true if the writer is a terminal
+func isTerminal(w io.Writer) bool {
+	f, ok := w.(*os.File)
+	if !ok {
+		return false
+	}
+	stat, err := f.Stat()
+	if err != nil {
+		return false
+	}
+	return (stat.Mode() & os.ModeCharDevice) != 0
+}

internal/output/errors.go

@@ -26,3 +26,32 @@ func IsSilent(err error) bool {
 	var silent *SilentError
 	return errors.As(err, &silent)
 }
+
+// ExitCodeError carries a specific process exit code through the error chain.
+// Used by passthrough commands (e.g. lstk aws) to propagate the subprocess exit code.
+type ExitCodeError struct {
+	Code int
+	Err  error
+}
+
+func (e *ExitCodeError) Error() string {
+	return e.Err.Error()
+}
+
+func (e *ExitCodeError) Unwrap() error {
+	return e.Err
+}
+
+func NewExitCodeError(code int, err error) *ExitCodeError {
+	return &ExitCodeError{Code: code, Err: err}
+}
+
+// ExitCode returns the exit code if err (or any error in its chain) is an ExitCodeError,
+// or 1 as a default.
+func ExitCode(err error) int {
+	var exitErr *ExitCodeError
+	if errors.As(err, &exitErr) {
+		return exitErr.Code
+	}
+	return 1
+}

main.go

@@ -7,13 +7,14 @@ import (
 	"syscall"
 
 	"github.com/localstack/lstk/cmd"
+	"github.com/localstack/lstk/internal/output"
 )
 
 func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer cancel()
 
 	if err := cmd.Execute(ctx); err != nil {
-		os.Exit(1)
+		os.Exit(output.ExitCode(err))
 	}
 }