Fix int64 precision loss in JSON loader (#5494)

## Why

Found during a full-repo review of the CLI. The JSON loader decodes
every number as float64, which has a 53-bit mantissa. Integer values
above 2^53 silently lose precision, and job, run, and pipeline IDs
routinely exceed that. For example, `--json '{"job_id":
123456789012345678}'` unmarshals to `123456789012345680` and targets the
wrong resource. The corruption happens at load time, so the precision
guard in `convert.Normalize` never sees the original value.

## Changes

Before, all JSON numbers became float64; now integer literals are loaded
as int64 and keep their exact value. The loader in
`libs/dyn/jsonloader/json.go` enables `decoder.UseNumber()` and handles
the `json.Number` token: integer literals parse as int64, while literals
with a fraction or exponent (`2.0`, `1e3`) stay float64. Integer
literals that overflow int64 also fall back to float64, matching the
previous decoder behavior.

This affects everything loading through `jsonloader`: the `--json` flag
on generated commands and bundle variable files. Both paths normalize
values against the target type afterwards, and `convert.Normalize`
already converts int to float (and back) with precision checks, so
well-formed inputs are unaffected apart from no longer being corrupted.

## Test plan

- [x] New unit tests in `libs/dyn/jsonloader`: large positive and
negative int64 values, max int64, floats with fraction or exponent,
int64 overflow fallback, out-of-range error, and a mixed object
converted via `convert.ToTyped` asserting the exact job ID
- [x] `go test ./libs/dyn/...`
- [x] `go test ./libs/flags ./bundle/config/mutator` (the two `LoadJSON`
consumers)
- [x] Acceptance tests covering JSON inputs pass unchanged:
`bundle/variables/file-defaults`, `cmd/workspace/apps`,
`cmd/workspace/database/update-database-instance`
- [x] `./task fmt-q`, `./task lint-q`, `./task checks`

This pull request and its description were written by Isaac.

Author: simonfaltum

libs/dyn/jsonloader/json.go

@@ -17,6 +17,9 @@ func LoadJSON(data []byte, source string) (dyn.Value, error) {
 	reader := bytes.NewReader(data)
 	decoder := json.NewDecoder(reader)
 
+	// Use json.Number to avoid losing precision on int64 values above 2^53 (e.g. job and run IDs).
+	decoder.UseNumber()
+
 	// Start decoding from the top-level value
 	value, err := decodeValue(decoder, &offset)
 	if err != nil {
@@ -107,6 +110,16 @@ func decodeValue(decoder *json.Decoder, o *Offset) (dyn.Value, error) {
 			}
 			return dyn.NewValue(arr, []dyn.Location{location}), nil
 		}
+	case json.Number:
+		// Integers that overflow int64 fall back to float64, matching the decoder's behavior without UseNumber.
+		if i64, err := tok.Int64(); err == nil {
+			return dyn.NewValue(i64, []dyn.Location{location}), nil
+		}
+		f64, err := tok.Float64()
+		if err != nil {
+			return invalidValueWithLocation(decoder, o), fmt.Errorf("invalid number %q: %w", tok.String(), err)
+		}
+		return dyn.NewValue(f64, []dyn.Location{location}), nil
 	default:
 		return dyn.NewValue(tok, []dyn.Location{location}), nil
 	}

libs/dyn/jsonloader/json_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/databricks/cli/libs/dyn/convert"
 	"github.com/databricks/databricks-sdk-go/service/jobs"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const jsonData = `
@@ -111,3 +112,50 @@ func TestJsonValidInline(t *testing.T) {
 	_, err := LoadJSON([]byte(validInline), "path/to/file.json")
 	assert.NoError(t, err)
 }
+
+func TestJsonLoaderNumbers(t *testing.T) {
+	for _, tc := range []struct {
+		input    string
+		expected any
+	}{
+		{`123`, int64(123)},
+		{`-1`, int64(-1)},
+		{`123456789012345678`, int64(123456789012345678)},
+		{`-123456789012345678`, int64(-123456789012345678)},
+		{`9223372036854775807`, int64(9223372036854775807)},
+		{`2.0`, 2.0},
+		{`2.5`, 2.5},
+		{`1e3`, 1000.0},
+		{`18446744073709551615`, 1.8446744073709552e+19},
+	} {
+		v, err := LoadJSON([]byte(tc.input), "(inline)")
+		assert.NoError(t, err, tc.input)
+		assert.Equal(t, tc.expected, v.AsAny(), tc.input)
+	}
+}
+
+func TestJsonLoaderNumberOutOfRange(t *testing.T) {
+	_, err := LoadJSON([]byte(`1e400`), "(inline)")
+	assert.ErrorContains(t, err, "value out of range")
+}
+
+const mixedNumbersData = `
+{
+    "job_id": 123456789012345678,
+    "new_settings": {
+        "name": "xxx",
+        "timeout_seconds": 100
+    }
+}
+`
+
+func TestJsonLoaderMixedNumbersToTyped(t *testing.T) {
+	v, err := LoadJSON([]byte(mixedNumbersData), "(inline)")
+	require.NoError(t, err)
+
+	var r jobs.ResetJob
+	err = convert.ToTyped(&r, v)
+	require.NoError(t, err)
+	assert.Equal(t, int64(123456789012345678), r.JobId)
+	assert.Equal(t, 100, r.NewSettings.TimeoutSeconds)
+}