Handle short/long name resolution

Signed-off-by: Radoslav Dimitrov <radoslav@stacklok.com>

Author: rdimitrov

pkg/registry/provider_base.go

@@ -24,20 +24,62 @@ func NewBaseProvider(getRegistry func() (*types.Registry, error)) *BaseProvider
 	}
 }
 
-// GetServer returns a specific server by name (container or remote)
+// GetServer returns a specific server by name (container or remote).
+// Supports both full reverse-DNS names (io.github.stacklok/osv) and
+// short names (osv) for backward compatibility.
 func (p *BaseProvider) GetServer(name string) (types.ServerMetadata, error) {
 	reg, err := p.GetRegistryFunc()
 	if err != nil {
 		return nil, err
 	}
 
-	// Use the registry's helper method
+	// Try exact match first
 	server, found := reg.GetServerByName(name)
-	if !found {
-		return nil, fmt.Errorf("server not found: %s", name)
+	if found {
+		return server, nil
 	}
 
-	return server, nil
+	// Fall back to short-name matching: check if name matches the last
+	// path component of any server's full reverse-DNS name.
+	// e.g. "osv" matches "io.github.stacklok/osv"
+	if !strings.Contains(name, "/") {
+		matches := findServersByShortName(reg, name)
+		if len(matches) == 1 {
+			return matches[0].server, nil
+		}
+		if len(matches) > 1 {
+			names := make([]string, len(matches))
+			for i, m := range matches {
+				names[i] = m.fullName
+			}
+			return nil, fmt.Errorf("multiple servers match '%s': %s — use the full name",
+				name, strings.Join(names, ", "))
+		}
+	}
+
+	return nil, fmt.Errorf("server not found: %s", name)
+}
+
+type shortNameMatch struct {
+	fullName string
+	server   types.ServerMetadata
+}
+
+// findServersByShortName returns all servers whose name ends with "/<shortName>".
+func findServersByShortName(reg *types.Registry, shortName string) []shortNameMatch {
+	suffix := "/" + shortName
+	var matches []shortNameMatch
+	for fullName, server := range reg.Servers {
+		if strings.HasSuffix(fullName, suffix) {
+			matches = append(matches, shortNameMatch{fullName, server})
+		}
+	}
+	for fullName, server := range reg.RemoteServers {
+		if strings.HasSuffix(fullName, suffix) {
+			matches = append(matches, shortNameMatch{fullName, server})
+		}
+	}
+	return matches
 }
 
 // SearchServers searches for servers matching the query (both container and remote)

pkg/registry/provider_test.go

@@ -460,6 +460,91 @@ func TestRemoteRegistryProvider_UpstreamFormat(t *testing.T) {
 	assert.NotEmpty(t, registry.Servers, "Should have at least one container server")
 }
 
+func TestGetServer_ShortNameResolution(t *testing.T) {
+	t.Parallel()
+
+	// Build a controlled registry with known names
+	reg := &types.Registry{
+		Version:     "1.0.0",
+		LastUpdated: "2025-01-01T00:00:00Z",
+		Servers: map[string]*types.ImageMetadata{
+			"io.github.stacklok/osv":    {BaseServerMetadata: types.BaseServerMetadata{Name: "io.github.stacklok/osv"}, Image: "ghcr.io/osv:latest"},
+			"io.github.stacklok/github": {BaseServerMetadata: types.BaseServerMetadata{Name: "io.github.stacklok/github"}, Image: "ghcr.io/github:latest"},
+			"io.github.acme/github":     {BaseServerMetadata: types.BaseServerMetadata{Name: "io.github.acme/github"}, Image: "ghcr.io/acme-github:latest"},
+		},
+		RemoteServers: map[string]*types.RemoteServerMetadata{
+			"io.github.stacklok/slack-remote": {BaseServerMetadata: types.BaseServerMetadata{Name: "io.github.stacklok/slack-remote"}, URL: "https://slack.example.com"},
+		},
+	}
+
+	provider := &LocalRegistryProvider{}
+	provider.BaseProvider = NewBaseProvider(func() (*types.Registry, error) {
+		return reg, nil
+	})
+
+	tests := []struct {
+		name        string
+		query       string
+		expectName  string
+		expectError string
+	}{
+		{
+			name:       "exact full name match",
+			query:      "io.github.stacklok/osv",
+			expectName: "io.github.stacklok/osv",
+		},
+		{
+			name:       "unique short name match",
+			query:      "osv",
+			expectName: "io.github.stacklok/osv",
+		},
+		{
+			name:        "ambiguous short name errors with full names",
+			query:       "github",
+			expectError: "multiple servers match 'github'",
+		},
+		{
+			name:        "ambiguous error lists both full names",
+			query:       "github",
+			expectError: "io.github.stacklok/github",
+		},
+		{
+			name:        "ambiguous error lists both full names (second)",
+			query:       "github",
+			expectError: "io.github.acme/github",
+		},
+		{
+			name:       "short name for remote server",
+			query:      "slack-remote",
+			expectName: "io.github.stacklok/slack-remote",
+		},
+		{
+			name:        "no match returns not found",
+			query:       "nonexistent",
+			expectError: "server not found: nonexistent",
+		},
+		{
+			name:        "partial name does not match (github-remote suffix check)",
+			query:       "remote",
+			expectError: "server not found: remote",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			server, err := provider.GetServer(tt.query)
+			if tt.expectError != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.expectError)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.expectName, server.GetName())
+		})
+	}
+}
+
 // getTypeName returns the type name of an interface value
 func getTypeName(v interface{}) string {
 	switch v.(type) {
@@ -538,8 +623,8 @@ func TestGetServer(t *testing.T) {
 	provider, err := NewRegistryProvider(cfg)
 	require.NoError(t, err)
 
-	// Test getting an existing server (using upstream reverse-DNS name)
-	server, err := provider.GetServer("io.github.stacklok/osv")
+	// Test getting an existing server (short name resolves via suffix match)
+	server, err := provider.GetServer("osv")
 	if err != nil {
 		t.Fatalf("Failed to get server: %v", err)
 	}

pkg/runner/retriever/retriever_test.go

@@ -128,11 +128,11 @@ func TestGetMCPServer_WithoutGroup(t *testing.T) {
 	// Test that passing empty group name still works (normal behavior)
 	imageURL, serverMetadata, err := GetMCPServer(
 		ctx,
-		"io.github.stacklok/osv", // Use a known server from the registry (upstream reverse-DNS name)
-		"",                       // rawCACertPath
-		VerifyImageDisabled,      // verificationType
-		"",                       // empty groupName should use normal registry lookup
-		nil,                      // no runtime override
+		"osv",               // Use a known server from the registry
+		"",                  // rawCACertPath
+		VerifyImageDisabled, // verificationType
+		"",                  // empty groupName should use normal registry lookup
+		nil,                 // no runtime override
 	)
 
 	// This should work as it's the normal flow