Refine persistent config command

CoderHariswar · CoderHariswar · commit de714be4fdd5 · 2026-05-23T11:25:24.000+05:30
diff --git a/cmd/cli/commands/config.go b/cmd/cli/commands/config.go
@@ -0,0 +1,14 @@
+package commands
+
+import "github.com/spf13/cobra"
+
+func newConfigCmd() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "config",
+		Short: "Manage persistent model runner configuration",
+	}
+
+	c.AddCommand(newSandboxConfigCmd())
+
+	return c
+}
diff --git a/cmd/cli/commands/launch.go b/cmd/cli/commands/launch.go
@@ -141,15 +141,12 @@ Examples:
 			// resolving runner endpoints. This keeps sandbox launch independent of
 			// whether the host app binary itself is installed.
 			if _, ok := hostApps[app]; ok {
-				sandboxTool, err := readSandboxToolConfig()
+				sandboxTool, err := configuredSandboxTool()
 				if err != nil {
 					return err
 				}
 
 				if sandboxTool != "" {
-					if err := validateSandboxTool(sandboxTool); err != nil {
-						return err
-					}
 					return launchSandboxedHostApp(cmd, sandboxTool, app, appArgs, dryRun)
 				}
 			}
@@ -172,7 +169,6 @@ Examples:
 			if ca, ok := containerApps[app]; ok {
 				return launchContainerApp(cmd, ca, ep.container, image, port, detach, appArgs, dryRun)
 			}
-
 			if cli, ok := hostApps[app]; ok {
 				return launchHostApp(cmd, app, ep.host, cli, model, runner, appArgs, dryRun)
 			}
@@ -190,28 +186,9 @@ Examples:
 }
 
 func launchSandboxedHostApp(cmd *cobra.Command, sandboxTool, app string, appArgs []string, dryRun bool) error {
-	if err := validateSandboxTool(sandboxTool); err != nil {
-		return err
-	}
-
 	args := append([]string{app}, appArgs...)
 
-	switch sandboxTool {
-	case "sbx":
-		if dryRun {
-			cmd.Printf("sbx %s\n", strings.Join(args, " "))
-			return nil
-		}
-
-		launchCmd := exec.Command("sbx", args...)
-		launchCmd.Stdin = os.Stdin
-		launchCmd.Stdout = os.Stdout
-		launchCmd.Stderr = os.Stderr
-
-		return launchCmd.Run()
-	default:
-		return fmt.Errorf("unsupported sandbox tool %q", sandboxTool)
-	}
+	return runSandboxTool(cmd, sandboxTool, args, dryRun)
 }
 
 // listSupportedApps prints all supported apps with their descriptions and install status.
