Merge branch 'main' into custom-helm-chart-values-README-update

Author: ChrisJBurns

.github/workflows/verify-docgen.yml

@@ -15,4 +15,6 @@ jobs:
       - uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5
         with:
           go-version-file: go.mod
+      - name: Install swag
+        run: go install github.com/swaggo/swag/v2/cmd/swag@latest
       - run: ./cmd/help/verify.sh

cmd/help/verify.sh

@@ -1,10 +1,18 @@
 #!/usr/bin/env bash
 set -e
 
-# Verify that generated Markdown docs are up-to-date.
+# Verify that generated CLI docs are up-to-date.
 tmpdir=$(mktemp -d)
 go run cmd/help/main.go --dir "$tmpdir"
 diff -Naur -I "^  date:" "$tmpdir" docs/cli/
+
+# Generate API docs in temp directory that mimics the final structure
+api_tmpdir=$(mktemp -d)
+mkdir -p "$api_tmpdir/server"
+swag init -g pkg/api/server.go --v3.1 -o "$api_tmpdir/server"
+# Exclude README.md from diff as it's manually maintained
+diff -Naur --exclude="README.md" "$api_tmpdir/server" docs/server/
+
 echo "######################################################################################"
 echo "If diffs are found, please run: \`task docs\` to regenerate the docs."
 echo "######################################################################################"

cmd/thv/app/mcp.go

