Add support for pypi packages in the registry (#392)

* Add support for pypi packages.

* CR feedback.

* Lint fix.

* Don't allow pypi when importing community registry.

* Independent volumes and long lived.

* Fix version parser. Handle not found on pypi.

* Support hidden `--include-pypi` flag for catalog created from community registry.

* Parse regex once.

* CR fixes.

Author: cmrigney

cmd/docker-mcp/commands/catalog_next.go

@@ -40,6 +40,7 @@ func createCatalogNextCommand() *cobra.Command {
 		FromLegacyCatalog     string
 		FromCommunityRegistry string
 		Servers               []string
+		IncludePyPI           bool
 	}
 
 	cmd := &cobra.Command{
@@ -86,13 +87,17 @@ When using --server without --from-profile, --from-legacy-catalog, or --from-com
 				return fmt.Errorf("only one of --from-profile, --from-legacy-catalog, or --from-community-registry can be specified")
 			}
 
+			if opts.IncludePyPI && opts.FromCommunityRegistry == "" {
+				return fmt.Errorf("--include-pypi can only be used when creating a catalog from a community registry")
+			}
+
 			dao, err := db.New()
 			if err != nil {
 				return err
 			}
 			registryClient := registryapi.NewClient()
 			ociService := oci.NewService()
-			return catalognext.Create(cmd.Context(), dao, registryClient, ociService, args[0], opts.Servers, opts.FromWorkingSet, opts.FromLegacyCatalog, opts.FromCommunityRegistry, opts.Title)
+			return catalognext.Create(cmd.Context(), dao, registryClient, ociService, args[0], opts.Servers, opts.FromWorkingSet, opts.FromLegacyCatalog, opts.FromCommunityRegistry, opts.Title, opts.IncludePyPI)
 		},
 	}
 
@@ -103,6 +108,9 @@ When using --server without --from-profile, --from-legacy-catalog, or --from-com
 	flags.StringVar(&opts.FromCommunityRegistry, "from-community-registry", "", "Community registry hostname to fetch servers from (e.g. registry.modelcontextprotocol.io)")
 	flags.StringVar(&opts.Title, "title", "", "Title of the catalog")
 
+	flags.BoolVar(&opts.IncludePyPI, "include-pypi", false, "Include PyPI servers when creating a catalog from a community registry")
+	cmd.Flags().MarkHidden("include-pypi") //nolint:errcheck
+
 	return cmd
 }
 

pkg/catalog/pypi.go

@@ -0,0 +1,135 @@
+package catalog
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strconv"
+	"time"
+
+	"github.com/docker/mcp-gateway/pkg/desktop"
+)
+
+const (
+	defaultPythonVersion = "3.14"
+	uvBaseImage          = "ghcr.io/astral-sh/uv"
+)
+
+var pythonVersionRe = regexp.MustCompile(`(~=|==|!=|<=|>=|<|>)\s*(\d+)(?:\.(\d+))?`)
+
+// PyPIVersionResolver resolves the minimum Python version for a PyPI package.
+// It returns the minimum Python version string (e.g., "3.10") or empty string if unknown,
+// and a boolean indicating whether the package was found.
+type PyPIVersionResolver func(ctx context.Context, identifier, version, registryBaseURL string) (string, bool)
+
+type pypiPackageInfo struct {
+	Info struct {
+		RequiresPython string `json:"requires_python"`
+	} `json:"info"`
+}
+
+// NewPyPIVersionResolver creates a resolver that queries the PyPI JSON API.
+func NewPyPIVersionResolver(httpClient *http.Client) PyPIVersionResolver {
+	return func(ctx context.Context, identifier, version, registryBaseURL string) (string, bool) {
+		// Only query PyPI for standard PyPI registry
+		if registryBaseURL != "" && registryBaseURL != "https://pypi.org" {
+			return "", true // assume found for non-standard registries
+		}
+
+		var url string
+		if version != "" {
+			url = fmt.Sprintf("https://pypi.org/pypi/%s/%s/json", identifier, version)
+		} else {
+			url = fmt.Sprintf("https://pypi.org/pypi/%s/json", identifier)
+		}
+
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+		if err != nil {
+			return "", false
+		}
+
+		resp, err := httpClient.Do(req)
+		if err != nil {
+			return "", false
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return "", false
+		}
+
+		var info pypiPackageInfo
+		if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
+			return "", false
+		}
+
+		return parsePythonVersion(info.Info.RequiresPython), true
+	}
+}
+
+// DefaultPyPIVersionResolver creates a resolver using the default HTTP client with proxy transport.
+func DefaultPyPIVersionResolver() PyPIVersionResolver {
+	client := &http.Client{
+		Transport: desktop.ProxyTransport(),
+		Timeout:   10 * time.Second,
+	}
+	return NewPyPIVersionResolver(client)
+}
+
+// parsePythonVersion extracts a pinned major.minor Python version from a PEP 440 specifier.
+// Pinning operators (~=, ==, <=, <) resolve to a specific version.
+// >= and > mean "this or newer", so we use the latest.
+// Examples: "~=3.10" -> "3.10", "==3.12" -> "3.12", ">=3.10" -> "" (use latest),
+// "<=3.10" -> "3.10", "<3.10" -> "3.9"
+func parsePythonVersion(requiresPython string) string {
+	if requiresPython == "" {
+		return ""
+	}
+
+	allMatches := pythonVersionRe.FindAllStringSubmatch(requiresPython, -1)
+
+	hasLowerBound := false
+	for _, m := range allMatches {
+		if m[1] == ">=" || m[1] == ">" {
+			hasLowerBound = true
+			break
+		}
+	}
+
+	// Look for pinning constraints; these take priority over lower-bound-only specifiers
+	for _, m := range allMatches {
+		if m[3] == "" {
+			continue // no minor version component, skip
+		}
+		switch m[1] {
+		case "~=", "==", "<=":
+			return fmt.Sprintf("%s.%s", m[2], m[3])
+		case "<":
+			minor, err := strconv.Atoi(m[3])
+			if err != nil || minor <= 0 {
+				continue
+			}
+			return fmt.Sprintf("%s.%d", m[2], minor-1)
+		}
+	}
+
+	// If a lower bound (>= or >) exists but no pinning constraint was found, use latest
+	if hasLowerBound {
+		return ""
+	}
+
+	return ""
+}
+
+// pythonVersionToImageTag maps a Python version to the appropriate uv Docker image tag.
+func pythonVersionToImageTag(pythonVersion string) string {
+	if pythonVersion == "" {
+		pythonVersion = defaultPythonVersion
+	}
+
+	distro := "bookworm-slim"
+
+	return fmt.Sprintf("%s:python%s-%s", uvBaseImage, pythonVersion, distro)
+}

