From 4e431e5d47ada014fcaf45131aa510adfcfd5b75 Mon Sep 17 00:00:00 2001
From: Akshay Singla <akshay.singla@databricks.com>
Date: Fri, 15 May 2026 15:23:03 +0000
Subject: [PATCH 1/2] [CJ-75152][lakebox] CLI: fix CreateSandbox wire format +
 add --name + surface name/timestamps

The auto-create path on `lakebox ssh` fails with:

  INVALID_PARAMETER_VALUE: JSON decode error:
  unknown field `public_key`, expected `sandbox`

`CreateSandboxRequest { Sandbox sandbox = 1 }` has `body: "*"`, so the
wire body must be wrapped as `{"sandbox": {...}}`. The CLI was sending an
unwrapped `{"public_key": "..."}` payload. `Sandbox` has no `public_key`
field anywhere on the create path (proto or handler), so the field was
dead end-to-end. `lakebox create` worked only because its default empty
publicKey was stripped by `omitempty` before the request went out.

While here, plug a few related gaps in the CLI surface:

- Wrap the create body as `{"sandbox": {...}}`; drop dead `public_key`
  field and `--public-key-file` flag.
- Surface `name`, `createTime`, `lastStartTime` on `sandboxEntry` so
  `lakebox status --json` and `lakebox list --json` stop silently
  dropping these fields.
- Add `--name` to `lakebox create` and `lakebox config` (proto + handler
  accept name on create + update; CLI had no way to set it).
- Print `name` in human `lakebox status` output when set.

Jira: CJ-75152

Co-authored-by: Isaac
---
 cmd/lakebox/api.go    | 42 ++++++++++++++++++++++++++----------------
 cmd/lakebox/config.go | 28 ++++++++++++++++++++++------
 cmd/lakebox/create.go | 21 ++++++---------------
 cmd/lakebox/ssh.go    |  6 +-----
 cmd/lakebox/status.go |  3 +++
 5 files changed, 58 insertions(+), 42 deletions(-)

diff --git a/cmd/lakebox/api.go b/cmd/lakebox/api.go
index acaeff47e8b..504bffe0802 100644
--- a/cmd/lakebox/api.go
+++ b/cmd/lakebox/api.go
@@ -23,15 +23,18 @@ type lakeboxAPI struct {
 	w *databricks.WorkspaceClient
 }
 
+// sandboxCreateBody is the inner `Sandbox` message in the create payload.
+// Only `name` is caller-settable today (see `LakeboxApi::create_sandbox` in
+// `lakebox/src/api/service.rs`); all other fields are server-chosen.
+type sandboxCreateBody struct {
+	Name string `json:"name,omitempty"`
+}
+
 // createRequest is the JSON body for POST /api/2.0/lakebox/sandboxes.
-//
-// The proto-defined `CreateSandboxRequest` carries a `Sandbox sandbox = 1`
-// field today (every member is server-chosen), but JSON transcoding accepts
-// the unwrapped form for forward-compatible callers. Keep `public_key` here
-// as a no-op compat shim so older `lakebox create --public-key-file=...`
-// invocations don't error — the manager ignores it on the wire.
+// `CreateSandboxRequest { Sandbox sandbox = 1 }` has `body: "*"`, so the
+// wire body is the full request with a `sandbox` wrapper.
 type createRequest struct {
-	PublicKey string `json:"public_key,omitempty"`
+	Sandbox sandboxCreateBody `json:"sandbox"`
 }
 
 // createResponse is the JSON body returned by POST /api/2.0/lakebox/sandboxes.
