Add install-runner and uninstall-runner to manage Docker Model Runner

commands/compose.go

@@ -14,15 +14,15 @@ func newComposeCmd() *cobra.Command {
 	c := &cobra.Command{
 		Use: "compose EVENT",
 	}
-	c.AddCommand(newUpCommand(desktopClient))
+	c.AddCommand(newUpCommand())
 	c.AddCommand(newDownCommand())
 	c.Hidden = true
 	c.PersistentFlags().String("project-name", "", "compose project name") // unused by model
 
 	return c
 }
 
-func newUpCommand(desktopClient *desktop.Client) *cobra.Command {
+func newUpCommand() *cobra.Command {
 	var model string
 	c := &cobra.Command{
 		Use: "up",
@@ -33,6 +33,11 @@ func newUpCommand(desktopClient *desktop.Client) *cobra.Command {
 				return err
 			}
 
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), nil); err != nil {
+				sendErrorf("Failed to initialize standalone model runner: %v", err)
+				return fmt.Errorf("Failed to initialize standalone model runner: %w", err)
+			}
+
 			_, _, err := desktopClient.Pull(model, func(s string) {
 				sendInfo(s)
 			})
@@ -41,8 +46,15 @@ func newUpCommand(desktopClient *desktop.Client) *cobra.Command {
 				return fmt.Errorf("Failed to pull model: %v\n", err)
 			}
 
-			// FIXME get actual URL from Docker Desktop
-			setenv("URL", "http://model-runner.docker.internal/engines/v1/")
+			if kind := modelRunner.EngineKind(); kind == desktop.ModelRunnerEngineKindDesktop {
+				// TODO: Get the actual URL from Docker Desktop via some API.
+				setenv("URL", "http://model-runner.docker.internal/engines/v1/")
+			} else if kind == desktop.ModelRunnerEngineKindMobyManual {
+				setenv("URL", modelRunner.URL("/engines/v1/"))
+			} else if kind == desktop.ModelRunnerEngineKindMoby || kind == desktop.ModelRunnerEngineKindCloud {
+				// TODO: Find a more robust solution in Moby-like environments.
+				setenv("URL", "http://172.17.0.1:12434/engines/v1/")
+			}
 			setenv("MODEL", model)
 
 			return nil

commands/inspect.go

@@ -24,6 +24,9 @@ func newInspectCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			inspectedModel, err := inspectModel(args, openai, desktopClient)
 			if err != nil {
 				return err

commands/install-runner.go

@@ -0,0 +1,141 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/docker/model-cli/commands/completion"
+	"github.com/docker/model-cli/desktop"
+	"github.com/docker/model-cli/pkg/standalone"
+	"github.com/spf13/cobra"
+)
+
+type noopPrinter struct{}
+
+func (*noopPrinter) Printf(format string, args ...any) {}
+
+func (*noopPrinter) Println(args ...any) {}
+
+// ensureStandaloneRunnerAvailable is a utility function that other commands can
+// use to initialize a default standalone model runner. It is a no-op in
+// unsupported contexts or if automatic installs have been disabled.
+func ensureStandaloneRunnerAvailable(ctx context.Context, printer standalone.StatusPrinter) error {
+	// If we're not in a supported model runner context, then don't do anything.
+	if modelRunner.EngineKind() != desktop.ModelRunnerEngineKindMoby {
+		return nil
+	}
+
+	// If automatic installation has been disabled, then don't do anything.
+	if os.Getenv("MODEL_RUNNER_NO_AUTO_INSTALL") != "" {
+		return nil
+	}
+
+	// Ensure that the output printer is non-nil.
+	if printer == nil {
+		printer = &noopPrinter{}
+	}
+
+	// Create a Docker client for the active context.
+	dockerClient, err := desktop.DockerClientForContext(dockerCLI, dockerCLI.CurrentContext())
+	if err != nil {
+		return fmt.Errorf("failed to create Docker client: %w", err)
+	}
+
+	// Check if a model runner container exists.
+	container, _, err := standalone.FindControllerContainer(ctx, dockerClient)
+	if err != nil {
+		return fmt.Errorf("unable to identify existing standalone model runner: %w", err)
+	} else if container != "" {
+		return nil
+	}
+
+	// Ensure that we have an up-to-date copy of the image.
+	if err := standalone.EnsureControllerImage(ctx, dockerClient, false, printer); err != nil {
+		return fmt.Errorf("unable to pull latest standalone model runner image: %w", err)
+	}
+
+	// Ensure that we have a model storage volume.
+	modelStorageVolume, err := standalone.EnsureModelStorageVolume(ctx, dockerClient, printer)
+	if err != nil {
+		return fmt.Errorf("unable to initialize standalone model storage: %w", err)
+	}
+
+	// Create the model runner container.
+	if err := standalone.CreateControllerContainer(ctx, dockerClient, standalone.DefaultControllerPort, false, modelStorageVolume, printer); err != nil {
+		return fmt.Errorf("unable to initialize standalone model runner container: %w", err)
+	}
+
+	// Give the model runner one second to start.
+	time.Sleep(1 * time.Second)
+
+	return nil
+}
+
+func newInstallRunner() *cobra.Command {
+	var port uint16
+	var gpu bool
+	c := &cobra.Command{
+		Use:   "install-runner",
+		Short: "Install Docker Model Runner",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Ensure that we're running in a supported model runner context.
+			if kind := modelRunner.EngineKind(); kind == desktop.ModelRunnerEngineKindDesktop {
+				// TODO: We may eventually want to auto-forward this to
+				// docker desktop enable model-runner, but we should first make
+				// sure the CLI flags match.
+				cmd.Println("Standalone installation not supported with Docker Desktop")
+				cmd.Println("Use `docker desktop enable model-runner` instead")
+				return nil
+			} else if kind == desktop.ModelRunnerEngineKindMobyManual {
+				cmd.Println("Standalone installation not supported with MODEL_RUNNER_HOST set")
+				return nil
+			} else if kind == desktop.ModelRunnerEngineKindCloud {
+				cmd.Println("Standalone installation not required with Docker Cloud")
+				return nil
+			}
+
+			// Create a Docker client for the active context.
+			dockerClient, err := desktop.DockerClientForContext(dockerCLI, dockerCLI.CurrentContext())
+			if err != nil {
+				return fmt.Errorf("failed to create Docker client: %w", err)
+			}
+
+			// Check if an active model runner container already exists.
+			if ctrID, ctrName, err := standalone.FindControllerContainer(cmd.Context(), dockerClient); err != nil {
+				return err
+			} else if ctrID != "" {
+				if ctrName != "" {
+					cmd.Printf("Model Runner container %s (%s) is already running\n", ctrName, ctrID[:12])
+				} else {
+					cmd.Printf("Model Runner container %s is already running\n", ctrID[:12])
+				}
+				return nil
+			}
+
+			// Ensure that we have an up-to-date copy of the image.
+			if err := standalone.EnsureControllerImage(cmd.Context(), dockerClient, gpu, cmd); err != nil {
+				return fmt.Errorf("unable to pull latest standalone model runner image: %w", err)
+			}
+
+			// Ensure that we have a model storage volume.
+			modelStorageVolume, err := standalone.EnsureModelStorageVolume(cmd.Context(), dockerClient, cmd)
+			if err != nil {
+				return fmt.Errorf("unable to initialize standalone model storage: %w", err)
+			}
+
+			// Create the model runner container.
+			if err := standalone.CreateControllerContainer(cmd.Context(), dockerClient, port, gpu, modelStorageVolume, cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner container: %w", err)
+			}
+
+			return nil
+		},
+		ValidArgsFunction: completion.NoComplete,
+	}
+	c.Flags().Uint16Var(&port, "port", standalone.DefaultControllerPort,
+		"Docker container port for Docker Model Runner")
+	c.Flags().BoolVar(&gpu, "gpu", false, "Enable GPU support")
+	return c
+}

