Add initial render ea sandbox commands (#381)

Co-authored-by: Jon Brackbill <jbrack@render.com>
GitOrigin-RevId: 8809690556351292df26804a8e50a3ecff95a9ac

Author: 2 people

cmd/root.go

@@ -162,6 +162,10 @@ func setupKVCommands(earlyAccess *cobra.Command, deps *dependencies.Dependencies
 	earlyAccess.AddCommand(newKVCmd(newKVCreateCmd(deps), newKVDeleteCmd(deps), newKVGetCmd(deps), newKVListCmd(deps), newKVResumeCmd(deps), newKVSuspendCmd(deps), newKVUpdateCmd(deps)))
 }
 
+func setupSandboxCommands(earlyAccess *cobra.Command, deps *dependencies.Dependencies) {
+	earlyAccess.AddCommand(newSandboxCmd(newSandboxCreateCmd(deps), newSandboxExecCmd(deps), newSandboxListCmd(deps), newSandboxStopCmd(deps)))
+}
+
 func SetupCommands() error {
 	c, err := client.NewDefaultClient()
 	if err != nil {
@@ -183,6 +187,7 @@ func SetupCommands() error {
 	servicesCmd.AddCommand(newServiceDeleteCmd(deps))
 	setupKVCommands(EarlyAccessCmd, deps)
 	setupPGCommands(EarlyAccessCmd, deps)
+	setupSandboxCommands(EarlyAccessCmd, deps)
 	setupRootCmdPersistentRun(rootCmd, deps)
 
 	return nil

cmd/sandbox.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func newSandboxCmd(children ...*cobra.Command) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "sandbox",
+		Short: "Manage sandboxes",
+		Long: `Manage sandboxes for your Render workspace.
+
+Sandboxes are ephemeral compute environments for running code, agents, and experiments.
+
+Available commands:
+  create   - Create a new sandbox
+  exec     - Execute a command in a sandbox
+  list     - List sandboxes
+  stop     - Terminate a running sandbox
+
+Examples:
+  render ea sandbox create --base=render/sandbox-python
+  render ea sandbox exec sbx-abc123 -- echo hello
+  render ea sandbox list
+  render ea sandbox list --all
+  render ea sandbox stop trn-abc123 --confirm
+`,
+	}
+	cmd.AddCommand(children...)
+	return cmd
+}

cmd/sandboxcreate.go

@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	sandboxclient "github.com/render-oss/cli/pkg/client/sandboxes"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/dependencies"
+	"github.com/render-oss/cli/pkg/sandbox"
+	"github.com/render-oss/cli/pkg/text"
+)
+
+type SandboxCreateInput struct {
+	Plan    string `cli:"plan"`
+	Region  string `cli:"region"`
+	Timeout int    `cli:"timeout"`
+}
+
+func (i *SandboxCreateInput) Validate(_ bool) error {
+	if i.Plan == "" {
+		return nil
+	}
+	switch sandboxclient.SandboxPlan(i.Plan) {
+	case sandboxclient.Starter, sandboxclient.Standard, sandboxclient.Pro:
+		return nil
+	default:
+		return fmt.Errorf("invalid plan %q: use starter, standard, or pro", i.Plan)
+	}
+}
+
+func newSandboxCreateCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "create",
+		Short: "Create a new sandbox",
+		Long: `Create a new sandbox in the current workspace.
+
+Examples:
+  render ea sandbox create
+  render ea sandbox create --plan=standard --region=oregon
+  render ea sandbox create --timeout=3600
+`,
+	}
+
+	cmd.Flags().String("plan", "", "Compute plan: starter, standard, pro")
+	cmd.Flags().String("region", "", "Region to run the sandbox in")
+	cmd.Flags().Int("timeout", 0, "Maximum sandbox lifetime in seconds")
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input SandboxCreateInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+
+		// Stream status updates to stderr only for text output, so JSON/YAML
+		// consumers get a single clean payload on stdout.
+		var onEvent func(*sandboxclient.Sandbox)
+		if format := command.GetFormatFromContext(cmd.Context()); format != nil && *format == command.TEXT {
+			onEvent = func(sb *sandboxclient.Sandbox) {
+				_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "  %s %s\n", sb.Id, sb.Status)
+			}
+		}
+
+		_, err := command.NonInteractive(cmd, func() (*sandboxclient.Sandbox, error) {
+			return deps.SandboxService().Create(cmd.Context(), sandbox.CreateInput{
+				Plan:    input.Plan,
+				Region:  input.Region,
+				Timeout: input.Timeout,
+			}, onEvent)
+		}, text.SandboxDetail)
+		return err
+	}
+
+	return cmd
+}

