Address review: guard uv install prompt, reject mixed serverless versions

Two correctness findings from the review of the follow-up changes:

- confirmUvInstall could panic: EnsureAvailable is a library entry point
  reachable with a context that has no cmdio (e.g. a Pipeline built with
  context.Background()), where cmdio.IsPromptSupported panics. Guard with
  cmdio.HasIO and treat a missing cmdio as non-interactive (decline).

- GetJobSparkVersion used only Environments[0] for serverless jobs. A job
  whose environments pin differing environment_version values (or a
  pinned-vs-unpinned mix) has no single correct target, so refuse and ask for
  --serverless, mirroring the existing job-cluster divergence check.

Adds a test asserting confirmUvInstall declines (no panic) with no cmdio.

Co-authored-by: Isaac

Author: rugpanov

cmd/localenv/compute.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 
 	databricks "github.com/databricks/databricks-sdk-go"
+	"github.com/databricks/databricks-sdk-go/service/jobs"
 )
 
 // sdkCompute adapts the Databricks SDK to the localenv.ComputeClient interface.
@@ -60,10 +61,16 @@ func (c sdkCompute) GetJobSparkVersion(ctx context.Context, jobID string) (spark
 		// The serverless environment version (e.g. "4") is recorded on the job's
 		// environment spec, unlike the bundle path where it is unavailable. Return
 		// it so ResolveTarget pins the matching serverless-vN instead of defaulting
-		// to v4. Spec/version may be empty on older jobs; that falls back to v4.
-		version := ""
-		if spec := job.Settings.Environments[0].Spec; spec != nil {
-			version = spec.EnvironmentVersion
+		// to v4. An empty version (older jobs) falls back to v4 in ResolveTarget.
+		version := environmentVersion(job.Settings.Environments[0])
+		// Tasks can reference any environment_key, so if the job's environments do
+		// not all share one version there is no single correct local environment
+		// (mirrors the job-cluster check below). Refuse rather than guess from the
+		// first. A pinned-vs-unpinned mix is also ambiguous, so compare raw values.
+		for _, e := range job.Settings.Environments[1:] {
+			if environmentVersion(e) != version {
+				return "", false, "", fmt.Errorf("job %d has serverless environments with differing environment_version; pass --serverless explicitly to disambiguate", id)
+			}
 		}
 		return "", true, version, nil
 	}
@@ -86,3 +93,12 @@ func (c sdkCompute) GetJobSparkVersion(ctx context.Context, jobID string) (spark
 
 	return "", false, "", fmt.Errorf("could not determine compute for job %d from its environments or job clusters (task-level compute is not supported); pass --cluster or --serverless explicitly", id)
 }
+
+// environmentVersion returns the serverless environment_version recorded on a
+// job environment, or "" when the spec or version is absent.
+func environmentVersion(e jobs.JobEnvironment) string {
+	if e.Spec == nil {
+		return ""
+	}
+	return e.Spec.EnvironmentVersion
+}

libs/localenv/uv.go

@@ -317,7 +317,10 @@ func confirmUvInstall(ctx context.Context) bool {
 	if optIn, ok := env.GetBool(ctx, EnvAutoInstallUv); ok && optIn {
 		return true
 	}
-	if !cmdio.IsPromptSupported(ctx) {
+	// EnsureAvailable is a library entry point reachable with a context that has
+	// no cmdio (e.g. Pipeline built with context.Background()); IsPromptSupported
+	// would panic there. Treat a missing cmdio as non-interactive and decline.
+	if !cmdio.HasIO(ctx) || !cmdio.IsPromptSupported(ctx) {
 		return false
 	}
 	ok, err := cmdio.AskYesOrNo(ctx, "uv is not installed. Download and run the official uv installer (https://astral.sh/uv/install.sh)?")

libs/localenv/uv_test.go

@@ -236,6 +236,14 @@ func TestConfirmUvInstall(t *testing.T) {
 		assert.False(t, confirmUvInstall(ctx))
 	})
 
+	t.Run("missing_cmdio_declines_without_panic", func(t *testing.T) {
+		// A context with no cmdio (library entry point) must not panic in
+		// IsPromptSupported; it declines like any other non-interactive run.
+		assert.NotPanics(t, func() {
+			assert.False(t, confirmUvInstall(t.Context()))
+		})
+	})
+
 	t.Run("falsey_opt_in_does_not_consent_when_non_interactive", func(t *testing.T) {
 		ctx, _ := cmdio.SetupTest(t.Context(), cmdio.TestOptions{})
 		ctx = env.Set(ctx, EnvAutoInstallUv, "0")