feat(create): add build mode flags and fix dynamic workspace group resolution

- Remove hardcoded "GCP" WorkspaceGroupID, resolve dynamically from instance type
- Populate VMBuild by default so SSH setup works correctly
- Add --mode flag (vm, k8s, container, compose) to select build type
- Add --jupyter, --startup-script, --container-image, --compose-file flags
- Match UI behavior: server determines mode from build field presence
  (vmBuild, customContainer, dockerCompose)

Tested: vm, container, and compose modes create successfully with SSH access.
K8s mode sends correct config but requires a dev-plane fix for dashboard install.

Author: theFong

pkg/cmd/create/create.go

@@ -2,9 +2,11 @@ package create
 
 import (
 	"fmt"
+	"os"
 	"strings"
 	"time"
 
+	"github.com/brevdev/brev-cli/pkg/cmd/gpusearch"
 	"github.com/brevdev/brev-cli/pkg/cmd/util"
 	"github.com/brevdev/brev-cli/pkg/config"
 	"github.com/brevdev/brev-cli/pkg/entity"
@@ -30,12 +32,18 @@ type CreateStore interface {
 	GetCurrentUser() (*entity.User, error)
 	GetWorkspace(workspaceID string) (*entity.Workspace, error)
 	CreateWorkspace(organizationID string, options *store.CreateWorkspacesOptions) (*entity.Workspace, error)
+	GetAllInstanceTypesWithWorkspaceGroups(orgID string) (*gpusearch.AllInstanceTypesResponse, error)
 }
 
 func NewCmdCreate(t *terminal.Terminal, createStore CreateStore) *cobra.Command {
 	var detached bool
 	var gpu string
 	var cpu string
+	var mode string
+	var jupyter bool
+	var startupScript string
+	var containerImage string
+	var composeFile string
 
 	cmd := &cobra.Command{
 		Annotations:           map[string]string{"workspace": ""},
@@ -50,11 +58,20 @@ func NewCmdCreate(t *terminal.Terminal, createStore CreateStore) *cobra.Command
 				name = args[0]
 			}
 
+			// Default jupyter to true unless explicitly set to false
+			jupyterSet := cmd.Flags().Changed("jupyter")
+
 			err := runCreateWorkspace(t, CreateOptions{
 				Name:           name,
 				WorkspaceClass: cpu,
 				Detached:       detached,
 				InstanceType:   gpu,
+				Mode:           mode,
+				Jupyter:        jupyter,
+				JupyterSet:     jupyterSet,
+				StartupScript:  startupScript,
+				ContainerImage: containerImage,
+				ComposeFile:    composeFile,
 			}, createStore)
 			if err != nil {
 				if strings.Contains(err.Error(), "duplicate instance with name") {
@@ -70,6 +87,11 @@ func NewCmdCreate(t *terminal.Terminal, createStore CreateStore) *cobra.Command
 	cmd.Flags().BoolVarP(&detached, "detached", "d", false, "run the command in the background instead of blocking the shell")
 	cmd.Flags().StringVarP(&cpu, "cpu", "c", "", "CPU instance type. Defaults to 2x8 [2x8, 4x16, 8x32, 16x32]. See docs.brev.dev/cpu for details")
 	cmd.Flags().StringVarP(&gpu, "gpu", "g", "n1-highmem-4:nvidia-tesla-t4:1", "GPU instance type. See https://brev.dev/docs/reference/gpu for details")
+	cmd.Flags().StringVarP(&mode, "mode", "m", "vm", "Build mode: vm (default), k8s, container, compose")
+	cmd.Flags().BoolVar(&jupyter, "jupyter", true, "Install Jupyter (default true for vm/k8s modes)")
+	cmd.Flags().StringVar(&startupScript, "startup-script", "", "Lifecycle script to run on boot")
+	cmd.Flags().StringVar(&containerImage, "container-image", "", "Container image URL (required for container mode)")
+	cmd.Flags().StringVar(&composeFile, "compose-file", "", "Docker compose file path or URL (required for compose mode)")
 	return cmd
 }
 
@@ -78,6 +100,12 @@ type CreateOptions struct {
 	WorkspaceClass string
 	Detached       bool
 	InstanceType   string
+	Mode           string
+	Jupyter        bool
+	JupyterSet     bool // whether --jupyter was explicitly set
+	StartupScript  string
+	ContainerImage string
+	ComposeFile    string
 }
 
 func runCreateWorkspace(t *terminal.Terminal, options CreateOptions, createStore CreateStore) error {
@@ -98,6 +126,22 @@ func createEmptyWorkspace(user *entity.User, t *terminal.Terminal, options Creat
 		return breverrors.NewValidationError("A name field is required to create a workspace!")
 	}
 
+	// validate mode
+	switch options.Mode {
+	case "vm", "k8s", "container", "compose":
+		// valid
+	default:
+		return breverrors.NewValidationError(fmt.Sprintf("invalid mode %q: must be one of vm, k8s, container, compose", options.Mode))
+	}
+
+	// validate mode-specific required flags
+	if options.Mode == "container" && options.ContainerImage == "" {
+		return breverrors.NewValidationError("--container-image is required for container mode")
+	}
+	if options.Mode == "compose" && options.ComposeFile == "" {
+		return breverrors.NewValidationError("--compose-file is required for compose mode")
+	}
+
 	// ensure org
 	var orgID string
 	activeorg, err := createStore.GetActiveOrganizationOrDefault()
@@ -122,14 +166,28 @@ func createEmptyWorkspace(user *entity.User, t *terminal.Terminal, options Creat
 		cwOptions.WithInstanceType(options.InstanceType)
 	}
 
-	t.Vprintf("Creating instane %s in org %s\n", t.Green(cwOptions.Name), t.Green(orgID))
+	// Resolve workspace group dynamically from instance type
+	resolveWorkspaceGroupID(t, createStore, cwOptions, orgID)
+
+	// Apply build mode
+	err = applyBuildMode(cwOptions, options)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+
+	t.Vprintf("Creating instance %s in org %s\n", t.Green(cwOptions.Name), t.Green(orgID))
 	t.Vprintf("\tname %s\n", t.Green(cwOptions.Name))
 	if options.InstanceType != "" {
 		t.Vprintf("\tGPU instance %s\n", t.Green(options.InstanceType))
 	} else {
 		t.Vprintf("\tCPU instance %s\n", t.Green(cwOptions.WorkspaceClassID))
 	}
-	t.Vprintf("\tCloud %s\n\n", t.Green(cwOptions.WorkspaceGroupID))
+	t.Vprintf("\tmode %s\n", t.Green(options.Mode))
+	if cwOptions.WorkspaceGroupID != "" {
+		t.Vprintf("\tCloud %s\n\n", t.Green(cwOptions.WorkspaceGroupID))
+	} else {
+		t.Vprintf("\tCloud %s\n\n", t.Green("(auto)"))
+	}
 
 	s := t.NewSpinner()
 	s.Suffix = " Creating your instance. Hang tight 🤙"
@@ -156,6 +214,90 @@ func createEmptyWorkspace(user *entity.User, t *terminal.Terminal, options Creat
 	}
 }
 
+// resolveWorkspaceGroupID fetches workspace groups for the instance type and sets the workspace group ID
+func resolveWorkspaceGroupID(t *terminal.Terminal, createStore CreateStore, cwOptions *store.CreateWorkspacesOptions, orgID string) {
+	allInstanceTypes, err := createStore.GetAllInstanceTypesWithWorkspaceGroups(orgID)
+	if err != nil {
+		t.Vprintf("Warning: could not fetch workspace groups: %s\n", err.Error())
+		t.Vprintf("Falling back to server default\n")
+		return
+	}
+	if allInstanceTypes != nil && cwOptions.InstanceType != "" {
+		if wgID := allInstanceTypes.GetWorkspaceGroupID(cwOptions.InstanceType); wgID != "" {
+			cwOptions.WorkspaceGroupID = wgID
+		}
+	}
+}
+
+// applyBuildMode configures the workspace options based on the selected build mode.
+// The server determines the mode from which build field is present (vmBuild, customContainer,
+// dockerCompose) — we do NOT send vmOnlyMode or onContainer, matching the UI behavior.
+func applyBuildMode(cwOptions *store.CreateWorkspacesOptions, options CreateOptions) error {
+	switch options.Mode {
+	case "vm":
+		jupyter := true
+		if options.JupyterSet {
+			jupyter = options.Jupyter
+		}
+		cwOptions.VMBuild = &store.VMBuild{
+			ForceJupyterInstall: jupyter,
+		}
+		if options.StartupScript != "" {
+			cwOptions.VMBuild.LifeCycleScriptAttr = &store.LifeCycleScriptAttr{
+				Script: options.StartupScript,
+			}
+		}
+
+	case "k8s":
+		jupyter := false // UI defaults to false for k8s
+		if options.JupyterSet {
+			jupyter = options.Jupyter
+		}
+		cwOptions.VMBuild = &store.VMBuild{
+			ForceJupyterInstall: jupyter,
+			K8s: &store.K8sConfig{
+				IsDisabled:         false,
+				IsDashboardEnabled: true,
+			},
+		}
+		if options.StartupScript != "" {
+			cwOptions.VMBuild.LifeCycleScriptAttr = &store.LifeCycleScriptAttr{
+				Script: options.StartupScript,
+			}
+		}
+
+	case "container":
+		cwOptions.VMBuild = nil
+		cwOptions.CustomContainer = &store.CustomContainer{
+			ContainerURL: options.ContainerImage,
+		}
+
+	case "compose":
+		cwOptions.VMBuild = nil
+		composeConfig := &store.DockerCompose{}
+
+		// Check if it's a file path or URL
+		if strings.HasPrefix(options.ComposeFile, "http://") || strings.HasPrefix(options.ComposeFile, "https://") {
+			composeConfig.FileURL = options.ComposeFile
+		} else {
+			content, err := os.ReadFile(options.ComposeFile)
+			if err != nil {
+				return breverrors.WrapAndTrace(fmt.Errorf("could not read compose file %s: %w", options.ComposeFile, err))
+			}
+			composeConfig.YamlString = string(content)
+		}
+
+		jupyter := false
+		if options.JupyterSet {
+			jupyter = options.Jupyter
+		}
+		composeConfig.JupyterInstall = jupyter
+		cwOptions.DockerCompose = composeConfig
+	}
+
+	return nil
+}
+
 func resolveWorkspaceUserOptions(options *store.CreateWorkspacesOptions, user *entity.User) *store.CreateWorkspacesOptions {
 	if options.WorkspaceTemplateID == "" {
 		if featureflag.IsAdmin(user.GlobalUserType) {