Merge pull request #242 from docker/refactor-servers-filtering

refactor: servers to server ls

Author: bobbyhouse

cmd/docker-mcp/commands/workingset.go

@@ -23,7 +23,6 @@ func workingSetCommand() *cobra.Command {
 	cmd.AddCommand(importWorkingSetCommand())
 	cmd.AddCommand(showWorkingSetCommand())
 	cmd.AddCommand(listWorkingSetsCommand())
-	cmd.AddCommand(serversCommand())
 	cmd.AddCommand(pushWorkingSetCommand())
 	cmd.AddCommand(pullWorkingSetCommand())
 	cmd.AddCommand(createWorkingSetCommand())
@@ -299,34 +298,34 @@ func removeWorkingSetCommand() *cobra.Command {
 	}
 }
 
-func serversCommand() *cobra.Command {
+func listServersCommand() *cobra.Command {
 	var opts struct {
-		WorkingSetID string
-		Filter       string
-		Format       string
+		Filters []string
+		Format  string
 	}
 
 	cmd := &cobra.Command{
-		Use:   "servers",
-		Short: "List servers across profiles",
+		Use:     "ls",
+		Aliases: []string{"list"},
+		Short:   "List servers across profiles",
 		Long: `List all servers grouped by profile.
 
-Use --filter to search for servers matching a query (case-insensitive substring matching on image names or source URLs).
-Use --profile to show servers only from a specific profile.`,
+Use --filter to search for servers matching a query (case-insensitive substring matching on server names).
+Filters use key=value format (e.g., name=github, profile=my-dev-env).`,
 		Example: `  # List all servers across all profiles
-  docker mcp profile servers
+  docker mcp profile server ls
 
   # Filter servers by name
-  docker mcp profile servers --filter github
+  docker mcp profile server ls --filter name=github
 
   # Show servers from a specific profile
-  docker mcp profile servers --profile dev-tools
+  docker mcp profile server ls --filter profile=my-dev-env
 
-  # Combine filter and profile
-  docker mcp profile servers --profile dev-tools --filter slack
+  # Combine multiple filters (using short flag)
+  docker mcp profile server ls -f name=slack -f profile=my-dev-env
 
   # Output in JSON format
-  docker mcp profile servers --format json`,
+  docker mcp profile server ls --format json`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			supported := slices.Contains(workingset.SupportedFormats(), opts.Format)
@@ -339,13 +338,12 @@ Use --profile to show servers only from a specific profile.`,
 				return err
 			}
 
-			return workingset.Servers(cmd.Context(), dao, opts.Filter, opts.WorkingSetID, workingset.OutputFormat(opts.Format))
+			return workingset.ListServers(cmd.Context(), dao, opts.Filters, workingset.OutputFormat(opts.Format))
 		},
 	}
 
 	flags := cmd.Flags()
-	flags.StringVarP(&opts.WorkingSetID, "profile", "p", "", "Show servers only from specified profile")
-	flags.StringVar(&opts.Filter, "filter", "", "Filter servers by image name or source URL")
+	flags.StringArrayVarP(&opts.Filters, "filter", "f", []string{}, "Filter output (e.g., name=github, profile=my-dev-env)")
 	flags.StringVar(&opts.Format, "format", string(workingset.OutputFormatHumanReadable), fmt.Sprintf("Supported: %s.", strings.Join(workingset.SupportedFormats(), ", ")))
 
 	return cmd
@@ -357,6 +355,7 @@ func workingsetServerCommand() *cobra.Command {
 		Short: "Manage servers in profiles",
 	}
 
+	cmd.AddCommand(listServersCommand())
 	cmd.AddCommand(addServerCommand())
 	cmd.AddCommand(removeServerCommand())
 

cmd/docker-mcp/secret-management/formatting/table.go

@@ -10,35 +10,59 @@ import (
 // PrettyPrintTable prints a table (slice of rows, each a slice of string)
 // maxWidths is an optional slice of maximum widths for each column.
 // Pass nil (or a slice of different length) to skip max-width limitations.
-func PrettyPrintTable(rows [][]string, maxWidths []int) {
-	if len(rows) == 0 {
+func PrettyPrintTable(rows [][]string, maxWidths []int, header ...[]string) {
+	var headerRow []string
+	if len(header) > 0 {
+		headerRow = header[0]
+	}
+
+	if len(rows) == 0 && headerRow == nil {
+		return
+	}
+
+	numColumns := 0
+	if headerRow != nil {
+		numColumns = len(headerRow)
+	} else if len(rows) > 0 {
+		numColumns = len(rows[0])
+	}
+
+	if numColumns == 0 {
 		return
 	}
 	// Sort rows by the first column.
 	sort.Slice(rows, func(i, j int) bool {
 		return strings.ToLower(rows[i][0]) < strings.ToLower(rows[j][0])
 	})
-	numColumns := len(rows[0])
 	colWidths := make([]int, numColumns)
 
+	for i, cell := range headerRow {
+		if w := runeWidth(cell); w > colWidths[i] {
+			colWidths[i] = w
+		}
+	}
+
 	for _, row := range rows {
 		for i, cell := range row {
-			if w := runeWidth(cell); w > colWidths[i] {
-				colWidths[i] = w
+			if i < numColumns {
+				if w := runeWidth(cell); w > colWidths[i] {
+					colWidths[i] = w
+				}
 			}
 		}
 	}
-
 	// If provided, limit the width per column.
 	if maxWidths != nil && len(maxWidths) == numColumns {
 		for i := range colWidths {
 			colWidths[i] = intMin(colWidths[i], maxWidths[i])
 		}
 	}
 
-	// Print each row with proper padding and truncation.
-	for _, row := range rows {
+	printRow := func(row []string) {
 		for i, cell := range row {
+			if i >= numColumns {
+				break
+			}
 			// Truncate the cell to the allowed width.
 			s := truncateString(cell, colWidths[i])
 			// Pad the cell so that each column aligns.
@@ -50,6 +74,12 @@ func PrettyPrintTable(rows [][]string, maxWidths []int) {
 		}
 		fmt.Println()
 	}
+	if headerRow != nil {
+		printRow(headerRow)
+	}
+	for _, row := range rows {
+		printRow(row)
+	}
 }
 
 func intMin(a, b int) int {

pkg/workingset/server.go

@@ -3,12 +3,17 @@ package workingset
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"slices"
+	"sort"
+	"strings"
 
 	"github.com/google/go-containerregistry/pkg/name"
+	"gopkg.in/yaml.v3"
 
+	"github.com/docker/mcp-gateway/cmd/docker-mcp/secret-management/formatting"
 	"github.com/docker/mcp-gateway/pkg/db"
 	"github.com/docker/mcp-gateway/pkg/oci"
 	"github.com/docker/mcp-gateway/pkg/registryapi"
@@ -161,3 +166,141 @@ func mapCatalogServersToWorkingSetServers(dbServers []db.CatalogServer, defaultS
 	}
 	return servers
 }
+
+type SearchResult struct {
+	ID      string   `json:"id" yaml:"id"`
+	Name    string   `json:"name" yaml:"name"`
+	Servers []Server `json:"servers" yaml:"servers"`
+}
+
+type serverFilter struct {
+	key   string
+	value string
+}
+
+func ListServers(ctx context.Context, dao db.DAO, filters []string, format OutputFormat) error {
+	parsedFilters, err := parseFilters(filters)
+	if err != nil {
+		return err
+	}
+
+	var nameFilter string
+	var workingSetFilter string
+	for _, filter := range parsedFilters {
+		switch filter.key {
+		case "name":
+			nameFilter = filter.value
+		case "profile":
+			workingSetFilter = filter.value
+		default:
+			return fmt.Errorf("unsupported filter key: %s", filter.key)
+		}
+	}
+	dbSets, err := dao.SearchWorkingSets(ctx, "", workingSetFilter)
+	if err != nil {
+		return fmt.Errorf("failed to search profiles: %w", err)
+	}
+	results := buildSearchResults(dbSets, nameFilter)
+	return outputSearchResults(results, format)
+}
+
+func parseFilters(filters []string) ([]serverFilter, error) {
+	parsed := make([]serverFilter, 0, len(filters))
+	for _, filter := range filters {
+		parts := strings.SplitN(filter, "=", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid filter format: %s (expected key=value)", filter)
+		}
+		parsed = append(parsed, serverFilter{
+			key:   parts[0],
+			value: parts[1],
+		})
+	}
+	return parsed, nil
+}
+
+func buildSearchResults(dbSets []db.WorkingSet, nameFilter string) []SearchResult {
+	nameLower := strings.ToLower(nameFilter)
+	results := make([]SearchResult, 0, len(dbSets))
+
+	for _, dbSet := range dbSets {
+		workingSet := NewFromDb(&dbSet)
+		matchedServers := make([]Server, 0)
+
+		for _, server := range workingSet.Servers {
+			if matchesNameFilter(server, nameLower) {
+				matchedServers = append(matchedServers, server)
+			}
+		}
+		if len(matchedServers) == 0 {
+			continue
+		}
+		sort.Slice(matchedServers, func(i, j int) bool {
+			return matchedServers[i].Snapshot.Server.Name < matchedServers[j].Snapshot.Server.Name
+		})
+		results = append(results, SearchResult{
+			ID:      workingSet.ID,
+			Name:    workingSet.Name,
+			Servers: matchedServers,
+		})
+	}
+	return results
+}
+
+func matchesNameFilter(server Server, nameLower string) bool {
+	// TODO: Remove when Snapshot is required
+	if server.Snapshot == nil {
+		return false
+	}
+	if nameLower == "" {
+		return true
+	}
+	serverName := strings.ToLower(server.Snapshot.Server.Name)
+	return strings.Contains(serverName, nameLower)
+}
+
+func outputSearchResults(results []SearchResult, format OutputFormat) error {
+	var data []byte
+	var err error
+
+	switch format {
+	case OutputFormatHumanReadable:
+		printSearchResultsHuman(results)
+		return nil
+	case OutputFormatJSON:
+		data, err = json.MarshalIndent(results, "", "  ")
+	case OutputFormatYAML:
+		data, err = yaml.Marshal(results)
+	default:
+		return fmt.Errorf("unsupported format: %s", format)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to format search results: %w", err)
+	}
+
+	fmt.Println(string(data))
+	return nil
+}
+
+func printSearchResultsHuman(results []SearchResult) {
+	if len(results) == 0 {
+		fmt.Println("No profiles found")
+		return
+	}
+
+	rows := [][]string{}
+
+	for _, result := range results {
+		for _, server := range result.Servers {
+			rows = append(rows, []string{
+				result.ID,
+				string(server.Type),
+				server.Snapshot.Server.Name,
+			})
+		}
+	}
+
+	header := []string{"PROFILE", "TYPE", "IDENTIFIER"}
+	formatting.PrettyPrintTable(rows, []int{40, 10, 120}, header)
+}