remove the --remote flag while running remote server for better user experience (#1517)

Author: amirejaz

cmd/thv/app/run.go

@@ -8,6 +8,7 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 
@@ -17,6 +18,7 @@ import (
 	"github.com/stacklok/toolhive/pkg/container/runtime"
 	"github.com/stacklok/toolhive/pkg/groups"
 	"github.com/stacklok/toolhive/pkg/logger"
+	"github.com/stacklok/toolhive/pkg/networking"
 	"github.com/stacklok/toolhive/pkg/process"
 	"github.com/stacklok/toolhive/pkg/runner"
 	"github.com/stacklok/toolhive/pkg/workloads"
@@ -62,7 +64,7 @@ ToolHive supports five ways to run an MCP server:
 
 5. Remote MCP server:
 
-	   $ thv run --remote <URL> [--name <name>]
+	   $ thv run <URL> [--name <name>]
 
    Runs a remote MCP server as a workload, proxying requests to the specified URL.
    This allows remote MCP servers to be managed like local workloads with full
@@ -75,10 +77,6 @@ permission profile. Additional configuration can be provided via flags.`,
 		if runFlags.FromConfig != "" {
 			return nil
 		}
-		// If --remote is provided, no args are required
-		if runFlags.RemoteURL != "" {
-			return nil
-		}
 		// Otherwise, require at least 1 argument
 		return cobra.MinimumNArgs(1)(cmd, args)
 	},
@@ -127,6 +125,7 @@ func cleanupAndWait(workloadManager workloads.Manager, name string, cancel conte
 	}
 }
 
+// nolint:gocyclo // This function is complex by design
 func runCmdFunc(cmd *cobra.Command, args []string) error {
 	ctx := cmd.Context()
 
@@ -136,21 +135,23 @@ func runCmdFunc(cmd *cobra.Command, args []string) error {
 	}
 
 	// Get the name of the MCP server to run.
-	// This may be a server name from the registry, a container image, or a protocol scheme.
-	// When using --from-config or --remote, no args are required
+	// This may be a server name from the registry, a container image, a protocol scheme, or a remote URL.
 	var serverOrImage string
 	if len(args) > 0 {
 		serverOrImage = args[0]
 	}
 
-	// If --remote is provided but no name is given, generate a name from the URL
-	if runFlags.RemoteURL != "" && runFlags.Name == "" {
-		// Extract a name from the remote URL
-		name, err := deriveRemoteName()
-		if err != nil {
-			return err
+	// Check if the server name is actually a URL (remote server)
+	if serverOrImage != "" && networking.IsURL(serverOrImage) {
+		runFlags.RemoteURL = serverOrImage
+		// If no name is given, generate a name from the URL
+		if runFlags.Name == "" {
+			name, err := deriveRemoteName(serverOrImage)
+			if err != nil {
+				return err
+			}
+			runFlags.Name = name
 		}
-		runFlags.Name = name
 	}
 
 	// Process command arguments using os.Args to find everything after --
@@ -205,17 +206,26 @@ func runCmdFunc(cmd *cobra.Command, args []string) error {
 	return workloadManager.RunWorkloadDetached(ctx, runnerConfig)
 }
 
-func deriveRemoteName() (string, error) {
-	parsedURL, err := url.Parse(runFlags.RemoteURL)
+// deriveRemoteName extracts a name from a remote URL
+func deriveRemoteName(remoteURL string) (string, error) {
+	parsedURL, err := url.Parse(remoteURL)
 	if err != nil {
-		return "", fmt.Errorf("invalid remote URL: %v", err)
+		return "", fmt.Errorf("invalid remote URL: %w", err)
 	}
+
 	// Use the hostname as the base name
 	hostname := parsedURL.Hostname()
 	if hostname == "" {
-		hostname = "remote"
+		return "", fmt.Errorf("could not extract hostname from URL: %s", remoteURL)
 	}
-	return fmt.Sprintf("%s-remote", hostname), nil
+
+	// Remove common TLDs and use the main domain name
+	parts := strings.Split(hostname, ".")
+	if len(parts) >= 2 {
+		return parts[len(parts)-2], nil
+	}
+
+	return hostname, nil
 }
 
 func runForeground(ctx context.Context, workloadManager workloads.Manager, runnerConfig *runner.RunConfig) error {

cmd/thv/app/run_flags.go

@@ -146,7 +146,6 @@ func AddRunFlags(cmd *cobra.Command, config *RunFlags) {
 		[]string{},
 		"Specify a secret to be fetched from the secrets manager and set as an environment variable (format: NAME,target=TARGET)",
 	)
-	cmd.Flags().StringVar(&config.RemoteURL, "remote", "", "URL of remote MCP server to run as a workload")
 	cmd.Flags().StringVar(&config.AuthzConfig, "authz-config", "", "Path to the authorization configuration file")
 	cmd.Flags().StringVar(&config.AuditConfig, "audit-config", "", "Path to the audit configuration file")
 	cmd.Flags().BoolVar(&config.EnableAudit, "enable-audit", false, "Enable audit logging with default configuration")

cmd/thv/app/run_test.go

@@ -0,0 +1,63 @@
+package app
+
+import (
+	"testing"
+)
+
+func TestDeriveRemoteName(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name     string
+		url      string
+		expected string
+		wantErr  bool
+	}{
+		{
+			name:     "api.github.com should return github",
+			url:      "https://api.github.com",
+			expected: "github",
+			wantErr:  false,
+		},
+		{
+			name:     "github.com should return github",
+			url:      "https://github.com",
+			expected: "github",
+			wantErr:  false,
+		},
+		{
+			name:     "invalid URL should return error",
+			url:      "not-a-url",
+			expected: "",
+			wantErr:  true,
+		},
+		{
+			name:     "empty URL should return error",
+			url:      "",
+			expected: "",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := deriveRemoteName(tt.url)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("deriveRemoteName() expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("deriveRemoteName() unexpected error: %v", err)
+				return
+			}
+
+			if got != tt.expected {
+				t.Errorf("deriveRemoteName() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}