@@ -53,11 +56,14 @@ type createResponse struct {
 // form serializes Duration as a string with an `s` suffix (e.g.
 // `"900s"`), so the Go field is `*string` and we parse on read.
 type sandboxEntry struct {
-	SandboxID   string  `json:"sandboxId"`
-	Status      string  `json:"status"`
-	FQDN        string  `json:"fqdn"`
-	IdleTimeout *string `json:"idleTimeout,omitempty"`
-	NoAutostop  *bool   `json:"noAutostop,omitempty"`
+	SandboxID     string  `json:"sandboxId"`
+	Status        string  `json:"status"`
+	FQDN          string  `json:"fqdn"`
+	Name          string  `json:"name,omitempty"`
+	CreateTime    string  `json:"createTime,omitempty"`
+	LastStartTime string  `json:"lastStartTime,omitempty"`
+	IdleTimeout   *string `json:"idleTimeout,omitempty"`
+	NoAutostop    *bool   `json:"noAutostop,omitempty"`
 }
 
 // idleTimeoutSecs parses the proto3-canonical Duration string off
@@ -140,10 +146,11 @@ func newLakeboxAPI(w *databricks.WorkspaceClient) *lakeboxAPI {
 	return &lakeboxAPI{w: w}
 }
 
-// create calls POST /api/2.0/lakebox with an optional public key.
-func (a *lakeboxAPI) create(ctx context.Context, publicKey string) (*createResponse, error) {
-	body := createRequest{PublicKey: publicKey}
-	jsonBody, err := json.Marshal(body)
+// create calls POST /api/2.0/lakebox/sandboxes. An empty `name` is omitted
+// from the wire payload so the server treats it as "unset" rather than
+// "explicit empty string."
+func (a *lakeboxAPI) create(ctx context.Context, name string) (*createResponse, error) {
+	jsonBody, err := json.Marshal(createRequest{Sandbox: sandboxCreateBody{Name: name}})
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal request: %w", err)
 	}
@@ -216,6 +223,7 @@ func (a *lakeboxAPI) get(ctx context.Context, id string) (*sandboxEntry, error)
 // `google.protobuf.Duration`.
 type updateBody struct {
 	SandboxID   string  `json:"sandbox_id"`
+	Name        *string `json:"name,omitempty"`
 	IdleTimeout *string `json:"idle_timeout,omitempty"`
 	NoAutostop  *bool   `json:"no_autostop,omitempty"`
 }
@@ -227,6 +235,7 @@ type updateBody struct {
 func (a *lakeboxAPI) update(
 	ctx context.Context,
 	id string,
+	name *string,
 	idleTimeoutSecs *int64,
 	noAutostop *bool,
 ) (*sandboxEntry, error) {
@@ -237,6 +246,7 @@ func (a *lakeboxAPI) update(
 	}
 	body := updateBody{
 		SandboxID:   id,
+		Name:        name,
 		IdleTimeout: idleTimeout,
 		NoAutostop:  noAutostop,
 	}
diff --git a/cmd/lakebox/config.go b/cmd/lakebox/config.go
index fe3b80ddf29..9aa54eff482 100644
--- a/cmd/lakebox/config.go
+++ b/cmd/lakebox/config.go
@@ -19,13 +19,17 @@ const (
 func newConfigCommand() *cobra.Command {
 	var idleTimeoutFlag string
 	var noAutostopFlag bool
+	var nameFlag string
 
 	cmd := &cobra.Command{
 		Use:   "config <lakebox-id>",
-		Short: "Configure a Lakebox's auto-stop policy",
-		Long: `Configure a Lakebox's auto-stop policy.
+		Short: "Configure a Lakebox's name and auto-stop policy",
+		Long: `Configure a Lakebox's name and auto-stop policy.
 
-Two knobs are independent — pass either or both:
+Three knobs are independent — pass any combination:
+
+  --name <label>              Display label for the lakebox (max 256 bytes).
+                              Pass an empty string to clear.
 
   --idle-timeout <duration>   Per-sandbox idle timeout. The watchdog reaps
                               the sandbox after this much idle time. Pass
@@ -42,6 +46,7 @@ Two knobs are independent — pass either or both:
                               stops on explicit 'lakebox delete'.
 
 Examples:
+  lakebox config happy-panda-1234 --name my-project
   lakebox config happy-panda-1234 --idle-timeout 15m
   lakebox config happy-panda-1234 --idle-timeout 1h30m
   lakebox config happy-panda-1234 --idle-timeout 0           # clear, use default
@@ -75,23 +80,34 @@ Examples:
 				noAutostop = &p
 			}
 
-			if idleSecs == nil && noAutostop == nil {
-				return fmt.Errorf("nothing to update — pass --idle-timeout and/or --no-autostop")
+			var name *string
+			if cmd.Flags().Changed("name") {
+				n := nameFlag
+				name = &n
+			}
+
+			if idleSecs == nil && noAutostop == nil && name == nil {
+				return fmt.Errorf("nothing to update — pass --name, --idle-timeout, and/or --no-autostop")
 			}
 
-			updated, err := api.update(ctx, id, idleSecs, noAutostop)
+			updated, err := api.update(ctx, id, name, idleSecs, noAutostop)
 			if err != nil {
 				return fmt.Errorf("failed to update lakebox %s: %w", id, err)
 			}
 
 			blank(out)
 			field(out, "id", bold(updated.SandboxID))
+			if updated.Name != "" {
+				field(out, "name", updated.Name)
+			}
 			field(out, "autostop", dim(updated.autoStopLabel()))
 			blank(out)
 			return nil
 		},
 	}
 
+	cmd.Flags().StringVar(&nameFlag, "name", "",
+		"Display label for the lakebox (max 256 bytes). Pass --name= to clear.")
 	cmd.Flags().StringVar(&idleTimeoutFlag, "idle-timeout", "",
 		"Idle timeout (e.g. 15m, 1h30m, 90s). Pass 0 to clear and revert to the manager's default.")
 	cmd.Flags().BoolVar(&noAutostopFlag, "no-autostop", false,
diff --git a/cmd/lakebox/create.go b/cmd/lakebox/create.go
index 096df26ce6b..872ba673ddf 100644
--- a/cmd/lakebox/create.go
+++ b/cmd/lakebox/create.go
@@ -2,14 +2,13 @@ package lakebox
 
 import (
 	"fmt"
-	"os"
 
 	"github.com/databricks/cli/libs/cmdctx"
 	"github.com/spf13/cobra"
 )
 
 func newCreateCommand() *cobra.Command {
-	var publicKeyFile string
+	var name string
 
 	cmd := &cobra.Command{
 		Use:   "create",
@@ -19,8 +18,9 @@ func newCreateCommand() *cobra.Command {
 Creates a new personal development environment backed by a microVM.
 Blocks until the lakebox is running and prints the lakebox ID.
 
-Example:
-  lakebox create`,
+Examples:
+  lakebox create
+  lakebox create --name my-project`,
 		PreRunE: mustWorkspaceClient,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -28,18 +28,9 @@ Example:
 			api := newLakeboxAPI(w)
 			stderr := cmd.ErrOrStderr()
 
-			var publicKey string
-			if publicKeyFile != "" {
-				data, err := os.ReadFile(publicKeyFile)
-				if err != nil {
-					return fmt.Errorf("failed to read public key file %s: %w", publicKeyFile, err)
-				}
-				publicKey = string(data)
-			}
-
 			s := spin(stderr, "Provisioning your lakebox…")
 
-			result, err := api.create(ctx, publicKey)
+			result, err := api.create(ctx, name)
 			if err != nil {
 				s.fail("Failed to create lakebox")
 				return fmt.Errorf("failed to create lakebox: %w", err)
@@ -73,7 +64,7 @@ Example:
 		},
 	}
 
-	cmd.Flags().StringVar(&publicKeyFile, "public-key-file", "", "Path to SSH public key file to install in the lakebox")
+	cmd.Flags().StringVar(&name, "name", "", "Display label for the lakebox (max 256 bytes)")
 
 	return cmd
 }
diff --git a/cmd/lakebox/ssh.go b/cmd/lakebox/ssh.go
index 2a7db87a1b7..3596a6911e9 100644
--- a/cmd/lakebox/ssh.go
+++ b/cmd/lakebox/ssh.go
@@ -90,13 +90,9 @@ Examples:
 					lakeboxID = def
 				} else {
 					api := newLakeboxAPI(w)
-					pubKeyData, err := os.ReadFile(keyPath + ".pub")
-					if err != nil {
-						return fmt.Errorf("failed to read public key %s.pub: %w", keyPath, err)
-					}
 
 					s := spin(stderr, "Provisioning your lakebox…")
-					result, err := api.create(ctx, string(pubKeyData))
+					result, err := api.create(ctx, "")
 					if err != nil {
 						s.fail("Failed to create lakebox")
 						return fmt.Errorf("failed to create lakebox: %w", err)
diff --git a/cmd/lakebox/status.go b/cmd/lakebox/status.go
index f5df1ee4a40..fa9d39b6f4b 100644
--- a/cmd/lakebox/status.go
+++ b/cmd/lakebox/status.go
@@ -42,6 +42,9 @@ Example:
 			out := cmd.OutOrStdout()
 			blank(out)
 			field(out, "id", bold(entry.SandboxID))
+			if entry.Name != "" {
+				field(out, "name", entry.Name)
+			}
 			field(out, "status", status(entry.Status))
 			if entry.FQDN != "" {
 				field(out, "fqdn", dim(entry.FQDN))

From 5add6a8d63a4d9102c4258a2ca69a9fbcd6d9566 Mon Sep 17 00:00:00 2001
From: Akshay Singla <akshay.singla@databricks.com>
Date: Fri, 15 May 2026 15:32:24 +0000
Subject: [PATCH 2/2] [CJ-75153][lakebox] CLI: follow pagination on
 ListSandboxes

Depends on universe#1941694, which makes `handlers::sandbox::list` pass
through pagination instead of collapsing to one response (default
`page_size=100`, clamped to `1000`, real `next_page_token` from ESM).

Today `(*lakeboxAPI).list` does a single GET and returns
`result.Sandboxes`. That works only because the manager pre-aggregates;
once the server PR lands, callers that ignore `next_page_token` silently
cap at 100 sandboxes per user.

Loop on the token, asking for `page_size=100&page_token=...` each round.
`doRequest` learned to split a leading `?...` off `path` into `RawQuery`
so it merges with the host's `?o=<wsid>` workspace selector instead of
getting URL-encoded into the path.

Jira: CJ-75153

Co-authored-by: Isaac
---
 cmd/lakebox/api.go | 54 +++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/cmd/lakebox/api.go b/cmd/lakebox/api.go
index 504bffe0802..1736aa96fe2 100644
--- a/cmd/lakebox/api.go
+++ b/cmd/lakebox/api.go
@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
@@ -128,10 +129,17 @@ func formatDurationSecs(secs int64) string {
 }
 
 // listResponse is the JSON body returned by GET /api/2.0/lakebox/sandboxes.
+// `nextPageToken` is empty on the final page (or when the result fits in one).
 type listResponse struct {
-	Sandboxes []sandboxEntry `json:"sandboxes"`
+	Sandboxes     []sandboxEntry `json:"sandboxes"`
+	NextPageToken string         `json:"nextPageToken,omitempty"`
 }
 
+// listPageSize matches the manager-side default in `handlers::sandbox::list`.
+// Typical user fleets are well under this, so one round-trip covers them; the
+// pagination loop in `list` handles the rare larger fleet.
+const listPageSize = 100
+
 // apiError is the error body returned by the lakebox API.
 type apiError struct {
 	ErrorCode string `json:"error_code"`
@@ -172,9 +180,34 @@ func (a *lakeboxAPI) create(ctx context.Context, name string) (*createResponse,
 	return &result, nil
 }
 
-// list calls GET /api/2.0/lakebox/sandboxes.
+// list calls GET /api/2.0/lakebox/sandboxes, following pagination until the
+// server stops sending `next_page_token`. Returns the full set in one slice.
 func (a *lakeboxAPI) list(ctx context.Context) ([]sandboxEntry, error) {
-	resp, err := a.doRequest(ctx, "GET", lakeboxAPIPath, nil)
+	var all []sandboxEntry
+	pageToken := ""
+	for {
+		page, err := a.listPage(ctx, pageToken)
+		if err != nil {
+			return nil, err
+		}
+		all = append(all, page.Sandboxes...)
+		if page.NextPageToken == "" {
+			return all, nil
+		}
+		pageToken = page.NextPageToken
+	}
+}
+
+// listPage fetches a single page of sandboxes. An empty `pageToken` requests
+// the first page; the server enforces ordering across pages.
+func (a *lakeboxAPI) listPage(ctx context.Context, pageToken string) (*listResponse, error) {
+	q := url.Values{}
+	q.Set("page_size", strconv.Itoa(listPageSize))
+	if pageToken != "" {
+		q.Set("page_token", pageToken)
+	}
+
+	resp, err := a.doRequest(ctx, "GET", lakeboxAPIPath+"?"+q.Encode(), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -188,7 +221,7 @@ func (a *lakeboxAPI) list(ctx context.Context) ([]sandboxEntry, error) {
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
 		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}
-	return result.Sandboxes, nil
+	return &result, nil
 }
 
 // get calls GET /api/2.0/lakebox/sandboxes/{id}.
@@ -303,7 +336,18 @@ func (a *lakeboxAPI) doRequest(ctx context.Context, method, path string, body io
 			wsid = v
 		}
 	}
-	parsed.Path = strings.TrimRight(parsed.Path, "/") + path
+	// Callers may pass a leading query string (`...?page_token=...`) in `path`.
+	// Split it off so it lands in `RawQuery` rather than being URL-encoded into
+	// the path, and merge with the host's existing query (e.g. `?o=<wsid>`).
+	pathOnly, query, _ := strings.Cut(path, "?")
+	parsed.Path = strings.TrimRight(parsed.Path, "/") + pathOnly
+	if query != "" {
+		if parsed.RawQuery == "" {
+			parsed.RawQuery = query
+		} else {
+			parsed.RawQuery = parsed.RawQuery + "&" + query
+		}
+	}
 
 	req, err := http.NewRequestWithContext(ctx, method, parsed.String(), body)
 	if err != nil {