commands/list.go

@@ -23,6 +23,9 @@ func newListCmd() *cobra.Command {
 			if openai && quiet {
 				return fmt.Errorf("--quiet flag cannot be used with --openai flag")
 			}
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), nil); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			models, err := listModels(openai, desktopClient, quiet, jsonFormat)
 			if err != nil {
 				return err

commands/pull.go

@@ -23,6 +23,9 @@ func newPullCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			return pullModel(cmd, desktopClient, args[0])
 		},
 		ValidArgsFunction: completion.NoComplete,

commands/push.go

@@ -23,6 +23,9 @@ func newPushCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			return pushModel(cmd, desktopClient, args[0])
 		},
 		ValidArgsFunction: completion.NoComplete,

commands/rm.go

@@ -24,6 +24,9 @@ func newRemoveCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			response, err := desktopClient.Remove(args, force)
 			if response != "" {
 				cmd.Println(response)

commands/root.go

@@ -10,6 +10,9 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// dockerCLI is the Docker CLI environment associated with the command.
+var dockerCLI *command.DockerCli
+
 // modelRunner is the model runner context. It is initialized by the root
 // command's PersistentPreRunE.
 var modelRunner *desktop.ModelRunnerContext
@@ -41,10 +44,11 @@ func NewRootCmd(cli *command.DockerCli) *cobra.Command {
 			} else if err := plugin.PersistentPreRunE(cmd, args); err != nil {
 				return err
 			}
+			dockerCLI = cli
 
 			// Detect the model runner context and create a client for it.
 			var err error
-			modelRunner, err = desktop.DetectContext(cli)
+			modelRunner, err = desktop.DetectContext(dockerCLI)
 			if err != nil {
 				return fmt.Errorf("unable to detect model runner context: %w", err)
 			}
@@ -81,6 +85,8 @@ func NewRootCmd(cli *command.DockerCli) *cobra.Command {
 		newInspectCmd(),
 		newComposeCmd(),
 		newTagCmd(),
+		newInstallRunner(),
+		newUninstallRunner(),
 	)
 	return rootCmd
 }

