Show container start guidance on more commands

cmd/logs.go

@@ -31,6 +31,9 @@ func newLogsCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
 			}
 			rt, err := runtime.NewDockerRuntime(cfg.DockerHost)
 			if err != nil {
+				return dockerNotAvailableError(err)
+			}
+			if err := checkRuntimeHealth(cmd.Context(), rt); err != nil {
 				return err
 			}
 			appConfig, err := config.Get()

cmd/root.go

@@ -32,7 +32,7 @@ func NewRootCmd(cfg *env.Env, tel *telemetry.Client, logger log.Logger) *cobra.C
 		RunE: func(cmd *cobra.Command, args []string) error {
 			rt, err := runtime.NewDockerRuntime(cfg.DockerHost)
 			if err != nil {
-				return err
+				return dockerNotAvailableError(err)
 			}
 			return runStart(cmd.Context(), cmd.Flags(), rt, cfg, tel, logger)
 		},
@@ -185,6 +185,31 @@ func isInteractiveMode(cfg *env.Env) bool {
 	return !cfg.NonInteractive && ui.IsInteractive()
 }
 
+// dockerNotAvailableError emits a styled Docker-not-available error and
+// returns a SilentError to suppress duplicate error printing.
+func dockerNotAvailableError(err error) error {
+	output.EmitError(output.NewPlainSink(os.Stdout), output.ErrorEvent{
+		Title:   "Docker is not available",
+		Summary: err.Error(),
+		Actions: []output.ErrorAction{
+			{Label: "See help:", Value: "lstk -h"},
+			{Label: "Install Docker:", Value: "https://docs.docker.com/get-docker/"},
+		},
+	})
+	return output.NewSilentError(err)
+}
+
+// checkRuntimeHealth checks if the runtime is healthy and emits an error
+// through the sink if not in interactive mode. Returns a SilentError to
+// suppress duplicate error printing.
+func checkRuntimeHealth(ctx context.Context, rt runtime.Runtime) error {
+	if err := rt.IsHealthy(ctx); err != nil {
+		rt.EmitUnhealthyError(output.NewPlainSink(os.Stdout), err)
+		return output.NewSilentError(err)
+	}
+	return nil
+}
+
 const maxLogSize = 1 << 20 // 1 MB
 
 func newLogger() (log.Logger, func(), error) {

cmd/start.go

@@ -17,7 +17,7 @@ func newStartCmd(cfg *env.Env, tel *telemetry.Client, logger log.Logger) *cobra.
 		RunE: func(cmd *cobra.Command, args []string) error {
 			rt, err := runtime.NewDockerRuntime(cfg.DockerHost)
 			if err != nil {
-				return err
+				return dockerNotAvailableError(err)
 			}
 			return runStart(cmd.Context(), cmd.Flags(), rt, cfg, tel, logger)
 		},

cmd/status.go

@@ -25,9 +25,11 @@ func newStatusCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
 		RunE: commandWithTelemetry("status", tel, func(cmd *cobra.Command, args []string) error {
 			rt, err := runtime.NewDockerRuntime(cfg.DockerHost)
 			if err != nil {
+				return dockerNotAvailableError(err)
+			}
+			if err := checkRuntimeHealth(cmd.Context(), rt); err != nil {
 				return err
 			}
-
 			appCfg, err := config.Get()
 			if err != nil {
 				return fmt.Errorf("failed to get config: %w", err)

cmd/stop.go

@@ -26,6 +26,9 @@ func newStopCmd(cfg *env.Env, tel *telemetry.Client) *cobra.Command {
 			startTime := time.Now()
 			rt, err := runtime.NewDockerRuntime(cfg.DockerHost)
 			if err != nil {
+				return dockerNotAvailableError(err)
+			}
+			if err := checkRuntimeHealth(cmd.Context(), rt); err != nil {
 				return err
 			}
 			appConfig, err := config.Get()

internal/output/plain_format.go

@@ -4,6 +4,16 @@ import (
 	"fmt"
 	"strings"
 	"time"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+var (
+	errorTitleStyle     = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#C33820"))
+	errorSecondaryStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))
+	errorActionStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("69"))
+	errorValueStyle     = lipgloss.NewStyle().Bold(true)
+	errorMutedStyle     = lipgloss.NewStyle().Foreground(lipgloss.Color("245"))
 )
 
 // FormatEventLine converts an output event into a single display line.
@@ -130,21 +140,27 @@ func formatMessageEvent(e MessageEvent) string {
 
 func formatErrorEvent(e ErrorEvent) string {
 	var sb strings.Builder
-	sb.WriteString("Error: ")
-	sb.WriteString(e.Title)
+	sb.WriteString(errorTitleStyle.Render("✗ " + e.Title))
 	if e.Summary != "" {
-		sb.WriteString("\n  ")
+		sb.WriteString("\n")
+		sb.WriteString(errorSecondaryStyle.Render("> "))
 		sb.WriteString(e.Summary)
 	}
 	if e.Detail != "" {
 		sb.WriteString("\n  ")
-		sb.WriteString(e.Detail)
+		sb.WriteString(errorMutedStyle.Render(e.Detail))
 	}
-	for _, action := range e.Actions {
-		sb.WriteString("\n  " + ErrorActionPrefix)
-		sb.WriteString(action.Label)
-		sb.WriteString(" ")
-		sb.WriteString(action.Value)
+	if len(e.Actions) > 0 {
+		sb.WriteString("\n")
+		for i, action := range e.Actions {
+			sb.WriteString("\n")
+			if i > 0 {
+				sb.WriteString(errorMutedStyle.Render(ErrorActionPrefix + action.Label + " " + action.Value))
+			} else {
+				sb.WriteString(errorActionStyle.Render(ErrorActionPrefix+action.Label+" "))
+				sb.WriteString(errorValueStyle.Render(action.Value))
+			}
+		}
 	}
 	return sb.String()
 }

internal/output/plain_format_test.go

@@ -84,19 +84,19 @@ func TestFormatEventLine(t *testing.T) {
 		{
 			name:   "error event title only",
 			event:  ErrorEvent{Title: "Connection failed"},
-			want:   "Error: Connection failed",
+			want:   "✗ Connection failed",
 			wantOK: true,
 		},
 		{
 			name:   "error event with summary",
 			event:  ErrorEvent{Title: "Auth failed", Summary: "Invalid token"},
-			want:   "Error: Auth failed\n  Invalid token",
+			want:   "✗ Auth failed\n> Invalid token",
 			wantOK: true,
 		},
 		{
 			name:   "error event with detail",
 			event:  ErrorEvent{Title: "Auth failed", Summary: "Invalid token", Detail: "Token expired at 2024-01-01"},
-			want:   "Error: Auth failed\n  Invalid token\n  Token expired at 2024-01-01",
+			want:   "✗ Auth failed\n> Invalid token\n  Token expired at 2024-01-01",
 			wantOK: true,
 		},
 		{
@@ -108,7 +108,7 @@ func TestFormatEventLine(t *testing.T) {
 					{Label: "Start Docker:", Value: "open -a Docker"},
 				},
 			},
-			want:   "Error: Docker not running\n  Cannot connect to Docker daemon\n  ==> Start Docker: open -a Docker",
+			want:   "✗ Docker not running\n> Cannot connect to Docker daemon\n\n==> Start Docker: open -a Docker",
 			wantOK: true,
 		},
 		{

internal/output/plain_sink_test.go

@@ -146,7 +146,7 @@ func TestPlainSink_EmitsErrorEvent(t *testing.T) {
 		Actions: []ErrorAction{{Label: "Start Docker:", Value: "open -a Docker"}},
 	})
 
-	expected := "Error: Connection failed\n  Cannot connect to Docker\n  ==> Start Docker: open -a Docker\n"
+	expected := "✗ Connection failed\n> Cannot connect to Docker\n\n==> Start Docker: open -a Docker\n"
 	assert.Equal(t, expected, out.String())
 }
 

test/integration/docker_unhealthy_test.go

@@ -0,0 +1,64 @@
+package integration_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/localstack/lstk/test/integration/env"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// unhealthyDockerEnv returns an environment with DOCKER_HOST pointing to a
+// non-existent Unix socket so that the Docker health check fails.
+func unhealthyDockerEnv() env.Environ {
+	return env.With(env.Key("DOCKER_HOST"), "unix:///var/run/docker-does-not-exist.sock")
+}
+
+func TestStartShowsDockerErrorWhenUnhealthy(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Unix socket test")
+	}
+
+	stdout, _, err := runLstk(t, testContext(t), "", unhealthyDockerEnv(), "start")
+	require.Error(t, err)
+	requireExitCode(t, 1, err)
+	assert.Contains(t, stdout, "Docker is not available")
+	assert.Contains(t, stdout, "Install Docker:")
+}
+
+func TestStopShowsDockerErrorWhenUnhealthy(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Unix socket test")
+	}
+
+	stdout, _, err := runLstk(t, testContext(t), "", unhealthyDockerEnv(), "stop")
+	require.Error(t, err)
+	requireExitCode(t, 1, err)
+	assert.Contains(t, stdout, "Docker is not available")
+	assert.Contains(t, stdout, "Install Docker:")
+}
+
+func TestStatusShowsDockerErrorWhenUnhealthy(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Unix socket test")
+	}
+
+	stdout, _, err := runLstk(t, testContext(t), "", unhealthyDockerEnv(), "status")
+	require.Error(t, err)
+	requireExitCode(t, 1, err)
+	assert.Contains(t, stdout, "Docker is not available")
+	assert.Contains(t, stdout, "Install Docker:")
+}
+
+func TestLogsShowsDockerErrorWhenUnhealthy(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Unix socket test")
+	}
+
+	stdout, _, err := runLstk(t, testContext(t), "", unhealthyDockerEnv(), "logs")
+	require.Error(t, err)
+	requireExitCode(t, 1, err)
+	assert.Contains(t, stdout, "Docker is not available")
+	assert.Contains(t, stdout, "Install Docker:")
+}