cmd/sandboxexec.go

@@ -0,0 +1,129 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	sandboxclient "github.com/render-oss/cli/pkg/client/sandboxes"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/dependencies"
+)
+
+// shellUnsafe matches any character that is not safe to pass to a shell
+// unquoted. A token containing one of these is wrapped in single quotes so the
+// remote shell re-splits the command exactly as the user's local shell did.
+var shellUnsafe = regexp.MustCompile(`[^\w@%+=:,./-]`)
+
+var sandboxExecExit = os.Exit
+
+type SandboxExecInput struct {
+	SandboxID string
+	Command   string
+}
+
+func (i *SandboxExecInput) Validate() error {
+	if i.SandboxID == "" {
+		return fmt.Errorf("sandbox ID is required")
+	}
+	if i.Command == "" {
+		return fmt.Errorf("a command is required")
+	}
+	return nil
+}
+
+func newSandboxExecCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "exec <sandboxId> -- <command>",
+		Short: "Execute a command in a sandbox",
+		Long: `Run a single command in a running sandbox. Blocks until the command
+exits and returns stdout, stderr, and exit code.
+
+Pass the command after a "--" separator so its own flags aren't parsed by the
+CLI.
+
+Examples:
+  render ea sandbox exec sbx-abc123 -- echo hello
+  render ea sandbox exec sbx-abc123 -- python script.py
+`,
+		Args: cobra.MinimumNArgs(2),
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		input := SandboxExecInput{
+			SandboxID: args[0],
+			Command:   joinShellCommand(args[1:]),
+		}
+		if err := input.Validate(); err != nil {
+			return err
+		}
+
+		result, err := deps.SandboxService().Exec(cmd.Context(), input.SandboxID, input.Command)
+		if err != nil {
+			return err
+		}
+
+		if err := writeSandboxExecResult(cmd, result); err != nil {
+			return err
+		}
+		exitSandboxExec(result.ExitCode)
+		return nil
+	}
+
+	return cmd
+}
+
+// joinShellCommand reconstructs a single shell command string from the
+// already-tokenized command args. Each token is shell-quoted only when it
+// contains characters the shell would otherwise interpret, so a plain
+// `echo hello` stays `echo hello` while `echo "a b"` becomes `echo 'a b'`.
+func joinShellCommand(args []string) string {
+	quoted := make([]string, len(args))
+	for i, arg := range args {
+		quoted[i] = shellQuote(arg)
+	}
+	return strings.Join(quoted, " ")
+}
+
+func shellQuote(arg string) string {
+	if arg == "" {
+		return "''"
+	}
+	if !shellUnsafe.MatchString(arg) {
+		return arg
+	}
+	// Wrap in single quotes, terminating the quote around any embedded
+	// single quote: ' -> '\''
+	return "'" + strings.ReplaceAll(arg, "'", `'\''`) + "'"
+}
+
+func exitSandboxExec(exitCode int) {
+	if exitCode != 0 {
+		sandboxExecExit(exitCode)
+	}
+}
+
+func writeSandboxExecResult(cmd *cobra.Command, result *sandboxclient.SandboxExecSyncResponse) error {
+	output := command.GetFormatFromContext(cmd.Context())
+	if output != nil && (*output == command.JSON || *output == command.YAML) {
+		_, err := command.PrintData(cmd, result, func(r *sandboxclient.SandboxExecSyncResponse) string {
+			return r.Stdout
+		})
+		return err
+	}
+
+	if result.Stdout != "" {
+		if _, err := fmt.Fprint(cmd.OutOrStdout(), result.Stdout); err != nil {
+			return err
+		}
+	}
+	if result.Stderr != "" {
+		if _, err := fmt.Fprint(cmd.ErrOrStderr(), result.Stderr); err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/sandboxexec_test.go

@@ -0,0 +1,116 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+
+	sandboxclient "github.com/render-oss/cli/pkg/client/sandboxes"
+	"github.com/render-oss/cli/pkg/command"
+)
+
+func TestWriteSandboxExecResultRawOutput(t *testing.T) {
+	cmd, stdout, stderr := newSandboxExecTestCommand(command.TEXT)
+	result := &sandboxclient.SandboxExecSyncResponse{
+		Stdout:   "hello\n",
+		Stderr:   "warning\n",
+		ExitCode: 7,
+	}
+
+	require.NoError(t, writeSandboxExecResult(cmd, result))
+	require.Equal(t, "hello\n", stdout.String())
+	require.Equal(t, "warning\n", stderr.String())
+}
+
+func TestWriteSandboxExecResultJSONOutput(t *testing.T) {
+	cmd, stdout, stderr := newSandboxExecTestCommand(command.JSON)
+	result := &sandboxclient.SandboxExecSyncResponse{
+		Stdout:   "hello\n",
+		Stderr:   "warning\n",
+		ExitCode: 7,
+	}
+
+	require.NoError(t, writeSandboxExecResult(cmd, result))
+	require.JSONEq(t, `{"stdout":"hello\n","stderr":"warning\n","exitCode":7}`, stdout.String())
+	require.Empty(t, stderr.String())
+}
+
+func TestWriteSandboxExecResultYAMLOutput(t *testing.T) {
+	cmd, stdout, stderr := newSandboxExecTestCommand(command.YAML)
+	result := &sandboxclient.SandboxExecSyncResponse{
+		Stdout:   "hello\n",
+		Stderr:   "warning\n",
+		ExitCode: 7,
+	}
+
+	require.NoError(t, writeSandboxExecResult(cmd, result))
+
+	var got map[string]any
+	require.NoError(t, yaml.Unmarshal(stdout.Bytes(), &got))
+	require.Equal(t, "hello\n", got["stdout"])
+	require.Equal(t, "warning\n", got["stderr"])
+	require.Equal(t, 7, got["exitCode"])
+	require.Empty(t, stderr.String())
+}
+
+func TestExitSandboxExecUsesRemoteExitCode(t *testing.T) {
+	oldExit := sandboxExecExit
+	defer func() { sandboxExecExit = oldExit }()
+
+	var gotExitCode *int
+	sandboxExecExit = func(code int) {
+		gotExitCode = &code
+	}
+
+	exitSandboxExec(7)
+	require.NotNil(t, gotExitCode)
+	require.Equal(t, 7, *gotExitCode)
+}
+
+func TestExitSandboxExecSkipsZeroExitCode(t *testing.T) {
+	oldExit := sandboxExecExit
+	defer func() { sandboxExecExit = oldExit }()
+
+	called := false
+	sandboxExecExit = func(int) {
+		called = true
+	}
+
+	exitSandboxExec(0)
+	require.False(t, called)
+}
+
+func TestJoinShellCommand(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{name: "simple command", args: []string{"echo", "hello"}, want: "echo hello"},
+		{name: "preserves quoted spaces", args: []string{"echo", "a b"}, want: "echo 'a b'"},
+		{name: "safe punctuation unquoted", args: []string{"ls", "-la", "./path/to-file_1"}, want: "ls -la ./path/to-file_1"},
+		{name: "quotes shell metacharacters", args: []string{"echo", "$HOME", "&&", "rm"}, want: "echo '$HOME' '&&' rm"},
+		{name: "escapes embedded single quote", args: []string{"echo", "it's"}, want: `echo 'it'\''s'`},
+		{name: "empty token", args: []string{"echo", ""}, want: "echo ''"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, joinShellCommand(tt.args))
+		})
+	}
+}
+
+func newSandboxExecTestCommand(output command.Output) (*cobra.Command, *bytes.Buffer, *bytes.Buffer) {
+	cmd := &cobra.Command{Use: "exec"}
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.SetContext(command.SetFormatInContext(context.Background(), &output))
+	return cmd, stdout, stderr
+}