cmd: ollama launch allow extra params

cmd/config/claude.go

@@ -15,11 +15,15 @@ type Claude struct{}
 
 func (c *Claude) String() string { return "Claude Code" }
 
-func (c *Claude) args(model string) []string {
+func (c *Claude) args(model string, extraArgs []string) []string {
+	var args []string
 	if model != "" {
-		return []string{"--model", model}
+		args = append(args, "--model", model)
 	}
-	return nil
+	if len(extraArgs) > 0 {
+		args = append(args, extraArgs...)
+	}
+	return args
 }
 
 func (c *Claude) findPath() (string, error) {
@@ -41,13 +45,13 @@ func (c *Claude) findPath() (string, error) {
 	return fallback, nil
 }
 
-func (c *Claude) Run(model string) error {
+func (c *Claude) Run(model string, extraArgs []string) error {
 	claudePath, err := c.findPath()
 	if err != nil {
 		return fmt.Errorf("claude is not installed, install from https://code.claude.com/docs/en/quickstart")
 	}
 
-	cmd := exec.Command(claudePath, c.args(model)...)
+	cmd := exec.Command(claudePath, c.args(model, extraArgs)...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr

cmd/config/claude_test.go

@@ -82,19 +82,23 @@ func TestClaudeArgs(t *testing.T) {
 	c := &Claude{}
 
 	tests := []struct {
-		name  string
-		model string
-		want  []string
+		name      string
+		model     string
+		extraArgs []string
+		want      []string
 	}{
-		{"with model", "llama3.2", []string{"--model", "llama3.2"}},
-		{"empty model", "", nil},
+		{"with model", "llama3.2", nil, []string{"--model", "llama3.2"}},
+		{"empty model", "", nil, nil},
+		{"with model and extra args", "llama3.2", []string{"--yolo", "--hi"}, []string{"--model", "llama3.2", "--yolo", "--hi"}},
+		{"empty model with extra args", "", []string{"--help"}, []string{"--help"}},
+		{"multiple extra args", "llama3.2", []string{"--flag1", "--flag2", "value"}, []string{"--model", "llama3.2", "--flag1", "--flag2", "value"}},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := c.args(tt.model)
+			got := c.args(tt.model, tt.extraArgs)
 			if !slices.Equal(got, tt.want) {
-				t.Errorf("args(%q) = %v, want %v", tt.model, got, tt.want)
+				t.Errorf("args(%q, %v) = %v, want %v", tt.model, tt.extraArgs, got, tt.want)
 			}
 		})
 	}

cmd/config/clawdbot.go

@@ -19,7 +19,7 @@ func (c *Clawdbot) String() string { return "Clawdbot" }
 
 const ansiGreen = "\033[32m"
 
-func (c *Clawdbot) Run(model string) error {
+func (c *Clawdbot) Run(model string, extraArgs []string) error {
 	if _, err := exec.LookPath("clawdbot"); err != nil {
 		return fmt.Errorf("clawdbot is not installed, install from https://docs.clawd.bot")
 	}
@@ -32,7 +32,13 @@ func (c *Clawdbot) Run(model string) error {
 		return fmt.Errorf("setup failed: %w", err)
 	}
 
-	cmd := exec.Command("clawdbot", "gateway")
+	// Build args: "gateway" first, then any extra args
+	args := []string{"gateway"}
+	if len(extraArgs) > 0 {
+		args = append(args, extraArgs...)
+	}
+
+	cmd := exec.Command("clawdbot", args...)
 	cmd.Stdin = os.Stdin
 
 	// Capture output to detect "already running" message

cmd/config/codex.go

@@ -14,20 +14,23 @@ type Codex struct{}
 
 func (c *Codex) String() string { return "Codex" }
 
-func (c *Codex) args(model string) []string {
+func (c *Codex) args(model string, extraArgs []string) []string {
 	args := []string{"--oss"}
 	if model != "" {
 		args = append(args, "-m", model)
 	}
+	if len(extraArgs) > 0 {
+		args = append(args, extraArgs...)
+	}
 	return args
 }
 
-func (c *Codex) Run(model string) error {
+func (c *Codex) Run(model string, extraArgs []string) error {
 	if err := checkCodexVersion(); err != nil {
 		return err
 	}
 
-	cmd := exec.Command("codex", c.args(model)...)
+	cmd := exec.Command("codex", c.args(model, extraArgs)...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr

cmd/config/codex_test.go

@@ -9,19 +9,22 @@ func TestCodexArgs(t *testing.T) {
 	c := &Codex{}
 
 	tests := []struct {
-		name  string
-		model string
-		want  []string
+		name      string
+		model     string
+		extraArgs []string
+		want      []string
 	}{
-		{"with model", "llama3.2", []string{"--oss", "-m", "llama3.2"}},
-		{"empty model", "", []string{"--oss"}},
+		{"with model", "llama3.2", nil, []string{"--oss", "-m", "llama3.2"}},
+		{"empty model", "", nil, []string{"--oss"}},
+		{"with model and extra args", "qwen3-coder", []string{"--yolo"}, []string{"--oss", "-m", "qwen3-coder", "--yolo"}},
+		{"empty model with extra args", "", []string{"--help"}, []string{"--oss", "--help"}},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := c.args(tt.model)
+			got := c.args(tt.model, tt.extraArgs)
 			if !slices.Equal(got, tt.want) {
-				t.Errorf("args(%q) = %v, want %v", tt.model, got, tt.want)
+				t.Errorf("args(%q, %v) = %v, want %v", tt.model, tt.extraArgs, got, tt.want)
 			}
 		})
 	}

cmd/config/droid.go

@@ -39,7 +39,7 @@ type modelEntry struct {
 
 func (d *Droid) String() string { return "Droid" }
 
-func (d *Droid) Run(model string) error {
+func (d *Droid) Run(model string, extraArgs []string) error {
 	if _, err := exec.LookPath("droid"); err != nil {
 		return fmt.Errorf("droid is not installed, install from https://docs.factory.ai/cli/getting-started/quickstart")
 	}
@@ -53,7 +53,7 @@ func (d *Droid) Run(model string) error {
 		return fmt.Errorf("setup failed: %w", err)
 	}
 
-	cmd := exec.Command("droid")
+	cmd := exec.Command("droid", extraArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr

cmd/config/integrations.go

@@ -22,7 +22,7 @@ import (
 // Runner can run an integration with a model.
 
 type Runner interface {
-	Run(model string) error
+	Run(model string, extraArgs []string) error
 	// String returns the human-readable name of the integration
 	String() string
 }
@@ -222,13 +222,13 @@ func selectModels(ctx context.Context, name, current string) ([]string, error) {
 	return selected, nil
 }
 
-func runIntegration(name, modelName string) error {
+func runIntegration(name, modelName string, extraArgs []string) error {
 	r, ok := integrations[name]
 	if !ok {
 		return fmt.Errorf("unknown integration: %s", name)
 	}
 	fmt.Fprintf(os.Stderr, "\nLaunching %s with %s...\n", r, modelName)
-	return r.Run(modelName)
+	return r.Run(modelName, extraArgs)
 }
 
 // LaunchCmd returns the cobra command for launching integrations.
@@ -237,7 +237,7 @@ func LaunchCmd(checkServerHeartbeat func(cmd *cobra.Command, args []string) erro
 	var configFlag bool
 
 	cmd := &cobra.Command{
-		Use:   "launch [INTEGRATION]",
+		Use:   "launch [INTEGRATION] [-- [EXTRA_ARGS...]]",
 		Short: "Launch an integration with Ollama",
 		Long: `Launch an integration configured with Ollama models.
 
@@ -252,13 +252,17 @@ Examples:
   ollama launch
   ollama launch claude
   ollama launch claude --model <model>
-  ollama launch droid --config (does not auto-launch)`,
-		Args:    cobra.MaximumNArgs(1),
+  ollama launch droid --config (does not auto-launch)
+  ollama launch claude -- --yolo --hi (pass extra args to integration)`,
+		Args:    cobra.ArbitraryArgs,
 		PreRunE: checkServerHeartbeat,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			// Extract integration name and pass through remaining args
 			var name string
+			var extraArgs []string
 			if len(args) > 0 {
 				name = args[0]
+				extraArgs = args[1:]
 			} else {
 				var err error
 				name, err = selectIntegration()
@@ -278,7 +282,7 @@ Examples:
 			// If launching without --model, use saved config if available
 			if !configFlag && modelFlag == "" {
 				if config, err := loadIntegration(name); err == nil && len(config.Models) > 0 {
-					return runIntegration(name, config.Models[0])
+					return runIntegration(name, config.Models[0], extraArgs)
 				}
 			}
 
@@ -339,13 +343,13 @@ Examples:
 
 			if configFlag {
 				if launch, _ := confirmPrompt(fmt.Sprintf("\nLaunch %s now?", r)); launch {
-					return runIntegration(name, models[0])
+					return runIntegration(name, models[0], extraArgs)
 				}
 				fmt.Fprintf(os.Stderr, "Run 'ollama launch %s' to start with %s\n", strings.ToLower(name), models[0])
 				return nil
 			}
 
-			return runIntegration(name, models[0])
+			return runIntegration(name, models[0], extraArgs)
 		},
 	}
 

cmd/config/integrations_test.go

@@ -90,8 +90,8 @@ func TestLaunchCmd(t *testing.T) {
 	cmd := LaunchCmd(mockCheck)
 
 	t.Run("command structure", func(t *testing.T) {
-		if cmd.Use != "launch [INTEGRATION]" {
-			t.Errorf("Use = %q, want %q", cmd.Use, "launch [INTEGRATION]")
+		if cmd.Use != "launch [INTEGRATION] [-- [EXTRA_ARGS...]]" {
+			t.Errorf("Use = %q, want %q", cmd.Use, "launch [INTEGRATION] [-- [EXTRA_ARGS...]]")
 		}
 		if cmd.Short == "" {
 			t.Error("Short description should not be empty")
@@ -121,7 +121,7 @@ func TestLaunchCmd(t *testing.T) {
 }
 
 func TestRunIntegration_UnknownIntegration(t *testing.T) {
-	err := runIntegration("unknown-integration", "model")
+	err := runIntegration("unknown-integration", "model", nil)
 	if err == nil {
 		t.Error("expected error for unknown integration, got nil")
 	}
@@ -182,7 +182,69 @@ func TestAllIntegrations_HaveRequiredMethods(t *testing.T) {
 
 			// Test Run() exists (we can't call it without actually running the command)
 			// Just verify the method is available
-			var _ func(string) error = r.Run
+			var _ func(string, []string) error = r.Run
+		})
+	}
+}
+
+func TestParseExtraArgs(t *testing.T) {
+	tests := []struct {
+		name          string
+		args          []string
+		wantArgs      []string
+		wantExtraArgs []string
+	}{
+		{
+			name:          "no extra args",
+			args:          []string{"claude"},
+			wantArgs:      []string{"claude"},
+			wantExtraArgs: nil,
+		},
+		{
+			name:          "with extra args after --",
+			args:          []string{"claude", "--", "--yolo", "--hi"},
+			wantArgs:      []string{"claude"},
+			wantExtraArgs: []string{"--yolo", "--hi"},
+		},
+		{
+			name:          "extra args only after --",
+			args:          []string{"codex", "--", "--help"},
+			wantArgs:      []string{"codex"},
+			wantExtraArgs: []string{"--help"},
+		},
+		{
+			name:          "-- at end with no args after",
+			args:          []string{"claude", "--"},
+			wantArgs:      []string{"claude", "--"},
+			wantExtraArgs: nil,
+		},
+		{
+			name:          "multiple args after --",
+			args:          []string{"claude", "--", "--flag1", "--flag2", "value", "--flag3"},
+			wantArgs:      []string{"claude"},
+			wantExtraArgs: []string{"--flag1", "--flag2", "value", "--flag3"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Simulate the parsing logic from LaunchCmd
+			args := tt.args
+			var extraArgs []string
+			for i, arg := range args {
+				if arg == "--" && i < len(args)-1 {
+					extraArgs = args[i+1:]
+					args = args[:i]
+					break
+				}
+			}
+
+			if !slices.Equal(args, tt.wantArgs) {
+				t.Errorf("args = %v, want %v", args, tt.wantArgs)
+			}
+			if !slices.Equal(extraArgs, tt.wantExtraArgs) {
+				t.Errorf("extraArgs = %v, want %v", extraArgs, tt.wantExtraArgs)
+			}
 		})
 	}
 }

cmd/config/opencode.go

@@ -18,7 +18,7 @@ type OpenCode struct{}
 
 func (o *OpenCode) String() string { return "OpenCode" }
 
-func (o *OpenCode) Run(model string) error {
+func (o *OpenCode) Run(model string, extraArgs []string) error {
 	if _, err := exec.LookPath("opencode"); err != nil {
 		return fmt.Errorf("opencode is not installed, install from https://opencode.ai")
 	}
@@ -32,7 +32,7 @@ func (o *OpenCode) Run(model string) error {
 		return fmt.Errorf("setup failed: %w", err)
 	}
 
-	cmd := exec.Command("opencode")
+	cmd := exec.Command("opencode", extraArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr