launch.go

package commands

import (
	"errors"
	"fmt"
	"net"
	"os"
	"os/exec"
	"sort"
	"strings"

	"github.com/docker/model-runner/cmd/cli/pkg/types"
	"github.com/spf13/cobra"
)

// openaiPathSuffix is the path appended to the base URL for OpenAI-compatible endpoints.
const openaiPathSuffix = "/engines/v1"

// dummyAPIKey is a placeholder API key for Docker Model Runner (which doesn't require auth).
const dummyAPIKey = "sk-docker-model-runner" //nolint:gosec // not a real credential

// engineEndpoints holds the resolved base URLs (without path) for both
// client locations.
type engineEndpoints struct {
	// base URL reachable from inside a Docker container
	// (e.g., http://model-runner.docker.internal).
	container string
	// base URL reachable from the host machine
	// (e.g., http://127.0.0.1:12434).
	host string
}

// containerApp describes an app that runs as a Docker container.
type containerApp struct {
	defaultImage    string
	defaultHostPort int
	containerPort   int
	envFn           func(baseURL string) []string
	extraDockerArgs []string // additional docker run args (e.g., volume mounts)
}

// containerApps are launched via "docker run --rm".
var containerApps = map[string]containerApp{
	"anythingllm": {
		defaultImage:    "mintplexlabs/anythingllm:latest",
		defaultHostPort: 3001,
		containerPort:   3001,
		envFn:           anythingllmEnv,
		extraDockerArgs: []string{"-v", "anythingllm_storage:/app/server/storage"},
	},
	"openwebui": {
		defaultImage:    "ghcr.io/open-webui/open-webui:latest",
		defaultHostPort: 3000,
		containerPort:   8080,
		envFn:           openwebuiEnv},

	"llmfit": {
		defaultImage: "ghcr.io/alexsjones/llmfit",
		envFn:        llmfitEnv,
	},
}

// hostApp describes a native CLI app launched on the host.
type hostApp struct {
	envFn              func(baseURL string) []string
	configInstructions func(baseURL string) []string // for apps that need manual config
}

// hostApps are launched as native executables on the host.
var hostApps = map[string]hostApp{
	"opencode": {envFn: openaiEnv(openaiPathSuffix)},
	"codex":    {envFn: openaiEnv("/v1")},
	"claude":   {envFn: anthropicEnv},
	"openclaw": {configInstructions: openclawConfigInstructions},
}

// supportedApps is derived from the registries above.
var supportedApps = func() []string {
	apps := make([]string, 0, len(containerApps)+len(hostApps))
	for name := range containerApps {
		apps = append(apps, name)
	}
	for name := range hostApps {
		apps = append(apps, name)
	}
	sort.Strings(apps)
	return apps
}()

// appDescriptions provides human-readable descriptions for supported apps.
var appDescriptions = map[string]string{
	"anythingllm": "RAG platform with Docker Model Runner provider",
	"claude":      "Claude Code AI assistant",
	"codex":       "Codex CLI",
	"openclaw":    "Open Claw AI assistant",
	"opencode":    "Open Code AI code editor",
	"openwebui":   "Open WebUI for models",
	"llmfit":      "Recommend models that run on your system",
}

