dotnet · lbussell · Oct 3, 2025 · Sep 30, 2025 · Sep 30, 2025 · Oct 1, 2025
@@ -3,13 +3,12 @@
 
 using System.CommandLine;
 using System.CommandLine.NamingConventionBinder;
-using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 namespace Dotnet.Docker;
 
-public abstract class BaseCommand<TOptions>() where TOptions : IOptions
+public abstract class BaseCommand<TOptions>() : ICommand<TOptions> where TOptions : IOptions
 {
     public abstract Task<int> ExecuteAsync(TOptions options);
 
@@ -34,7 +33,7 @@ public static Command Create(string name, string description)
     private static BindingHandler Handler =>
         CommandHandler.Create<TOptions, IHost>(async (options, host) =>
             {
-                var thisCommand = host.Services.GetRequiredService<BaseCommand<TOptions>>();
+                var thisCommand = host.Services.GetRequiredService<ICommand<TOptions>>();
                 return await thisCommand.ExecuteAsync(options);
             });
 }
@@ -25,10 +25,10 @@ internal class BaseUrlUpdater : FileRegexUpdater
     /// If the base URL variable cannot be found in the manifest, the updater
     /// won't do anything.
     /// </summary>
-    public static IDependencyUpdater Create(string repoRoot, SpecificCommandOptions options)
+    public static IDependencyUpdater Create(SpecificCommandOptions options)
     {
         // Load manifest and extract variables once so the constructor doesn't duplicate this logic
-        var manifest = ManifestHelper.LoadManifest(SpecificCommand.VersionsFilename);
+        var manifest = ManifestHelper.LoadManifest(options.GetManifestVersionsFilePath());
         var manifestVariables = (JObject?)manifest["variables"];
 
         if (manifestVariables is null)
@@ -49,16 +49,15 @@ public static IDependencyUpdater Create(string repoRoot, SpecificCommandOptions
             return new EmptyDependencyUpdater();
         }
 
-        return new BaseUrlUpdater(repoRoot, options, manifestVariables, baseUrlVarName);
+        return new BaseUrlUpdater(options, manifestVariables, baseUrlVarName);
     }
 
     private BaseUrlUpdater(
-        string repoRoot,
         SpecificCommandOptions options,
         JObject manifestVariables,
         string manifestVariableName)
     {
-        Path = System.IO.Path.Combine(repoRoot, SpecificCommand.VersionsFilename);
+        Path = options.GetManifestVersionsFilePath();
         VersionGroupName = BaseUrlGroupName;
         _options = options;
         _manifestVariables = manifestVariables;

@@ -10,6 +10,11 @@ public abstract record CreatePullRequestOptions
 {
     private string? _targetBranch = null;
 
+    /// <summary>
+    /// The root of the dotnet-docker repo to run against.
+    /// </summary>
+    public string RepoRoot { get; init; } = Directory.GetCurrentDirectory();
+
     public string User { get; init; } = "";
     public string Email { get; init; } = "";
     public string Password { get; init; } = "";
@@ -26,6 +31,7 @@ public string TargetBranch
 
     public static List<Option> Options =>
     [
+        new Option<string>("--repo-root") { Description = "The root of the dotnet-docker repo to run against (defaults to current working directory)" },
         new Option<string>("--user") { Description = "GitHub or AzDO user used to make PR (if not specified, a PR will not be created)" },
         new Option<string>("--email") { Description = "GitHub or AzDO email used to make PR (if not specified, a PR will not be created)" },
         new Option<string>("--password") { Description = "GitHub or AzDO password used to make PR (if not specified, a PR will not be created)" },

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Dotnet.Docker;
+
+internal static class CreatePullRequestOptionsExtensions
+{
+    public static string GetManifestVersionsFilePath(this CreatePullRequestOptions options) =>
+        Path.Combine(options.RepoRoot, "manifest.versions.json");
+}
@@ -17,7 +17,7 @@ public static void AddCommand<TCommand, TOptions>(
             where TCommand : BaseCommand<TOptions>
             where TOptions : IOptions
     {
-        serviceCollection.AddSingleton<BaseCommand<TOptions>, TCommand>();
+        serviceCollection.AddSingleton<ICommand<TOptions>, TCommand>();
     }
 
     /// <summary>

@@ -72,11 +72,12 @@ public DockerfileShaUpdater(
             _manifestVariables = new Lazy<JObject>(
                 () =>
                 {
+                    var versionsFile = options.GetManifestVersionsFilePath();
                     const string VariablesProperty = "variables";
-                    JToken? variables = ManifestHelper.LoadManifest(SpecificCommand.VersionsFilename)[VariablesProperty];
+                    JToken? variables = ManifestHelper.LoadManifest(versionsFile)[VariablesProperty];
                     if (variables is null)
                     {
-                        throw new InvalidOperationException($"'{VariablesProperty}' property missing in '{SpecificCommand.VersionsFilename}'");
+                        throw new InvalidOperationException($"'{VariablesProperty}' property missing in '{versionsFile}'");
                     }
                     return (JObject)variables;
                 });
@@ -91,9 +92,9 @@ public DockerfileShaUpdater(
         }
 
         public static IEnumerable<IDependencyUpdater> CreateUpdaters(
-            string productName, string dockerfileVersion, string repoRoot, SpecificCommandOptions options)
+            string productName, string dockerfileVersion, SpecificCommandOptions options)
         {
-            string versionsPath = System.IO.Path.Combine(repoRoot, SpecificCommand.VersionsFilename);
+            string versionsPath = options.GetManifestVersionsFilePath();
             string versions = File.ReadAllText(versionsPath);
 
             // The format of the sha variable name is '<productName>|<dockerfileVersion>|<os>|<arch>|sha'.

@@ -1,17 +1,20 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Dotnet.Docker.Sync;
 using Microsoft.Extensions.Logging;
 
 namespace Dotnet.Docker;
 
 internal partial class FromStagingPipelineCommand(
     ILogger<FromStagingPipelineCommand> logger,
-    PipelineArtifactProvider pipelineArtifactProvider)
+    PipelineArtifactProvider pipelineArtifactProvider,
+    IInternalVersionsService internalVersionsService)
     : BaseCommand<FromStagingPipelineOptions>
 {
     private readonly ILogger<FromStagingPipelineCommand> _logger = logger;
     private readonly PipelineArtifactProvider _pipelineArtifactProvider = pipelineArtifactProvider;
+    private readonly IInternalVersionsService _internalVersionsService = internalVersionsService;
 
     public override async Task<int> ExecuteAsync(FromStagingPipelineOptions options)
     {
@@ -44,7 +47,10 @@ public override async Task<int> ExecuteAsync(FromStagingPipelineOptions options)
         string dockerfileVersion = VersionHelper.ResolveMajorMinorVersion(releaseConfig.RuntimeBuild).ToString();
 
         // Record pipeline run ID for this dockerfileVersion, for later use by sync-internal-release command
-        RecordInternalVersion(dockerfileVersion, options.StagingPipelineRunId.ToString());
+        _internalVersionsService.RecordInternalStagingBuild(
+            options.RepoRoot,
+            dockerfileVersion,
+            options.StagingPipelineRunId);
 
         var productVersions = (options.Internal, releaseConfig.SdkOnly) switch
         {
@@ -109,59 +115,6 @@ public override async Task<int> ExecuteAsync(FromStagingPipelineOptions options)
         return await updateDependencies.ExecuteAsync(updateDependenciesOptions);
     }
 
-    /// <summary>
-    /// Records the staging pipeline run ID in an easy to parse format. This
-    /// can be used by the sync-internal-release pipeline to record and
-    /// re-apply the same staging builds after resetting the state of the repo
-    /// to match the public release branch.
-    /// </summary>
-    /// <remarks>
-    /// This will only store one staging pipeline run ID per dockerfileVersion
-    /// </remarks>
-    /// <param name="dockerfileVersion">major-minor version</param>
-    /// <param name="stagingPipelineRunId">the build ID of the staging pipeline run</param>
-    private void RecordInternalVersion(string dockerfileVersion, string stagingPipelineRunId)
-    {
-        const string InternalVersionsFile = "internal-versions.txt";
-
-        // Internal versions file should have one line per dockerfileVersion
-        // Each line should be formatted as: <dockerfileVersion>=<stagingPipelineRunId>
-        //
-        // The preferable way to do this would be to record the version in
-        // manifest.versions.json, however that would require one of the following:
-        // 1) round-trip serialization, which would remove any whitespace/blank lines - which are
-        //    important for keeping the file readable and reducing git merge conflicts
-        // 2) lots of regex JSON manipulation which is error-prone and harder to maintain
-        //
-        // So for now, the separate file and format is a compromise.
-
-        var versionsFilePath = Path.GetFullPath(SpecificCommand.VersionsFilename);
-        var versionsFileDir = Path.GetDirectoryName(versionsFilePath) ?? "";
-        var internalVersionFile = Path.Combine(versionsFileDir, InternalVersionsFile);
-        Dictionary<string, string> versions = [];
-
-        _logger.LogInformation(
-            "Recording staging pipeline build ID in {internalVersionFile}",
-            internalVersionFile);
-
-        try
-        {
-            // File already exists - read existing versions
-            versions = File.ReadAllLines(internalVersionFile)
-                .Select(line => line.Split('=', 2))
-                .Where(parts => parts.Length == 2)
-                .ToDictionary(parts => parts[0], parts => parts[1]);
-        }
-        catch (FileNotFoundException)
-        {
-            // File doesn't exist - it will be created
-        }
-
-        versions[dockerfileVersion] = stagingPipelineRunId;
-        var versionLines = versions.Select(kv => $"{kv.Key}={kv.Value}");
-        File.WriteAllLines(internalVersionFile, versionLines);
-    }
-
     /// <summary>
     /// Formats a storage account URL has a specific format:
     /// - Starts with "https://"

@@ -8,7 +8,7 @@ namespace Dotnet.Docker;
 
 internal record FromStagingPipelineOptions : CreatePullRequestOptions, IOptions
 {
-    public const string StagingStorageAccountOption = "--staging-storage-account";
+    public const string StagingStorageAccountOptionName = "--staging-storage-account";
     public const string InternalOption = "--internal";
 
     /// <summary>
@@ -37,14 +37,16 @@ internal record FromStagingPipelineOptions : CreatePullRequestOptions, IOptions
         ..CreatePullRequestOptions.Arguments,
     ];
 
+    public static Option<string> StagingStorageAccountOption = new(StagingStorageAccountOptionName)
+    {
+        Description = "The Azure Storage Account to use as a source for the update."
+            + " This should be one of two storage accounts: dotnetstagetest or dotnetstage."
+            + " For example: https://dotnetstagetest.blob.core.windows.net/"
+    };
+
     public static new List<Option> Options { get; } =
     [
-        new Option<string>(StagingStorageAccountOption)
-        {
-            Description = "The Azure Storage Account to use as a source for the update."
-                + " This should be one of two storage accounts: dotnetstagetest or dotnetstage."
-                + " For example: https://dotnetstagetest.blob.core.windows.net/"
-        },
+        StagingStorageAccountOption,
         new Option<bool>(InternalOption)
         {
             Description = "Whether or not to use the internal versions of the staged build. When not using an internal"

@@ -8,4 +8,4 @@ namespace Dotnet.Docker.Git;
 /// </summary>
 /// <param name="Name">The name of the remote (e.g., "origin").</param>
 /// <param name="Url">The URL of the remote repository.</param>
-public record GitRemoteInfo(string Name, string Url);
+internal sealed record GitRemoteInfo(string Name, string Url);
@@ -13,7 +13,7 @@ namespace Dotnet.Docker.Git;
 /// <remarks>
 /// Use <see cref="IGitRepoHelperFactory"/> to instantiate this.
 /// </remarks>
-public sealed class GitRepoHelper(
+internal sealed class GitRepoHelper(
     string remoteRepoUrl,
     ILocalGitRepoHelper localGitRepoHelper,
     IRemoteGitRepoHelper remoteGitRepoHelper,

@@ -11,12 +11,12 @@
 
 namespace Dotnet.Docker.Git;
 
-public interface IGitRepoHelperFactory
+internal interface IGitRepoHelperFactory
 {
     Task<IGitRepoHelper> CreateAsync(string repoUri);
 }
 
-public sealed class GitRepoHelperFactory(
+internal sealed class GitRepoHelperFactory(
     IGitRepoCloner gitRepoCloner,
     ILocalGitRepoFactory localGitRepoFactory,
     IRemoteGitRepoFactory remoteFactory,

@@ -9,7 +9,7 @@ namespace Dotnet.Docker.Git;
 /// <summary>
 /// Handles operations that require interactions with both local and remote git repos.
 /// </summary>
-public interface IGitRepoHelper : IDisposable
+internal interface IGitRepoHelper : IDisposable
 {
     /// <summary>
     /// For any git operations that only affect the local repo.

@@ -6,7 +6,7 @@
 
 namespace Dotnet.Docker.Git;
 
-public interface ILocalGitRepoHelper
+internal interface ILocalGitRepoHelper
 {
     /// <summary>
     /// The local path where the repository is cloned.
@@ -69,4 +69,20 @@ public interface ILocalGitRepoHelper
     /// List all remotes for the local repository.
     /// </summary>
     Task<IEnumerable<GitRemoteInfo>> ListAllRemotesAsync();
+
+    /// <summary>
+    /// Restore the working tree with the contents from a restore source.
+    /// Uncommitted changes in the working tree will be lost.
+    /// </summary>
+    /// <remarks>
+    /// Because contents are restored to the working tree, they will not be
+    /// staged. If the changes resulting from this command need to be
+    /// committed, they must be staged first.
+    /// </remarks>
+    /// <param name="source">
+    /// Restore the working tree files with the content from this tree.
+    /// This can be a commit, branch or tag.
+    /// </param>
+    /// <see href="link">https://git-scm.com/docs/git-restore</see>
+    Task RestoreAsync(string source);
 }
@@ -6,7 +6,7 @@
 
 namespace Dotnet.Docker.Git;
 
-public interface IRemoteGitRepoHelper
+internal interface IRemoteGitRepoHelper
 {
     /// <summary>
     /// Checks if a branch exists on the remote repository.

@@ -10,4 +10,4 @@ namespace Dotnet.Docker.Git;
 /// such as attempting to use a non-existent branch or an incorrectly named branch.
 /// </summary>
 /// <param name="message">The error message describing the invalid branch condition.</param>
-public sealed class InvalidBranchException(string message) : InvalidOperationException(message);
+internal sealed class InvalidBranchException(string message) : InvalidOperationException(message);
@@ -10,7 +10,7 @@
 
 namespace Dotnet.Docker.Git;
 
-public sealed class LocalGitRepoHelper(
+internal sealed class LocalGitRepoHelper(
     string localPath,
     ILocalGitRepo localGitRepo,
     ILogger<LocalGitRepoHelper> logger
@@ -67,7 +67,7 @@ public async Task<string> CommitAsync(string message, (string Name, string Email
         var commitSha = await _localGitRepo.GetShaForRefAsync("HEAD");
         return commitSha;
     }
-    
+
     /// <inheritdoc />
     public async Task<bool> IsAncestorAsync(string ancestorRef, string descendantRef)
     {
@@ -99,4 +99,10 @@ public async Task<IEnumerable<GitRemoteInfo>> ListAllRemotesAsync()
             // There are typically two entries per remote (fetch and push); we only want one
             .Distinct();
     }
+
+    /// <inheritdoc />
+    public async Task RestoreAsync(string source)
+    {
+        await _localGitRepo.ExecuteGitCommand("restore", "--source", source);
+    }
 }
@@ -10,7 +10,7 @@ namespace Dotnet.Docker.Git;
 /// <summary>
 /// Factory for creating <see cref="IRemoteGitRepo"/> instances based on repository URLs.
 /// </summary>
-public interface IRemoteGitRepoFactory
+internal interface IRemoteGitRepoFactory
 {
     /// <summary>
     /// Creates a remote Git repository client appropriate for the given repository URL.
@@ -21,7 +21,7 @@ public interface IRemoteGitRepoFactory
 }
 
 /// <inheritdoc />
-public sealed class RemoteGitRepoFactory(IServiceProvider serviceProvider) : IRemoteGitRepoFactory
+internal sealed class RemoteGitRepoFactory(IServiceProvider serviceProvider) : IRemoteGitRepoFactory
 {
     private readonly IServiceProvider _serviceProvider = serviceProvider;
 

@@ -8,7 +8,7 @@
 
 namespace Dotnet.Docker.Git;
 
-public sealed class RemoteGitRepoHelper(
+internal sealed class RemoteGitRepoHelper(
     string remoteRepoUrl,
     IRemoteGitRepo remoteGitRepo,
     ILocalGitRepo localGitRepo,