fix: propagate context cancellation during image pull

On Ctrl+C mid-pull, the cancelled context made the rt.ImageExists
local-image probe fail, so the start surfaced a misleading "Failed to
pull" error and emitted a spurious start-error telemetry event. Guard the
pull-failure path with ctx.Err() so a user cancel propagates cleanly,
mirroring the existing license pre-flight handling.

Also documents the known limitation that an HTTP error response from the
license server (5xx, or 407 from a proxy) is still treated as a definitive
verdict rather than degrading.

Refs DEVX-703

Author: gtsiolis

internal/container/start.go

@@ -324,6 +324,12 @@ func pullImages(ctx context.Context, rt runtime.Runtime, sink output.Sink, tel *
 		}()
 		if err := rt.PullImage(ctx, c.Image, progress); err != nil {
 			sink.Emit(output.SpinnerStop())
+			// A cancelled caller context (e.g. Ctrl+C) is not an offline condition —
+			// propagate it instead of probing for a local image or reporting a pull
+			// failure, which would also emit a spurious start-error telemetry event.
+			if ctx.Err() != nil {
+				return nil, ctx.Err()
+			}
 			// The registry may be unreachable (offline, proxy, or TLS interception in
 			// enterprise networks). If the image is already available locally, fall back
 			// to it instead of failing — the image carries its own license.
@@ -621,6 +627,10 @@ func validateLicense(ctx context.Context, sink output.Sink, opts StartOptions, c
 			sink.Emit(output.MessageEvent{Severity: output.SeverityWarning, Text: "Could not reach the license server; continuing with the image's bundled license"})
 			return nil
 		}
+		// Known limitation: any *api.LicenseError — i.e. any non-200 HTTP response,
+		// including a 5xx or a 407 from a corporate proxy — is treated as a definitive
+		// verdict and stays fatal here; only connection-level failures (handled above)
+		// degrade. Gating this on licErr.Status is tracked as follow-up.
 		if licErr.Detail != "" {
 			opts.Logger.Error("license server response (HTTP %d): %s", licErr.Status, licErr.Detail)
 		}

internal/container/start_test.go

@@ -443,6 +443,43 @@ func TestPullImages_FailsWhenPullFailsAndImageMissing(t *testing.T) {
 	assert.Contains(t, out.String(), "Failed to pull localstack/localstack-pro:latest")
 }
 
+func TestPullImages_PropagatesContextCancellation(t *testing.T) {
+	// A cancelled caller context (Ctrl+C) during a pull must surface as
+	// cancellation — not be reported as a pull failure nor probed as a local-image
+	// fallback (which would also emit a spurious start-error telemetry event).
+	ctrl := gomock.NewController(t)
+	mockRT := runtime.NewMockRuntime(ctrl)
+
+	c := runtime.ContainerConfig{
+		Image:        "localstack/localstack-pro:latest",
+		Name:         "localstack-aws",
+		EmulatorType: config.EmulatorAWS,
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	mockRT.EXPECT().Remove(gomock.Any(), c.Name).Return(nil)
+	mockRT.EXPECT().PullImage(gomock.Any(), c.Image, gomock.Any()).DoAndReturn(
+		func(_ context.Context, _ string, progress chan<- runtime.PullProgress) error {
+			cancel() // the user interrupts mid-pull
+			close(progress)
+			return context.Canceled
+		})
+	// ImageExists must NOT be called once the context is cancelled; gomock fails
+	// the test if it is (no EXPECT registered).
+
+	var out bytes.Buffer
+	sink := output.NewPlainSink(&out)
+	tel := telemetry.New("", true)
+
+	_, err := pullImages(ctx, mockRT, sink, tel, []runtime.ContainerConfig{c})
+
+	require.ErrorIs(t, err, context.Canceled)
+	assert.False(t, output.IsSilent(err), "a user cancel is not a silent start error")
+	assert.NotContains(t, out.String(), "Failed to pull", "a cancel must not be reported as a pull failure")
+	assert.NotContains(t, out.String(), "using the local image")
+}
+
 func TestValidateLicense_ContinuesWhenServerUnreachable(t *testing.T) {
 	// A closed port yields a transport-level failure (not an *api.LicenseError),
 	// which models an offline/proxy environment that cannot reach the license server.