func newLaunchCmd() *cobra.Command {
	var (
		port       int
		image      string
		detach     bool
		dryRun     bool
		configOnly bool
		model      string
	)
	c := &cobra.Command{
		Use:   "launch [APP] [-- APP_ARGS...]",
		Short: "Launch an app configured to use Docker Model Runner",
		Long: fmt.Sprintf(`Launch an app configured to use Docker Model Runner.

Without arguments, lists all supported apps.

Supported apps: %s

Examples:
  docker model launch
  docker model launch opencode
	docker model launch llmfit
  docker model launch claude -- --help
  docker model launch openwebui --port 3000
  docker model launch claude --config
  docker model launch llmfit -- recommend -n 5`, strings.Join(supportedApps, ", ")),
		ValidArgs: supportedApps,
		RunE: func(cmd *cobra.Command, args []string) error {
			// No args - list supported apps
			if len(args) == 0 {
				return listSupportedApps(cmd)
			}

			app := strings.ToLower(args[0])

			// Extract passthrough args using -- separator
			var appArgs []string
			dashIdx := cmd.ArgsLenAtDash()
			if dashIdx == -1 {
				// No "--" separator
				if len(args) > 1 {
					return fmt.Errorf("unexpected arguments: %s\nUse '--' to pass extra arguments to the app", strings.Join(args[1:], " "))
				}
			} else {
				// "--" was used: require exactly 1 arg (the app name) before it
				if dashIdx != 1 {
					return fmt.Errorf("unexpected arguments before '--': %s\nUsage: docker model launch [APP] [-- APP_ARGS...]", strings.Join(args[1:dashIdx], " "))
				}
				appArgs = args[dashIdx:]
			}

			runner, err := getStandaloneRunner(cmd.Context())
			if err != nil {
				return fmt.Errorf("unable to determine standalone runner endpoint: %w", err)
			}

			ep, err := resolveBaseEndpoints(runner)
			if err != nil {
				return err
			}

			// --config: print configuration without launching
			if configOnly {
				return printAppConfig(cmd, app, ep, image, port)
			}

			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)
			}
			return fmt.Errorf("unsupported app %q (supported: %s)", app, strings.Join(supportedApps, ", "))
		},
	}
	c.Flags().IntVar(&port, "port", 0, "Host port to expose (web UIs)")
	c.Flags().StringVar(&image, "image", "", "Override container image for containerized apps")
	c.Flags().BoolVar(&detach, "detach", false, "Run containerized app in background")
	c.Flags().BoolVar(&dryRun, "dry-run", false, "Print what would be executed without running it")
	c.Flags().BoolVar(&configOnly, "config", false, "Print configuration without launching")
	c.Flags().StringVar(&model, "model", "", "Model to use (for opencode)")
	return c
}

// listSupportedApps prints all supported apps with their descriptions and install status.
func listSupportedApps(cmd *cobra.Command) error {
	cmd.Println("Supported apps:")
	cmd.Println()
	for _, name := range supportedApps {
		desc := appDescriptions[name]
		if desc == "" {
			desc = name
		}
		status := ""
		if _, ok := hostApps[name]; ok {
			if _, err := exec.LookPath(name); err != nil {
				status = " (not installed)"
			}
		}
		cmd.Printf("  %-15s %s%s\n", name, desc, status)
	}
	cmd.Println()
	cmd.Println("Usage: docker model launch [APP] [-- APP_ARGS...]")
	return nil
}

// printAppConfig prints the configuration that would be used for the given app.
func printAppConfig(cmd *cobra.Command, app string, ep engineEndpoints, imageOverride string, portOverride int) error {
	if ca, ok := containerApps[app]; ok {
		img := imageOverride
		if img == "" {
			img = ca.defaultImage
		}
		hostPort := portOverride
		if hostPort == 0 {
			hostPort = ca.defaultHostPort
		}
		cmd.Printf("Configuration for %s (container app):\n", app)
		cmd.Printf("  Image:          %s\n", img)
		if ca.containerPort > 0 {
			cmd.Printf("  Container port: %d\n", ca.containerPort)
		}
		if ca.defaultHostPort > 0 {
			cmd.Printf("  Host port:      %d\n", hostPort)
		}
		if ca.envFn != nil {
			cmd.Printf("  Environment:\n")
			for _, e := range ca.envFn(ep.container) {
				cmd.Printf("    %s\n", e)
			}
		}
		return nil
	}
	if cli, ok := hostApps[app]; ok {
		cmd.Printf("Configuration for %s (host app):\n", app)
		if cli.envFn != nil {
			cmd.Printf("  Environment:\n")
			for _, e := range cli.envFn(ep.host) {
				cmd.Printf("    %s\n", e)
			}
		}
		if cli.configInstructions != nil {
			cmd.Printf("  Manual configuration:\n")
			for _, line := range cli.configInstructions(ep.host) {
				cmd.Printf("    %s\n", line)
			}
		}
		return nil
	}
	return fmt.Errorf("unsupported app %q (supported: %s)", app, strings.Join(supportedApps, ", "))
}