@@ -19,6 +19,7 @@ import (
 	"github.com/stacklok/toolhive/pkg/transport/streamable"
 	"github.com/stacklok/toolhive/pkg/transport/types"
 	"github.com/stacklok/toolhive/pkg/versions"
+	"github.com/stacklok/toolhive/pkg/workloads"
 )
 
 var (
@@ -86,7 +87,7 @@ func newMCPCommand() *cobra.Command {
 }
 
 func addMCPFlags(cmd *cobra.Command) {
-	cmd.Flags().StringVar(&mcpServerURL, "server", "", "MCP server URL (required)")
+	cmd.Flags().StringVar(&mcpServerURL, "server", "", "MCP server URL or name from ToolHive registry (required)")
 	cmd.Flags().StringVar(&mcpFormat, "format", FormatText, "Output format (json or text)")
 	cmd.Flags().DurationVar(&mcpTimeout, "timeout", 30*time.Second, "Connection timeout")
 	cmd.Flags().StringVar(&mcpTransport, "transport", "auto", "Transport type (auto, sse, streamable-http)")
@@ -98,7 +99,13 @@ func mcpListCmdFunc(cmd *cobra.Command, _ []string) error {
 	ctx, cancel := context.WithTimeout(cmd.Context(), mcpTimeout)
 	defer cancel()
 
-	mcpClient, err := createMCPClient()
+	// Resolve server URL if it's a name
+	serverURL, err := resolveServerURL(ctx, mcpServerURL)
+	if err != nil {
+		return err
+	}
+
+	mcpClient, err := createMCPClient(serverURL)
 	if err != nil {
 		return err
 	}
@@ -143,7 +150,13 @@ func mcpListToolsCmdFunc(cmd *cobra.Command, _ []string) error {
 	ctx, cancel := context.WithTimeout(cmd.Context(), mcpTimeout)
 	defer cancel()
 
-	mcpClient, err := createMCPClient()
+	// Resolve server URL if it's a name
+	serverURL, err := resolveServerURL(ctx, mcpServerURL)
+	if err != nil {
+		return err
+	}
+
+	mcpClient, err := createMCPClient(serverURL)
 	if err != nil {
 		return err
 	}
@@ -166,7 +179,13 @@ func mcpListResourcesCmdFunc(cmd *cobra.Command, _ []string) error {
 	ctx, cancel := context.WithTimeout(cmd.Context(), mcpTimeout)
 	defer cancel()
 
-	mcpClient, err := createMCPClient()
+	// Resolve server URL if it's a name
+	serverURL, err := resolveServerURL(ctx, mcpServerURL)
+	if err != nil {
+		return err
+	}
+
+	mcpClient, err := createMCPClient(serverURL)
 	if err != nil {
 		return err
 	}
@@ -189,7 +208,13 @@ func mcpListPromptsCmdFunc(cmd *cobra.Command, _ []string) error {
 	ctx, cancel := context.WithTimeout(cmd.Context(), mcpTimeout)
 	defer cancel()
 
-	mcpClient, err := createMCPClient()
+	// Resolve server URL if it's a name
+	serverURL, err := resolveServerURL(ctx, mcpServerURL)
+	if err != nil {
+		return err
+	}
+
+	mcpClient, err := createMCPClient(serverURL)
 	if err != nil {
 		return err
 	}
@@ -207,19 +232,48 @@ func mcpListPromptsCmdFunc(cmd *cobra.Command, _ []string) error {
 	return outputMCPData(map[string]interface{}{"prompts": result.Prompts}, mcpFormat)
 }
 
+// resolveServerURL resolves a server name to a URL or returns the URL if it's already a URL
+func resolveServerURL(ctx context.Context, serverInput string) (string, error) {
+	// Check if it's already a URL
+	if strings.HasPrefix(serverInput, "http://") || strings.HasPrefix(serverInput, "https://") {
+		return serverInput, nil
+	}
+
+	// Try to get the workload by name
+	manager, err := workloads.NewManager(ctx)
+	if err != nil {
+		return "", fmt.Errorf("failed to create workload manager: %w", err)
+	}
+
+	workload, err := manager.GetWorkload(ctx, serverInput)
+	if err != nil {
+		return "", fmt.Errorf(
+			"server '%s' not found in running workloads. "+
+				"Please ensure the server is running or provide a valid URL", serverInput)
+	}
+
+	// Check if the workload is running
+	if workload.Status != "running" {
+		return "", fmt.Errorf("server '%s' is not running (status: %s). "+
+			"Please start it first using 'thv run %s'", serverInput, workload.Status, serverInput)
+	}
+
+	return workload.URL, nil
+}
+
 // createMCPClient creates an MCP client based on the server URL and transport type
-func createMCPClient() (*client.Client, error) {
-	transportType := determineTransportType(mcpServerURL, mcpTransport)
+func createMCPClient(serverURL string) (*client.Client, error) {
+	transportType := determineTransportType(serverURL, mcpTransport)
 
 	switch transportType {
 	case types.TransportTypeSSE:
-		mcpClient, err := client.NewSSEMCPClient(mcpServerURL)
+		mcpClient, err := client.NewSSEMCPClient(serverURL)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create SSE MCP client: %w", err)
 		}
 		return mcpClient, nil
 	case types.TransportTypeStreamableHTTP:
-		mcpClient, err := client.NewStreamableHttpClient(mcpServerURL)
+		mcpClient, err := client.NewStreamableHttpClient(serverURL)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create Streamable HTTP MCP client: %w", err)
 		}

docs/cli/thv_mcp_list.md

@@ -22,21 +22,25 @@ func (m *DefaultGroupMigrator) Migrate(ctx context.Context) error {
 		return fmt.Errorf("failed to initialize managers: %w", err)
 	}
 
-	// Create default group
-	if err := m.createDefaultGroup(ctx); err != nil {
-		return fmt.Errorf("failed to create default group: %w", err)
+	// Create default group if it doesn't exist
+	defaultGroupExists, err := m.groupManager.Exists(ctx, groups.DefaultGroupName)
+	if err != nil {
+		return fmt.Errorf("failed to check if default group exists: %w", err)
+	}
+	if !defaultGroupExists {
+		if err := m.createDefaultGroup(ctx); err != nil {
+			return fmt.Errorf("failed to create default group: %w", err)
+		}
 	}
 
-	// Migrate workloads to default group
+	// Migrate workloads to default group if they don't have a group assigned
 	migratedCount, err := m.migrateWorkloadsToDefaultGroup(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to migrate workloads: %w", err)
 	}
 
 	if migratedCount > 0 {
 		fmt.Printf("\nSuccessfully migrated %d workloads to default group '%s'\n", migratedCount, groups.DefaultGroupName)
-	} else {
-		fmt.Println("No workloads needed migration to default group")
 	}
 
 	// Migrate client configurations from global config to default group
@@ -108,12 +112,10 @@ func (m *DefaultGroupMigrator) migrateClientConfigs(ctx context.Context) error {
 
 	// If there are no registered clients, nothing to migrate
 	if len(appConfig.Clients.RegisteredClients) == 0 {
-		logger.Infof("No client configurations to migrate")
+		logger.Debugf("No client configurations to migrate")
 		return nil
 	}
 
-	fmt.Printf("Migrating %d client configurations to default group...\n", len(appConfig.Clients.RegisteredClients))
-
 	// Get the default group
 	defaultGroup, err := m.groupManager.Get(ctx, groups.DefaultGroupName)
 	if err != nil {
@@ -151,10 +153,10 @@ func (m *DefaultGroupMigrator) migrateClientConfigs(ctx context.Context) error {
 		if err != nil {
 			logger.Warnf("Failed to clear global client configurations after migration: %v", err)
 		} else {
-			logger.Infof("Cleared global client configurations")
+			logger.Debugf("Cleared global client configurations")
 		}
 	} else {
-		logger.Infof("No client configurations needed migration")
+		logger.Debugf("No client configurations needed migration")
 	}
 
 	return nil

docs/cli/thv_mcp_list_prompts.md

@@ -3,10 +3,8 @@ package migration
 
 import (
 	"context"
-	"fmt"
 	"sync"
 
-	"github.com/stacklok/toolhive/pkg/config"
 	"github.com/stacklok/toolhive/pkg/logger"
 )
 
@@ -17,13 +15,6 @@ var migrationOnce sync.Once
 // This is called once at application startup
 func CheckAndPerformDefaultGroupMigration() {
 	migrationOnce.Do(func() {
-		appConfig := config.GetConfig()
-
-		// Check if default group migration has already been performed
-		if appConfig.DefaultGroupMigration {
-			return
-		}
-
 		if err := performDefaultGroupMigration(); err != nil {
 			logger.Errorf("Failed to perform default group migration: %v", err)
 			return
@@ -33,9 +24,6 @@ func CheckAndPerformDefaultGroupMigration() {
 
 // performDefaultGroupMigration migrates all existing workloads to the default group
 func performDefaultGroupMigration() error {
-	fmt.Println("Migrating existing workloads to default group...")
-	fmt.Println()
-
 	migrator := &DefaultGroupMigrator{}
 	return migrator.Migrate(context.Background())
 }