pkg/catalog/pypi_test.go

@@ -0,0 +1,63 @@
+package catalog
+
+import (
+	"testing"
+)
+
+func TestParsePythonVersion(t *testing.T) {
+	tests := []struct {
+		name           string
+		requiresPython string
+		want           string
+	}{
+		{"empty string", "", ""},
+		{"greater than or equal uses latest", ">=3.10", ""},
+		{"greater than or equal with upper bound uses latest", ">=3.10,<4", ""},
+		{"less than or equal uses pinned version", "<=3.10", "3.10"},
+		{"less than uses pinned version below", "<3.10", "3.9"},
+		{"less than with upper bound uses pinned version below", "<3.14,>=3.10", "3.13"},
+		{"less than with upper bound and lower bound uses pinned version below", "<3.13,>=3.12", "3.12"},
+		{"compatible release pins", "~=3.10", "3.10"},
+		{"exact version pins", "==3.12", "3.12"},
+		{"gte with patch uses latest", ">=3.10.2", ""},
+		{"gte with spaces uses latest", ">= 3.10", ""},
+		{"garbage input", "foobar", ""},
+		{"just a number", "3.10", ""},
+		{"greater than only", ">3.10", ""},
+		{"multiple gte constraints uses latest", ">=3.8,!=3.9.0,<4.0", ""},
+		{"compatible release with patch", "~=3.12.1", "3.12"},
+		{"exact with patch", "==3.11.5", "3.11"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parsePythonVersion(tt.requiresPython)
+			if got != tt.want {
+				t.Errorf("parsePythonVersion(%q) = %q, want %q", tt.requiresPython, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestPythonVersionToImageTag(t *testing.T) {
+	tests := []struct {
+		name          string
+		pythonVersion string
+		want          string
+	}{
+		{"empty defaults to bookworm", "", "ghcr.io/astral-sh/uv:python3.14-bookworm-slim"},
+		{"3.10 uses bookworm", "3.10", "ghcr.io/astral-sh/uv:python3.10-bookworm-slim"},
+		{"3.12 uses bookworm", "3.12", "ghcr.io/astral-sh/uv:python3.12-bookworm-slim"},
+		{"3.13 uses bookworm", "3.13", "ghcr.io/astral-sh/uv:python3.13-bookworm-slim"},
+		{"3.14 uses bookworm", "3.14", "ghcr.io/astral-sh/uv:python3.14-bookworm-slim"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := pythonVersionToImageTag(tt.pythonVersion)
+			if got != tt.want {
+				t.Errorf("pythonVersionToImageTag(%q) = %q, want %q", tt.pythonVersion, got, tt.want)
+			}
+		})
+	}
+}