// resolveBaseEndpoints resolves the base URLs (without path) for both
// container and host client locations.
func resolveBaseEndpoints(runner *standaloneRunner) (engineEndpoints, error) {
	const (
		localhost          = "127.0.0.1"
		hostDockerInternal = "host.docker.internal"
	)

	kind := modelRunner.EngineKind()
	switch kind {
	case types.ModelRunnerEngineKindDesktop:
		return engineEndpoints{
			container: "http://model-runner.docker.internal",
			host:      strings.TrimRight(modelRunner.URL(""), "/"),
		}, nil
	case types.ModelRunnerEngineKindMobyManual:
		ep := strings.TrimRight(modelRunner.URL(""), "/")
		containerEP := strings.NewReplacer(
			"localhost", hostDockerInternal,
			localhost, hostDockerInternal,
		).Replace(ep)
		return engineEndpoints{container: containerEP, host: ep}, nil
	case types.ModelRunnerEngineKindCloud, types.ModelRunnerEngineKindMoby:
		if runner == nil {
			return engineEndpoints{}, errors.New("unable to determine standalone runner endpoint")
		}
		if runner.gatewayIP != "" && runner.gatewayPort != 0 {
			port := fmt.Sprintf("%d", runner.gatewayPort)
			return engineEndpoints{
				container: "http://" + net.JoinHostPort(runner.gatewayIP, port),
				host:      "http://" + net.JoinHostPort(localhost, port),
			}, nil
		}
		if runner.hostPort != 0 {
			hostPort := fmt.Sprintf("%d", runner.hostPort)
			return engineEndpoints{
				container: "http://" + net.JoinHostPort(hostDockerInternal, hostPort),
				host:      "http://" + net.JoinHostPort(localhost, hostPort),
			}, nil
		}
		return engineEndpoints{}, errors.New("unable to determine standalone runner endpoint")
	default:
		return engineEndpoints{}, fmt.Errorf("unhandled engine kind: %v", kind)
	}
}

// launchContainerApp launches a container-based app via "docker run".
func launchContainerApp(cmd *cobra.Command, ca containerApp, baseURL string, imageOverride string, portOverride int, detach bool, appArgs []string, dryRun bool) error {
	img := imageOverride
	if img == "" {
		img = ca.defaultImage
	}
	hostPort := portOverride
	if hostPort == 0 {
		hostPort = ca.defaultHostPort
	}

	dockerArgs := []string{"run", "--rm"}
	if detach {
		dockerArgs = append(dockerArgs, "-d")
	}

	if ca.containerPort > 0 {
		dockerArgs = append(dockerArgs,
			"-p", fmt.Sprintf("%d:%d", hostPort, ca.containerPort),
		)
	}

	dockerArgs = append(dockerArgs, ca.extraDockerArgs...)
	if ca.envFn == nil {
		return fmt.Errorf("container app requires envFn to be set")
	}
	for _, e := range ca.envFn(baseURL) {
		dockerArgs = append(dockerArgs, "-e", e)
	}
	dockerArgs = append(dockerArgs, img)
	dockerArgs = append(dockerArgs, appArgs...)

	if dryRun {
		cmd.Printf("Would run: docker %s\n", strings.Join(dockerArgs, " "))
		return nil
	}

	return runExternal(cmd, nil, "docker", dockerArgs...)
}

// launchHostApp launches a native host app executable.
func launchHostApp(cmd *cobra.Command, bin string, baseURL string, cli hostApp, model string, runner *standaloneRunner, appArgs []string, dryRun bool) error {
	// Special handling for opencode: use dedicated launcher
	if bin == "opencode" {
		return launchOpenCode(cmd, baseURL, model, runner, appArgs, dryRun)
	}

	if !dryRun {
		if _, err := exec.LookPath(bin); err != nil {
			cmd.PrintErrf("%q executable not found in PATH.\n", bin)
			if cli.envFn != nil {
				cmd.PrintErrf("Configure your app to use:\n")
				for _, e := range cli.envFn(baseURL) {
					cmd.PrintErrf("  %s\n", e)
				}
			}
			return fmt.Errorf("%s not found; please install it and re-run", bin)
		}
	}

	if cli.envFn == nil {
		return launchUnconfigurableHostApp(cmd, bin, baseURL, cli, appArgs, dryRun)
	}

	env := cli.envFn(baseURL)
	if dryRun {
		cmd.Printf("Would run: %s %s\n", bin, strings.Join(appArgs, " "))
		for _, e := range env {
			cmd.Printf("  %s\n", e)
		}
		return nil
	}
	return runExternal(cmd, withEnv(env...), bin, appArgs...)
}

