microsoft
diff --git a/‎internal/app/azldev/cmds/component/build.go‎
Lines changed: 110 additions & 2 deletions b/‎internal/app/azldev/cmds/component/build.go‎
Lines changed: 110 additions & 2 deletions
diff --git a/‎internal/app/azldev/cmds/component/build_test.go‎
Lines changed: 46 additions & 0 deletions b/‎internal/app/azldev/cmds/component/build_test.go‎
Lines changed: 46 additions & 0 deletions
diff --git a/‎internal/utils/fileutils/file.go‎
Lines changed: 7 additions & 0 deletions b/‎internal/utils/fileutils/file.go‎
Lines changed: 7 additions & 0 deletions
@@ -6,6 +6,7 @@ package component
 import (
 	"errors"
 	"fmt"
+	"path/filepath"
 
 	"github.com/gim-home/azldev-preview/internal/app/azldev"
 	"github.com/gim-home/azldev-preview/internal/app/azldev/core/componentbuilder"
@@ -16,6 +17,7 @@ import (
 	"github.com/gim-home/azldev-preview/internal/providers/sourceproviders"
 	"github.com/gim-home/azldev-preview/internal/utils/defers"
 	"github.com/gim-home/azldev-preview/internal/utils/fileutils"
+	"github.com/gim-home/azldev-preview/internal/utils/localrepo"
 	"github.com/spf13/cobra"
 )
 
@@ -27,7 +29,8 @@ type ComponentBuildOptions struct {
 	SourcePackageOnly bool
 	BuildEnvPolicy    BuildEnvPreservePolicy
 
-	LocalRepoPaths []string
+	LocalRepoPaths           []string
+	LocalRepoWithPublishPath string
 }
 
 // ComponentBuildResults summarizes the results of building a single component.
@@ -76,12 +79,22 @@ func NewBuildCmd() *cobra.Command {
 		))
 	cmd.Flags().StringArrayVar(&options.LocalRepoPaths, "local-repo", []string{},
 		"Paths to local repositories to include during build (can be specified multiple times)")
