Refactor: use service target tool requirements instead of host assumptions

Per @vhvb1989 feedback: project_manager should not assume which targets
support remoteBuild. Instead, check whether the service target's
RequiredExternalTools actually listed Docker, which respects custom
service targets from extensions.

The suggestRemoteBuild helper now takes svcToolInfo (which services
needed Docker per their target) instead of checking Host.RequiresContainer().

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: spboyer

cli/azd/pkg/project/project_manager.go

@@ -208,6 +208,12 @@ func (pm *projectManager) EnsureFrameworkTools(
 	return nil
 }
 
+// svcToolInfo tracks whether a service's target required Docker.
+type svcToolInfo struct {
+	svc         *ServiceConfig
+	needsDocker bool
+}
+
 func (pm *projectManager) EnsureServiceTargetTools(
 	ctx context.Context,
 	projectConfig *ProjectConfig,
@@ -220,6 +226,8 @@ func (pm *projectManager) EnsureServiceTargetTools(
 		return err
 	}
 
+	var svcTools []svcToolInfo
+
 	for _, svc := range servicesStable {
 		if serviceFilterFn != nil && !serviceFilterFn(svc) {
 			continue
@@ -230,13 +238,22 @@ func (pm *projectManager) EnsureServiceTargetTools(
 			return fmt.Errorf("getting service target: %w", err)
 		}
 
-		serviceTargetTools := serviceTarget.RequiredExternalTools(ctx, svc)
-		requiredTools = append(requiredTools, serviceTargetTools...)
+		targetTools := serviceTarget.RequiredExternalTools(ctx, svc)
+		requiredTools = append(requiredTools, targetTools...)
+
+		needsDocker := false
+		for _, tool := range targetTools {
+			if tool.Name() == "Docker" {
+				needsDocker = true
+				break
+			}
+		}
+		svcTools = append(svcTools, svcToolInfo{svc: svc, needsDocker: needsDocker})
 	}
 
 	if err := tools.EnsureInstalled(ctx, tools.Unique(requiredTools)...); err != nil {
 		if toolErr, ok := errors.AsType[*tools.MissingToolErrors](err); ok {
-			if suggestion := suggestRemoteBuild(servicesStable, toolErr, serviceFilterFn); suggestion != nil {
+			if suggestion := suggestRemoteBuild(svcTools, toolErr); suggestion != nil {
 				return suggestion
 			}
 		}
@@ -246,35 +263,25 @@ func (pm *projectManager) EnsureServiceTargetTools(
 	return nil
 }
 
-// suggestRemoteBuild checks if Docker is in the missing tools list and whether the affected
-// services support remote builds. If so, it returns an ErrorWithSuggestion guiding the user
-// to enable remoteBuild instead of installing Docker locally.
+// suggestRemoteBuild checks if Docker is in the missing tools list and whether any
+// services that required it could use remote builds instead. Only services whose
+// service target actually listed Docker as required are included in the suggestion.
 func suggestRemoteBuild(
-	services []*ServiceConfig,
+	svcTools []svcToolInfo,
 	toolErr *tools.MissingToolErrors,
-	serviceFilterFn ServiceFilterPredicate,
 ) *internal.ErrorWithSuggestion {
 	if !slices.Contains(toolErr.ToolNames, "Docker") {
 		return nil
 	}
 
-	// Find services that actually require Docker/Podman locally and support remote builds.
-	// Exclude services that use dotnet publish (no Docker needed) or already have remoteBuild enabled.
+	// Find services that actually required Docker (per their service target)
+	// and could use remoteBuild instead.
 	var remoteBuildCapable []string
-	for _, svc := range services {
-		if serviceFilterFn != nil && !serviceFilterFn(svc) {
-			continue
-		}
-		if !svc.Host.RequiresContainer() {
-			continue
-		}
-		if svc.Docker.RemoteBuild {
-			continue
-		}
-		if useDotnetPublishForDockerBuild(svc) {
+	for _, info := range svcTools {
+		if !info.needsDocker {
 			continue
 		}
-		remoteBuildCapable = append(remoteBuildCapable, svc.Name)
+		remoteBuildCapable = append(remoteBuildCapable, info.svc.Name)
 	}
 
 	if len(remoteBuildCapable) == 0 {

cli/azd/pkg/project/project_manager_test.go

@@ -27,128 +27,87 @@ func Test_suggestRemoteBuild(t *testing.T) {
 	}
 
 	tests := []struct {
-		name            string
-		services        []*ServiceConfig
-		toolErr         *tools.MissingToolErrors
-		serviceFilterFn ServiceFilterPredicate
-		wantSuggestion  bool
-		wantContains    string
+		name           string
+		svcTools       []svcToolInfo
+		toolErr        *tools.MissingToolErrors
+		wantSuggestion bool
+		wantContains   string
 	}{
 		{
-			name: "ContainerApp_without_remoteBuild_suggests",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
+			name: "Service_needing_Docker_suggests",
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
 			},
 			toolErr:        dockerMissing,
 			wantSuggestion: true,
 			wantContains:   "api",
 		},
-		{
-			name: "AKS_without_remoteBuild_suggests",
-			services: []*ServiceConfig{
-				{Name: "worker", Host: AksTarget},
-			},
-			toolErr:        dockerMissing,
-			wantSuggestion: true,
-			wantContains:   "worker",
-		},
 		{
 			name: "Multiple_services_lists_all",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
-				{Name: "web", Host: ContainerAppTarget},
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
+				{svc: &ServiceConfig{Name: "web"}, needsDocker: true},
 			},
 			toolErr:        dockerMissing,
 			wantSuggestion: true,
 			wantContains:   "api, web",
 		},
 		{
-			name: "ContainerApp_with_remoteBuild_no_suggestion",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget, Docker: DockerProjectOptions{RemoteBuild: true}},
-			},
-			toolErr:        dockerMissing,
-			wantSuggestion: false,
-		},
-		{
-			name: "AppService_no_suggestion",
-			services: []*ServiceConfig{
-				{Name: "web", Host: AppServiceTarget},
+			name: "Service_not_needing_Docker_no_suggestion",
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: false},
 			},
 			toolErr:        dockerMissing,
 			wantSuggestion: false,
 		},
 		{
 			name: "Non_Docker_tool_missing_no_suggestion",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
 			},
 			toolErr:        bicepMissing,
 			wantSuggestion: false,
 		},
 		{
-			name: "Mixed_services_only_suggests_container_targets",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
-				{Name: "web", Host: AppServiceTarget},
-				{Name: "worker", Host: AksTarget},
+			name: "Mixed_services_only_Docker_ones",
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
+				{svc: &ServiceConfig{Name: "web"}, needsDocker: false},
+				{svc: &ServiceConfig{Name: "worker"}, needsDocker: true},
 			},
 			toolErr:        dockerMissing,
 			wantSuggestion: true,
 			wantContains:   "api, worker",
 		},
-		{
-			name: "Service_filter_excludes_service",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
-				{Name: "worker", Host: ContainerAppTarget},
-			},
-			toolErr: dockerMissing,
-			serviceFilterFn: func(svc *ServiceConfig) bool {
-				return svc.Name == "api"
-			},
-			wantSuggestion: true,
-			wantContains:   "api",
-		},
-		{
-			name: "DotNet_without_Dockerfile_no_suggestion",
-			services: func() []*ServiceConfig {
-				useDotNet := true
-				return []*ServiceConfig{
-					{
-						Name:                           "api",
-						Host:                           ContainerAppTarget,
-						Language:                       ServiceLanguageCsharp,
-						useDotNetPublishForDockerBuild: &useDotNet,
-					},
-				}
-			}(),
-			toolErr:        dockerMissing,
-			wantSuggestion: false,
-		},
 		{
 			name: "Docker_not_running_suggests_start",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
 			},
 			toolErr:        dockerNotRunning,
 			wantSuggestion: true,
 			wantContains:   "start your container runtime",
 		},
 		{
 			name: "Docker_not_installed_suggests_install",
-			services: []*ServiceConfig{
-				{Name: "api", Host: ContainerAppTarget},
+			svcTools: []svcToolInfo{
+				{svc: &ServiceConfig{Name: "api"}, needsDocker: true},
 			},
 			toolErr:        dockerMissing,
 			wantSuggestion: true,
 			wantContains:   "install Docker",
 		},
+		{
+			name:           "Empty_services_no_suggestion",
+			svcTools:       []svcToolInfo{},
+			toolErr:        dockerMissing,
+			wantSuggestion: false,
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := suggestRemoteBuild(tt.services, tt.toolErr, tt.serviceFilterFn)
+			result := suggestRemoteBuild(tt.svcTools, tt.toolErr)
 
 			if !tt.wantSuggestion {
 				assert.Nil(t, result)