commands/run.go

@@ -33,6 +33,10 @@ func newRunCmd() *cobra.Command {
 				}
 			}
 
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
+
 			modelDetail, err := desktopClient.Inspect(model)
 			if err != nil {
 				if !errors.Is(err, desktop.ErrNotFound) {

commands/status.go

@@ -2,6 +2,7 @@ package commands
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 
 	"github.com/docker/cli/cli-plugins/hooks"
@@ -14,6 +15,9 @@ func newStatusCmd() *cobra.Command {
 		Use:   "status",
 		Short: "Check if the Docker Model Runner is running",
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			status := desktopClient.Status()
 			if status.Error != nil {
 				return handleClientError(status.Error, "Failed to get Docker Model Runner status")

commands/tag.go

@@ -23,6 +23,9 @@ func newTagCmd() *cobra.Command {
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureStandaloneRunnerAvailable(cmd.Context(), cmd); err != nil {
+				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
+			}
 			return tagModel(cmd, desktopClient, args[0], args[1])
 		},
 	}

commands/uninstall-runner.go

@@ -0,0 +1,66 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/docker/model-cli/commands/completion"
+	"github.com/docker/model-cli/desktop"
+	"github.com/docker/model-cli/pkg/standalone"
+	"github.com/spf13/cobra"
+)
+
+func newUninstallRunner() *cobra.Command {
+	var models, images bool
+	c := &cobra.Command{
+		Use:   "uninstall-runner",
+		Short: "Uninstall Docker Model Runner",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Ensure that we're running in a supported model runner context.
+			if kind := modelRunner.EngineKind(); kind == desktop.ModelRunnerEngineKindDesktop {
+				// TODO: We may eventually want to auto-forward this to
+				// docker desktop disable model-runner, but we should first
+				// make install-runner forward in the same way.
+				cmd.Println("Standalone uninstallation not supported with Docker Desktop")
+				cmd.Println("Use `docker desktop disable model-runner` instead")
+				return nil
+			} else if kind == desktop.ModelRunnerEngineKindMobyManual {
+				cmd.Println("Standalone uninstallation not supported with MODEL_RUNNER_HOST set")
+				return nil
+			} else if kind == desktop.ModelRunnerEngineKindCloud {
+				cmd.Println("Standalone uninstallation not supported with Docker Cloud")
+				return nil
+			}
+
+			// Create a Docker client for the active context.
+			dockerClient, err := desktop.DockerClientForContext(dockerCLI, dockerCLI.CurrentContext())
+			if err != nil {
+				return fmt.Errorf("failed to create Docker client: %w", err)
+			}
+
+			// Remove any model runner containers.
+			if err := standalone.PruneControllerContainers(cmd.Context(), dockerClient, cmd); err != nil {
+				return fmt.Errorf("unable to remove model runner container(s): %w", err)
+			}
+
+			// Remove model runner images, if requested.
+			if images {
+				if err := standalone.PruneControllerImages(cmd.Context(), dockerClient, cmd); err != nil {
+					return fmt.Errorf("unable to remove model runner image(s): %w", err)
+				}
+			}
+
+			// Remove model storage, if requested.
+			if models {
+				if err := standalone.PruneModelStorageVolumes(cmd.Context(), dockerClient, cmd); err != nil {
+					return fmt.Errorf("unable to remove model storage volume(s): %w", err)
+				}
+			}
+
+			return nil
+		},
+		ValidArgsFunction: completion.NoComplete,
+	}
+	c.Flags().BoolVar(&models, "models", false, "Remove model storage volume")
+	c.Flags().BoolVar(&images, "images", false, "Remove "+standalone.ControllerImage+" images")
+	return c
+}