+	cmd.Flags().StringVar(&options.LocalRepoWithPublishPath, "local-repo-with-publish", "",
+		"Path to local repository to include during build and publish built RPMs to")
+
+	// Mark flags as mutually exclusive.
+	cmd.MarkFlagsMutuallyExclusive("srpm-only", "local-repo-with-publish")
 
 	return cmd
 }
 
 func SelectAndBuildComponents(env *azldev.Env, options *ComponentBuildOptions,
 ) ([]ComponentBuildResults, error) {
+	// Validate options before doing any work.
+	if err := validateBuildOptions(env, options); err != nil {
+		return nil, err
+	}
+
 	var comps *components.ComponentSet
 
 	resolver := components.NewResolver(env)
@@ -173,9 +186,22 @@ func BuildComponent(
 
 	builder := componentbuilder.New(env, env.FS(), env, sourcePreparer, buildEnv, workDirFactory)
 
-	return buildComponentUsingBuilder(env, component, builder, options.LocalRepoPaths,
+	// Combine both local repo paths for use during build (both are used as dependencies).
+	allLocalRepoPaths := append([]string{}, options.LocalRepoPaths...)
+	if options.LocalRepoWithPublishPath != "" {
+		allLocalRepoPaths = append(allLocalRepoPaths, options.LocalRepoWithPublishPath)
+	}
+
+	results, err = buildComponentUsingBuilder(
+		env, component, builder, allLocalRepoPaths,
 		options.SourcePackageOnly, options.RunChecks,
+		options.LocalRepoWithPublishPath,
 	)
+	if err != nil {
+		return results, err
+	}
+
+	return results, nil
 }
 
 func buildComponentUsingBuilder(
@@ -184,6 +210,7 @@ func buildComponentUsingBuilder(
 	builder *componentbuilder.Builder,
 	localRepoPaths []string,
 	sourcePackageOnly, runChecks bool,
+	localRepoWithPublishPath string,
 ) (results ComponentBuildResults, err error) {
 	// Compose the path to the output dir.
 	outputDir := env.OutputDir()
@@ -227,5 +254,86 @@ func buildComponentUsingBuilder(
 		return results, fmt.Errorf("failed to build RPM for %q: %w", component.GetName(), err)
 	}
 
+	// Publish built RPMs to local repo with publish enabled.
+	if localRepoWithPublishPath != "" && len(results.RPMPaths) > 0 {
+		publishErr := publishToLocalRepo(env, results.RPMPaths, localRepoWithPublishPath)
+		if publishErr != nil {
+			return results, fmt.Errorf("failed to publish RPMs for %q:\n%w", component.GetName(), publishErr)
+		}
+	}
+
 	return results, nil
 }
+
+// validateBuildOptions validates the build options before any work is done.
+func validateBuildOptions(env *azldev.Env, options *ComponentBuildOptions) error {
+	// Check for overlap between --local-repo and --local-repo-with-publish.
+	// (Check config errors before tool availability for better UX.)
+	if err := checkLocalRepoPathOverlap(options.LocalRepoPaths, options.LocalRepoWithPublishPath); err != nil {
+		return err
+	}
+
+	// If we have a repo to publish to, create and initialize it.
+	// This checks for createrepo_c availability and initializes the repo metadata
+	// so it can be used as a dependency source during builds.
+	if options.LocalRepoWithPublishPath != "" {
+		_, err := localrepo.NewPublisher(env, options.LocalRepoWithPublishPath, true)
+		if err != nil {
+			return fmt.Errorf("failed to initialize publish repository:\n%w", err)
+		}
+	}
+
+	return nil
+}
+
+// checkLocalRepoPathOverlap checks that the path doesn't appear in both --local-repo and --local-repo-with-publish.
+func checkLocalRepoPathOverlap(localRepoPaths []string, localRepoWithPublishPath string) error {
+	// If no publish path is specified, there's no overlap.
+	if localRepoWithPublishPath == "" {
+		return nil
+	}
+
+	// Normalize the publish path for comparison.
+	absPublishPath, err := filepath.Abs(localRepoWithPublishPath)
+	if err != nil {
+		return fmt.Errorf("failed to resolve absolute path for %#q:\n%w", localRepoWithPublishPath, err)
+	}
+
+	// Check if the publish path appears in local repo paths.
+	for _, repoPath := range localRepoPaths {
+		absPath, err := filepath.Abs(repoPath)
+		if err != nil {
+			return fmt.Errorf("failed to resolve absolute path for %#q:\n%w", repoPath, err)
+		}
+
+		if absPath == absPublishPath {
+			return fmt.Errorf(
+				"path %#q appears in both --local-repo and --local-repo-with-publish; "+
+					"use --local-repo-with-publish only for repos you want to both read from and publish to",
+				localRepoWithPublishPath,
+			)
+		}
+	}
+
+	return nil
+}
+
+// publishToLocalRepo publishes the given RPMs to the specified local repo.
+func publishToLocalRepo(env *azldev.Env, rpmPaths []string, repoPath string) error {
+	publisher, err := localrepo.NewPublisher(env, repoPath, false)
+	if err != nil {
+		return fmt.Errorf("failed to create publisher for %#q:\n%w", repoPath, err)
+	}
+
+	// Ensure the repo directory exists.
+	if err := publisher.EnsureRepoExists(); err != nil {
+		return fmt.Errorf("ensuring local repo exists:\n%w", err)
+	}
+
+	// Publish RPMs and update repo metadata.
+	if err := publisher.PublishRPMs(env, rpmPaths); err != nil {
+		return fmt.Errorf("failed to publish to %#q:\n%w", repoPath, err)
+	}
+
+	return nil
+}
@@ -40,3 +40,49 @@ func TestBuildComponents_NoComponents(t *testing.T) {
 	require.Error(t, err)
 	require.Empty(t, results)
 }
+
+func TestValidateBuildOptions_SRPMOnlyWithPublish(t *testing.T) {
+	testEnv := testutils.NewTestEnv(t)
+
+	cmd := testutils.PrepareCommand(componentcmds.NewBuildCmd(), testEnv.Env)
+	cmd.SetArgs([]string{"--srpm-only", "--local-repo-with-publish=/some/repo"})
+	err := cmd.Execute()
+
+	require.Error(t, err)
+	assert.Contains(
+		t, err.Error(),
+		"if any flags in the group [srpm-only local-repo-with-publish] are set none of the others can be",
+	)
+}
+
+func TestValidateBuildOptions_PathOverlap(t *testing.T) {
+	testEnv := testutils.NewTestEnv(t)
+
+	options := componentcmds.ComponentBuildOptions{
+		LocalRepoPaths:           []string{"/shared/repo"},
+		LocalRepoWithPublishPath: "/shared/repo",
+	}
+
+	_, err := componentcmds.SelectAndBuildComponents(testEnv.Env, &options)
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "appears in both --local-repo and --local-repo-with-publish")
+}
+
+func TestValidateBuildOptions_NoOverlapWithDifferentPaths(t *testing.T) {
+	testEnv := testutils.NewTestEnv(t)
+
+	// This should not fail validation due to path overlap.
+	// It will fail due to createrepo_c not being available (which is expected in unit tests).
+	options := componentcmds.ComponentBuildOptions{
+		LocalRepoPaths:           []string{"/upstream/repo"},
+		LocalRepoWithPublishPath: "/dev/repo",
+	}
+
+	_, err := componentcmds.SelectAndBuildComponents(testEnv.Env, &options)
+
+	// Should fail because createrepo_c is not available, NOT because of path overlap.
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "createrepo_c")
+	assert.NotContains(t, err.Error(), "appears in both")
+}
@@ -42,3 +42,10 @@ func Exists(fs opctx.FS, path string) (bool, error) {
 	//nolint:wrapcheck // We are intentionally a pass-through.
 	return afero.Exists(fs, path)
 }
+
+// Adaptation of [afero.DirExists] that works with [opctx.FS].
+// Checks if a directory exists at the given path.
+func DirExists(fs opctx.FS, path string) (bool, error) {
+	//nolint:wrapcheck // We are intentionally a pass-through.
+	return afero.DirExists(fs, path)
+}