[SAN-839] Select sandbox groups when creating and listing sandboxes (#772)

Add --sandbox-group to sandbox create and list. Creation without a group ID keeps using the workspace default. Sandbox listing without a group filter stays workspace-wide, and group listing continues returning all groups. Refresh the generated client for the group endpoints and sandboxGroupId fields.

Update the shared API fake so command tests cover creation in a selected group and filtering out sandboxes from other groups.

https://linear.app/render-com/issue/SAN-839/support-multiple-sandbox-groups

Generated client changes come from public-api-schema/generate-cli.sh against the schema in https://github.com/renderinc/api/pull/37841. Land the API before this CLI change.

GitOrigin-RevId: 7b4e2958b6888a374f65a0c70371d8e899e45d26

Author: Talor-A

cmd/sandboxcreate.go

@@ -18,6 +18,7 @@ import (
 )
 
 type SandboxCreateInput struct {
+	SandboxGroupID   string   `cli:"sandbox-group"`
 	Plan             string   `cli:"plan"`
 	Region           string   `cli:"region"`
 	Timeout          int      `cli:"timeout"`
@@ -159,7 +160,8 @@ func newSandboxCreateCmd(deps *dependencies.Dependencies) *cobra.Command {
 
 Examples:
   render ea sandboxes create
-  render ea sandboxes create --plan=2c-4g --region=oregon
+  render ea sandboxes create --plan=2c-4g
+  render ea sandboxes create --sandbox-group=sbg-cph1rs3idesc73a2b2mg
   render ea sandboxes create --timeout=3600
   render ea sandboxes create --idle-timeout=1800
   render ea sandboxes create --idle-timeout=0
@@ -176,7 +178,9 @@ Examples:
 	}
 
 	cmd.Flags().String("plan", "", "Compute plan: "+strings.Join(sandboxPlanNames(), ", "))
-	cmd.Flags().String("region", "", "Region to run the sandbox in")
+	cmd.Flags().String("region", "", "Accepted for compatibility; placement uses the sandbox group region")
+	cmd.Flags().String("sandbox-group", "", "Sandbox group ID. Omit to use the workspace default group")
+	setFlagPlaceholder(cmd.Flags(), "sandbox-group", "SANDBOX_GROUP_ID")
 	cmd.Flags().Int("timeout", 0, "Maximum sandbox lifetime in seconds, up to 2592000 (30 days), or 86400 (24 hours) on Hobby workspaces. 0 uses the default of 86400 (24 hours)")
 	cmd.Flags().Int("idle-timeout", 900, "Seconds of inactivity before suspension. 0 disables automatic idle suspension")
 	cmd.Flags().String("network-policy", "", "Outbound network policy: "+strings.Join(sandboxNetworkPolicyNames(), ", "))
@@ -236,17 +240,18 @@ Examples:
 		var waitErr error
 		_, err = command.NonInteractive(cmd, func() (*sandboxclient.Sandbox, error) {
 			sb, err := deps.SandboxService().Create(cmd.Context(), sandbox.CreateInput{
-				Plan:          input.Plan,
-				Region:        input.Region,
-				Timeout:       input.Timeout,
-				IdleTimeout:   idleTimeout,
-				NetworkPolicy: input.resolvedNetworkPolicy(),
-				EgressRules:   input.egressRules(),
-				Env:           env,
-				SnapshotID:    snapshotID,
-				SnapshotName:  snapshotName,
-				BuildID:       buildID,
-				BuildName:     buildName,
+				SandboxGroupID: input.SandboxGroupID,
+				Plan:           input.Plan,
+				Region:         input.Region,
+				Timeout:        input.Timeout,
+				IdleTimeout:    idleTimeout,
+				NetworkPolicy:  input.resolvedNetworkPolicy(),
+				EgressRules:    input.egressRules(),
+				Env:            env,
+				SnapshotID:     snapshotID,
+				SnapshotName:   snapshotName,
+				BuildID:        buildID,
+				BuildName:      buildName,
 			}, onEvent)
 			if err != nil || !input.Wait {
 				return sb, err

cmd/sandboxcreate_test.go

@@ -709,3 +709,28 @@ func TestSandboxCreate_WaitFailurePrintsSandbox(t *testing.T) {
 		})
 	}
 }
+
+func TestSandboxCreate_GroupSelection(t *testing.T) {
+	for _, groupID := range []string{"", "sbg-cph1rs3idesc73a2b2mg"} {
+		t.Run(groupID, func(t *testing.T) {
+			server := newSandboxCreateServer(t)
+			if groupID != "" {
+				server.SandboxGroups.Add(renderapi.NewSandboxGroup(sandboxclient.SandboxGroup{Id: groupID, OwnerId: sandboxCreateActiveWorkspaceID}))
+			}
+			args := []string{"ea", "sandboxes", "create", "--output", "json"}
+			if groupID != "" {
+				args = append(args, "--sandbox-group", groupID)
+			}
+			_, err := executeSandboxCommand(t, server, args...)
+			require.NoError(t, err)
+			req, ok := server.LastRequest("POST", "/sandboxes")
+			require.True(t, ok)
+			body := testrequire.ParseJSONMap(t, string(req.Body))
+			if groupID == "" {
+				assert.NotContains(t, body, "sandboxGroupId")
+			} else {
+				assert.Equal(t, groupID, body["sandboxGroupId"])
+			}
+		})
+	}
+}

cmd/sandboxgroupslist.go

@@ -15,7 +15,7 @@ func newSandboxGroupsListCmd(deps *dependencies.Dependencies) *cobra.Command {
 		Short:        "List sandbox groups in the active workspace",
 		Args:         cobra.NoArgs,
 		SilenceUsage: true,
-		Long:         `List sandbox groups in your workspace.`,
+		Long:         `List all sandbox groups in your workspace, newest first.`,
 		Example: `  # List sandbox groups in the active workspace
   render ea sandbox-groups list
 

cmd/sandboxlist.go

@@ -13,8 +13,9 @@ import (
 )
 
 type SandboxListInput struct {
-	Status []string `cli:"status"`
-	All    bool     `cli:"all"`
+	SandboxGroupID string   `cli:"sandbox-group"`
+	Status         []string `cli:"status"`
+	All            bool     `cli:"all"`
 }
 
 func newSandboxListCmd(deps *dependencies.Dependencies) *cobra.Command {
@@ -36,6 +37,8 @@ Examples:
 
 	cmd.Flags().StringArray("status", nil, "Filter by status (repeatable: "+strings.Join(sandboxStatusNames(), ", ")+")")
 	cmd.Flags().Bool("all", false, "Include terminated sandboxes")
+	cmd.Flags().String("sandbox-group", "", "Filter by sandbox group ID")
+	setFlagPlaceholder(cmd.Flags(), "sandbox-group", "SANDBOX_GROUP_ID")
 
 	cmd.RunE = func(cmd *cobra.Command, args []string) error {
 		command.DefaultFormatNonInteractive(cmd)
@@ -46,7 +49,7 @@ Examples:
 		}
 
 		_, err := command.NonInteractive(cmd, func() ([]*sandboxclient.Sandbox, error) {
-			return deps.SandboxService().List(cmd.Context(), input.Status, input.All)
+			return deps.SandboxService().List(cmd.Context(), input.Status, input.All, input.SandboxGroupID)
 		}, text.SandboxTable)
 		return err
 	}

cmd/sandboxlist_test.go

@@ -1,12 +1,14 @@
 package cmd
 
 import (
+	"net/url"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	renderapi "github.com/render-oss/cli/internal/fakes/renderapi"
+	sandboxes "github.com/render-oss/cli/pkg/client/sandboxes"
 	"github.com/render-oss/cli/pkg/sandbox"
 )
 
@@ -20,3 +22,20 @@ func TestSandboxList_StatusHelpListsEveryStatus(t *testing.T) {
 		assert.Contains(t, result.Stdout, string(status), "--status help should list %q", status)
 	}
 }
+
+func TestSandboxList_GroupSelection(t *testing.T) {
+	server := newSandboxCreateServer(t)
+	groupID := "sbg-cph1rs3idesc73a2b2mg"
+	server.SandboxGroups.Add(renderapi.NewSandboxGroup(sandboxes.SandboxGroup{Id: groupID, OwnerId: sandboxCreateActiveWorkspaceID}))
+	server.Sandboxes.Add(renderapi.NewSandbox(sandboxes.Sandbox{Id: "sbx-selected", SandboxGroupId: &groupID}))
+	server.Sandboxes.Add(renderapi.NewSandbox(sandboxes.Sandbox{Id: "sbx-other", SandboxGroupId: new(sandboxCreateDefaultGroup(t, server).Id)}))
+	result, err := executeSandboxCommand(t, server, "ea", "sandboxes", "list", "--sandbox-group", groupID, "--output", "json")
+	require.NoError(t, err)
+	assert.Contains(t, result.Stdout, "sbx-selected")
+	assert.NotContains(t, result.Stdout, "sbx-other")
+	req, ok := server.LastRequest("GET", "/sandboxes")
+	require.True(t, ok)
+	u, err := url.Parse(req.URI)
+	require.NoError(t, err)
+	assert.Equal(t, groupID, u.Query().Get("sandboxGroupId"))
+}

internal/fakes/renderapi/sandboxes.go

@@ -3,9 +3,13 @@ package renderapi
 import (
 	"encoding/json"
 	"net/http"
+	"slices"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/render-oss/cli/internal/testids"
+	"github.com/render-oss/cli/pkg/client"
 	sandboxesclient "github.com/render-oss/cli/pkg/client/sandboxes"
 )
 
@@ -102,6 +106,41 @@ func (s *Server) snapshotByName(groupID, name string) (*sandboxesclient.SandboxS
 }
 
 func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Request)) {
+	mux.HandleFunc("GET /sandboxes", func(w http.ResponseWriter, r *http.Request) {
+		record(r)
+		q := r.URL.Query()
+		limit, _ := strconv.Atoi(q.Get("limit"))
+		if limit <= 0 {
+			limit = 20
+		}
+		statuses := strings.Split(q.Get("status"), ",")
+		result := make([]client.SandboxWithCursor, 0)
+		pastCursor := q.Get("cursor") == ""
+		for _, sb := range s.Sandboxes.Instances {
+			if sb.SandboxGroupId == nil || s.sandboxGroupOwner(*sb.SandboxGroupId) != q.Get("ownerId") {
+				continue
+			}
+			if groupID := q.Get("sandboxGroupId"); groupID != "" && *sb.SandboxGroupId != groupID {
+				continue
+			}
+			if !pastCursor {
+				pastCursor = sb.Id == q.Get("cursor")
+				continue
+			}
+			if q.Get("status") == "" && sb.Status == sandboxesclient.SandboxStatusTerminated {
+				continue
+			}
+			if q.Get("status") != "" && !slices.Contains(statuses, string(sb.Status)) {
+				continue
+			}
+			result = append(result, client.SandboxWithCursor{Sandbox: *sb, Cursor: sb.Id})
+			if len(result) == limit {
+				break
+			}
+		}
+		writeJSON(w, http.StatusOK, result)
+	})
+
 	mux.HandleFunc("GET /sandboxes/{sandboxId}", func(w http.ResponseWriter, r *http.Request) {
 		record(r)
 		if q := s.Sandboxes.getErrorQueue; len(q) > 0 {
@@ -124,6 +163,14 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 			writeAPIError(w, http.StatusBadRequest, "invalid body", "")
 			return
 		}
+		groupID := s.defaultSandboxGroupID(body.OwnerId)
+		if body.SandboxGroupId != nil {
+			groupID = *body.SandboxGroupId
+			if s.sandboxGroupOwner(groupID) != body.OwnerId {
+				writeAPIError(w, http.StatusNotFound, "sandbox group not found", "")
+				return
+			}
+		}
 		if body.SnapshotId != nil && body.SnapshotName != nil {
 			writeAPIError(w, http.StatusBadRequest, "snapshotId and snapshotName are mutually exclusive", "")
 			return
@@ -138,7 +185,7 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 		}
 		if body.BuildId != nil {
 			build, found := s.buildByID(*body.BuildId)
-			if !found || build.SandboxGroupId != s.defaultSandboxGroupID(body.OwnerId) {
+			if !found || build.SandboxGroupId != groupID {
 				writeAPIError(w, http.StatusNotFound, "not found: build", "")
 				return
 			}
@@ -148,7 +195,7 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 			}
 		}
 		if body.BuildName != nil {
-			build, found := s.latestBuildByName(s.defaultSandboxGroupID(body.OwnerId), *body.BuildName)
+			build, found := s.latestBuildByName(groupID, *body.BuildName)
 			if !found {
 				writeAPIError(w, http.StatusNotFound, "not found: build", "")
 				return
@@ -164,7 +211,7 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 				writeAPIError(w, http.StatusNotFound, "snapshot not found", ErrorCodeSnapshotNotFound)
 				return
 			}
-			if snap.SandboxGroupId != s.defaultSandboxGroupID(body.OwnerId) {
+			if snap.SandboxGroupId != groupID {
 				writeAPIError(w, http.StatusConflict, "snapshot belongs to a different sandbox group", ErrorCodeSnapshotNotAvailable)
 				return
 			}
@@ -178,7 +225,7 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 			}
 		}
 		if body.SnapshotName != nil {
-			snap, found := s.snapshotByName(s.defaultSandboxGroupID(body.OwnerId), *body.SnapshotName)
+			snap, found := s.snapshotByName(groupID, *body.SnapshotName)
 			if !found {
 				writeAPIError(w, http.StatusNotFound, "snapshot not found", ErrorCodeSnapshotNotFound)
 				return
@@ -188,7 +235,7 @@ func registerSandboxRoutes(mux *http.ServeMux, s *Server, record func(*http.Requ
 				return
 			}
 		}
-		var sb sandboxesclient.Sandbox
+		sb := sandboxesclient.Sandbox{SandboxGroupId: &groupID}
 		if body.Plan != nil {
 			sb.Plan = *body.Plan
 		}

pkg/sandbox/list_test.go

@@ -69,7 +69,7 @@ func TestServiceList_StatusQuery(t *testing.T) {
 				_ = json.NewEncoder(w).Encode([]client.SandboxWithCursor{})
 			})
 
-			_, err := svc.List(context.Background(), tt.statuses, tt.all)
+			_, err := svc.List(context.Background(), tt.statuses, tt.all, "")
 			require.NoError(t, err)
 
 			assert.Equal(t, listTestWorkspace, gotQuery.Get("ownerId"))
@@ -110,7 +110,7 @@ func TestServiceList_FollowsCursorsAcrossPages(t *testing.T) {
 		})
 	})
 
-	got, err := svc.List(context.Background(), nil, false)
+	got, err := svc.List(context.Background(), nil, false, "")
 	require.NoError(t, err)
 
 	assert.Len(t, got, firstPageSize+1)

pkg/sandbox/service.go

@@ -23,11 +23,12 @@ func NewService(repo *Repo) *Service {
 // CreateInput describes the parameters for creating a sandbox. Empty/zero
 // fields fall back to the API defaults.
 type CreateInput struct {
-	Plan          string
-	Region        string
-	Timeout       int
-	IdleTimeout   *int
-	NetworkPolicy string
+	SandboxGroupID string
+	Plan           string
+	Region         string
+	Timeout        int
+	IdleTimeout    *int
+	NetworkPolicy  string
 	// EgressRules are the destinations reachable under an allow-list
 	// NetworkPolicy.
 	EgressRules  []sandboxclient.SandboxEgressRule
@@ -60,8 +61,11 @@ func AllStatuses() []sandboxclient.SandboxStatus {
 // filters by those statuses. Otherwise it sends no status filter, so the server
 // applies its default (exclude terminated) — unless all is true, which requests
 // every status to include terminated sandboxes too.
-func (s *Service) List(ctx context.Context, statuses []string, all bool) ([]*sandboxclient.Sandbox, error) {
+func (s *Service) List(ctx context.Context, statuses []string, all bool, groupID string) ([]*sandboxclient.Sandbox, error) {
 	params := &client.ListSandboxesParams{}
+	if groupID != "" {
+		params.SandboxGroupId = &groupID
+	}
 
 	if len(statuses) > 0 {
 		filtered := make([]sandboxclient.SandboxStatus, len(statuses))
@@ -86,6 +90,9 @@ func (s *Service) Create(ctx context.Context, input CreateInput, onEvent func(*s
 	}
 
 	body := client.CreateSandboxJSONRequestBody{OwnerId: workspace}
+	if input.SandboxGroupID != "" {
+		body.SandboxGroupId = &input.SandboxGroupID
+	}
 
 	if input.Plan != "" {
 		plan := sandboxclient.SandboxPlan(input.Plan)

pkg/sandboxgroup/repo.go

@@ -18,8 +18,8 @@ func NewRepo(c *client.ClientWithResponses) *Repo {
 	return &Repo{client: c}
 }
 
-// List returns the sandbox groups owned by ownerID. The returned slice is
-// always non-nil so callers can range over it unconditionally.
+// List returns all sandbox groups owned by ownerID. Omitting pagination keeps
+// this compatible with servers that do not support group pagination.
 func (r *Repo) List(ctx context.Context, ownerID string) ([]*sandboxesclient.SandboxGroup, error) {
 	params := &client.ListSandboxGroupsParams{
 		OwnerId: ownerID,