// launchUnconfigurableHostApp handles host apps that need manual config rather than env vars.
func launchUnconfigurableHostApp(cmd *cobra.Command, bin string, baseURL string, cli hostApp, appArgs []string, dryRun bool) error {
	enginesEP := baseURL + openaiPathSuffix
	cmd.Printf("Configure %s to use Docker Model Runner:\n", bin)
	cmd.Printf("  Base URL: %s\n", enginesEP)
	cmd.Printf("  API type: openai-completions\n")
	cmd.Printf("  API key:  %s\n", dummyAPIKey)

	if cli.configInstructions != nil {
		cmd.Printf("\nExample:\n")
		for _, line := range cli.configInstructions(baseURL) {
			cmd.Printf("  %s\n", line)
		}
	}
	if dryRun {
		cmd.Printf("Would run: %s %s\n", bin, strings.Join(appArgs, " "))
		return nil
	}
	return runExternal(cmd, nil, bin, appArgs...)
}

// openclawConfigInstructions returns configuration commands for openclaw.
func openclawConfigInstructions(baseURL string) []string {
	ep := baseURL + openaiPathSuffix
	return []string{
		fmt.Sprintf("openclaw config set models.providers.docker-model-runner.baseUrl %q", ep),
		"openclaw config set models.providers.docker-model-runner.api openai-completions",
		fmt.Sprintf("openclaw config set models.providers.docker-model-runner.apiKey %s", dummyAPIKey),
	}
}

// openaiEnv returns an env builder that sets OpenAI-compatible
// environment variables using the given path suffix.
func openaiEnv(suffix string) func(string) []string {
	return func(baseURL string) []string {
		ep := baseURL + suffix
		return []string{
			"OPENAI_API_BASE=" + ep,
			"OPENAI_BASE_URL=" + ep,
			"OPENAI_API_BASE_URL=" + ep,
			"OPENAI_API_KEY=" + dummyAPIKey,
			"OPEN_AI_KEY=" + dummyAPIKey, // AnythingLLM uses this
		}
	}
}

// openwebuiEnv returns environment variables for Open WebUI with Docker Model Runner.
func openwebuiEnv(baseURL string) []string {
	return append(openaiEnv(openaiPathSuffix)(baseURL), "WEBUI_AUTH=false")
}

// anythingllmEnv returns environment variables for AnythingLLM with Docker Model Runner provider.
func anythingllmEnv(baseURL string) []string {
	return []string{
		"STORAGE_DIR=/app/server/storage",
		"LLM_PROVIDER=docker-model-runner",
		"DOCKER_MODEL_RUNNER_BASE_PATH=" + baseURL,
	}
}

// anthropicEnv returns Anthropic-compatible environment variables.
func anthropicEnv(baseURL string) []string {
	return []string{
		"ANTHROPIC_BASE_URL=" + baseURL + "/anthropic",
		"ANTHROPIC_API_KEY=" + dummyAPIKey,
	}
}

func llmfitEnv(baseURL string) []string {
	return []string{
		"DOCKER_MODEL_RUNNER_HOST=" + baseURL,
	}
}

// withEnv returns the current process environment extended with extra vars.
func withEnv(extra ...string) []string {
	return append(os.Environ(), extra...)
}

// runExternal executes a program inheriting stdio.
// Security: prog and progArgs are either hardcoded values or user-provided
// arguments that the user explicitly intends to pass to the launched app.
func runExternal(cmd *cobra.Command, env []string, prog string, progArgs ...string) error {
	c := exec.Command(prog, progArgs...)
	c.Stdout = cmd.OutOrStdout()
	c.Stderr = cmd.ErrOrStderr()
	c.Stdin = os.Stdin
	if env != nil {
		c.Env = env
	}
	if err := c.Run(); err != nil {
		return fmt.Errorf("failed to run %s %s: %w", prog, strings.Join(progArgs, " "), err)
	}
	return nil
}