diff --git a/cmd/cli/commands/root.go b/cmd/cli/commands/root.go
@@ -120,7 +120,7 @@ func NewRootCmd(cli *command.DockerCli) *cobra.Command {
 		newShowCmd(),
 		newComposeCmd(),
 		newLaunchCmd(),
-		newSandboxConfigCmd(),
+		newConfigCmd(),
 		newTagCmd(),
 		newConfigureCmd(),
 		newPSCmd(),
diff --git a/cmd/cli/commands/sandbox.go b/cmd/cli/commands/sandbox.go
@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -16,32 +17,26 @@ var allowedSandboxTools = map[string]struct{}{
 
 func newSandboxConfigCmd() *cobra.Command {
 	return &cobra.Command{
-		Use:   "config <key> <value>",
-		Short: "Set model runner configuration values",
-		Args:  cobra.ExactArgs(2),
+		Use:   "sandbox.tool <tool>",
+		Short: "Set the sandbox tool",
+		Args:  cobra.ExactArgs(1),
 		RunE: func(_ *cobra.Command, args []string) error {
-			key := args[0]
-			value := args[1]
-
-			if key != "sandbox.tool" {
-				return fmt.Errorf("unsupported config key %q", key)
-			}
-
-			if err := validateSandboxTool(value); err != nil {
+			tool, err := validateSandboxTool(args[0])
+			if err != nil {
 				return err
 			}
 
-			return writeSandboxToolConfig(value)
+			return writeSandboxToolConfig(tool)
 		},
 	}
 }
 
-func validateSandboxTool(tool string) error {
+func validateSandboxTool(tool string) (string, error) {
 	if _, ok := allowedSandboxTools[tool]; !ok {
-		return fmt.Errorf("unsupported sandbox tool %q", tool)
+		return "", fmt.Errorf("unsupported sandbox tool %q", tool)
 	}
 
-	return nil
+	return tool, nil
 }
 
 func dmrConfigPath() (string, error) {
@@ -124,3 +119,38 @@ func readSandboxToolConfig() (string, error) {
 
 	return "", nil
 }
+func runSandboxTool(cmd *cobra.Command, sandboxTool string, args []string, dryRun bool) error {
+	validatedSandboxTool, err := validateSandboxTool(sandboxTool)
+	if err != nil {
+		return err
+	}
+
+	if dryRun {
+		cmd.Printf("%s %s\n", validatedSandboxTool, strings.Join(args, " "))
+		return nil
+	}
+
+	switch validatedSandboxTool {
+	case "sbx":
+		launchCmd := exec.Command("sbx", args...)
+		launchCmd.Stdin = os.Stdin
+		launchCmd.Stdout = os.Stdout
+		launchCmd.Stderr = os.Stderr
+
+		return launchCmd.Run()
+	default:
+		return fmt.Errorf("unsupported sandbox tool %q", validatedSandboxTool)
+	}
+}
+func configuredSandboxTool() (string, error) {
+	sandboxTool, err := readSandboxToolConfig()
+	if err != nil {
+		return "", err
+	}
+
+	if sandboxTool == "" {
+		return "", nil
+	}
+
+	return validateSandboxTool(sandboxTool)
+}
diff --git a/cmd/cli/commands/sandbox_test.go b/cmd/cli/commands/sandbox_test.go
@@ -52,42 +52,47 @@ func TestReadSandboxToolConfigMissingFile(t *testing.T) {
 }
 
 func TestValidateSandboxToolAllowsSbx(t *testing.T) {
-	if err := validateSandboxTool("sbx"); err != nil {
+	tool, err := validateSandboxTool("sbx")
+	if err != nil {
 		t.Fatalf("validateSandboxTool() error = %v", err)
 	}
+
+	if tool != "sbx" {
+		t.Fatalf("validateSandboxTool() = %q, want %q", tool, "sbx")
+	}
 }
 
 func TestValidateSandboxToolRejectsUnsupportedTool(t *testing.T) {
-	err := validateSandboxTool("firejail")
+	_, err := validateSandboxTool("firejail")
 	if err == nil {
 		t.Fatal("validateSandboxTool() error = nil, want error")
 	}
 }
 
-func TestSandboxConfigCommandRejectsUnsupportedKey(t *testing.T) {
-	cmd := newSandboxConfigCmd()
+func TestConfigCommandRejectsUnsupportedKey(t *testing.T) {
+	cmd := newConfigCmd()
 	cmd.SetArgs([]string{"unsupported.key", "sbx"})
 
 	if err := cmd.Execute(); err == nil {
 		t.Fatal("config command error = nil, want error")
 	}
 }
 
-func TestSandboxConfigCommandRejectsUnsupportedTool(t *testing.T) {
+func TestConfigCommandRejectsUnsupportedTool(t *testing.T) {
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
 
-	cmd := newSandboxConfigCmd()
+	cmd := newConfigCmd()
 	cmd.SetArgs([]string{"sandbox.tool", "firejail"})
 
 	if err := cmd.Execute(); err == nil {
 		t.Fatal("config command error = nil, want error")
 	}
 }
 
-func TestSandboxConfigCommandWritesConfig(t *testing.T) {
+func TestConfigCommandWritesSandboxToolConfig(t *testing.T) {
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
 
-	cmd := newSandboxConfigCmd()
+	cmd := newConfigCmd()
 	cmd.SetArgs([]string{"sandbox.tool", "sbx"})
 
 	if err := cmd.Execute(); err != nil {
@@ -104,14 +109,16 @@ func TestSandboxConfigCommandWritesConfig(t *testing.T) {
 	}
 }
 
-func TestLaunchCommandRequiresConfiguredSandboxTool(t *testing.T) {
+func TestConfiguredSandboxToolMissingConfig(t *testing.T) {
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
 
-	cmd := newLaunchCmd()
-	cmd.SetArgs([]string{"opencode"})
+	got, err := configuredSandboxTool()
+	if err != nil {
+		t.Fatalf("configuredSandboxTool() error = %v", err)
+	}
 
-	if err := cmd.Execute(); err == nil {
-		t.Fatal("launch command error = nil, want error")
+	if got != "" {
+		t.Fatalf("configuredSandboxTool() = %q, want empty string", got)
 	}
 }
 
diff --git a/cmd/cli/docs/reference/docker_model_config.yaml b/cmd/cli/docs/reference/docker_model_config.yaml
@@ -1,9 +1,12 @@
 command: docker model config
-short: Set model runner configuration values
-long: Set model runner configuration values
-usage: docker model config <key> <value>
+short: Manage persistent model runner configuration
+long: Manage persistent model runner configuration
 pname: docker model
 plink: docker_model.yaml
+cname:
+    - docker model config sandbox.tool
+clink:
+    - docker_model_config_sandbox.tool.yaml
 deprecated: false
 hidden: false
 experimental: false
diff --git a/cmd/cli/docs/reference/docker_model_config_sandbox.tool.yaml b/cmd/cli/docs/reference/docker_model_config_sandbox.tool.yaml
@@ -0,0 +1,13 @@
+command: docker model config sandbox.tool
+short: Set the sandbox tool
+long: Set the sandbox tool
+usage: docker model config sandbox.tool <tool>
+pname: docker model config
+plink: docker_model_config.yaml
+deprecated: false
+hidden: false
+experimental: false
+experimentalcli: false
+kubernetes: false
+swarm: false
+
diff --git a/cmd/cli/docs/reference/model.md b/cmd/cli/docs/reference/model.md
@@ -8,7 +8,7 @@ Docker Model Runner
 | Name                                            | Description                                                            |
 |:------------------------------------------------|:-----------------------------------------------------------------------|
 | [`bench`](model_bench.md)                       | Benchmark a model's performance at different concurrency levels        |
-| [`config`](model_config.md)                     | Set model runner configuration values                                  |
+| [`config`](model_config.md)                     | Manage persistent model runner configuration                           |
 | [`context`](model_context.md)                   | Manage Docker Model Runner contexts                                    |
 | [`df`](model_df.md)                             | Show Docker Model Runner disk usage                                    |
 | [`gateway`](model_gateway.md)                   | Run an OpenAI-compatible LLM gateway                                   |
diff --git a/cmd/cli/docs/reference/model_config.md b/cmd/cli/docs/reference/model_config.md
@@ -1,7 +1,14 @@
 # docker model config
 
 <!---MARKER_GEN_START-->
-Set model runner configuration values
+Manage persistent model runner configuration
+
+### Subcommands
+
+| Name                                           | Description          |
+|:-----------------------------------------------|:---------------------|
+| [`sandbox.tool`](model_config_sandbox.tool.md) | Set the sandbox tool |
+
 
 
 <!---MARKER_GEN_END-->
diff --git a/cmd/cli/docs/reference/model_config_sandbox.tool.md b/cmd/cli/docs/reference/model_config_sandbox.tool.md
@@ -0,0 +1,8 @@
+# docker model config sandbox.tool
+
+<!---MARKER_GEN_START-->
+Set the sandbox tool
+
+
+<!---MARKER_GEN_END-->
+

Original file line number	Diff line number	Diff line change
`@@ -52,42 +52,47 @@ func TestReadSandboxToolConfigMissingFile(t *testing.T) {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`func TestValidateSandboxToolAllowsSbx(t *testing.T) {`
`55`		`- if err := validateSandboxTool("sbx"); err != nil {`
	`55`	`+ tool, err := validateSandboxTool("sbx")`
	`56`	`+ if err != nil {`
`56`	`57`	`t.Fatalf("validateSandboxTool() error = %v", err)`
`57`	`58`	`}`
	`59`	`+`
	`60`	`+ if tool != "sbx" {`
	`61`	`+ t.Fatalf("validateSandboxTool() = %q, want %q", tool, "sbx")`
	`62`	`+ }`
`58`	`63`	`}`
`59`	`64`
`60`	`65`	`func TestValidateSandboxToolRejectsUnsupportedTool(t *testing.T) {`
`61`		`- err := validateSandboxTool("firejail")`
	`66`	`+ _, err := validateSandboxTool("firejail")`
`62`	`67`	`if err == nil {`
`63`	`68`	`t.Fatal("validateSandboxTool() error = nil, want error")`
`64`	`69`	`}`
`65`	`70`	`}`
`66`	`71`
`67`		`-func TestSandboxConfigCommandRejectsUnsupportedKey(t *testing.T) {`
`68`		`- cmd := newSandboxConfigCmd()`
	`72`	`+func TestConfigCommandRejectsUnsupportedKey(t *testing.T) {`
	`73`	`+ cmd := newConfigCmd()`
`69`	`74`	`cmd.SetArgs([]string{"unsupported.key", "sbx"})`
`70`	`75`
`71`	`76`	`if err := cmd.Execute(); err == nil {`
`72`	`77`	`t.Fatal("config command error = nil, want error")`
`73`	`78`	`}`
`74`	`79`	`}`
`75`	`80`
`76`		`-func TestSandboxConfigCommandRejectsUnsupportedTool(t *testing.T) {`
	`81`	`+func TestConfigCommandRejectsUnsupportedTool(t *testing.T) {`
`77`	`82`	`t.Setenv("XDG_CONFIG_HOME", t.TempDir())`
`78`	`83`
`79`		`- cmd := newSandboxConfigCmd()`
	`84`	`+ cmd := newConfigCmd()`
`80`	`85`	`cmd.SetArgs([]string{"sandbox.tool", "firejail"})`
`81`	`86`
`82`	`87`	`if err := cmd.Execute(); err == nil {`
`83`	`88`	`t.Fatal("config command error = nil, want error")`
`84`	`89`	`}`
`85`	`90`	`}`
`86`	`91`
`87`		`-func TestSandboxConfigCommandWritesConfig(t *testing.T) {`
	`92`	`+func TestConfigCommandWritesSandboxToolConfig(t *testing.T) {`
`88`	`93`	`t.Setenv("XDG_CONFIG_HOME", t.TempDir())`
`89`	`94`
`90`		`- cmd := newSandboxConfigCmd()`
	`95`	`+ cmd := newConfigCmd()`
`91`	`96`	`cmd.SetArgs([]string{"sandbox.tool", "sbx"})`
`92`	`97`
`93`	`98`	`if err := cmd.Execute(); err != nil {`
`@@ -104,14 +109,16 @@ func TestSandboxConfigCommandWritesConfig(t *testing.T) {`
`104`	`109`	`}`
`105`	`110`	`}`
`106`	`111`
`107`		`-func TestLaunchCommandRequiresConfiguredSandboxTool(t *testing.T) {`
	`112`	`+func TestConfiguredSandboxToolMissingConfig(t *testing.T) {`
`108`	`113`	`t.Setenv("XDG_CONFIG_HOME", t.TempDir())`
`109`	`114`
`110`		`- cmd := newLaunchCmd()`
`111`		`- cmd.SetArgs([]string{"opencode"})`
	`115`	`+ got, err := configuredSandboxTool()`
	`116`	`+ if err != nil {`
	`117`	`+ t.Fatalf("configuredSandboxTool() error = %v", err)`
	`118`	`+ }`
`112`	`119`
`113`		`- if err := cmd.Execute(); err == nil {`
`114`		`- t.Fatal("launch command error = nil, want error")`
	`120`	`+ if got != "" {`
	`121`	`+ t.Fatalf("configuredSandboxTool() = %q, want empty string", got)`
`115`	`122`	`}`
`116`	`123`	`}`
`117`	`124`