Preserve overrides with export and import (#6118)

When a package is installed with --override or --custom arguments, those
values are now preserved through the winget export / winget import
roundtrip, allowing packages to be reinstalled with the same
customizations automatically.

Author: Trenly

doc/ReleaseNotes.md

@@ -28,6 +28,10 @@ match criteria that factor into the result ordering. This will prevent them from
 
 ## Minor Features
 
+### Preserve installer arguments across export and import
+
+`winget export` now captures the `--override` and `--custom` arguments that were used when a package was originally installed and saves them into the export file. When subsequently running `winget import`, those values are automatically re-applied during installation — `--override` replaces all installer arguments and `--custom` appends extra switches — so packages can be reinstalled with the same customizations without any manual intervention. Both fields are optional and independent of each other; packages without stored installer arguments are unaffected.
+
 ### --no-progress flag
 
 Added a new `--no-progress` command-line flag that disables all progress reporting (progress bars and spinners). This flag is universally available on all commands and takes precedence over the `visual.progressBar` setting. Useful for automation scenarios or when running WinGet in environments where progress output is undesirable.

schemas/JSON/packages/packages.schema.2.0.json

@@ -96,6 +96,16 @@
                     "machine"
                   ],
                   "default": "user"
+                },
+
+                "InitialOverrideArguments": {
+                  "description": "Override arguments used when the package was initially installed; preserved on upgrade",
+                  "type": "string"
+                },
+
+                "InitialCustomSwitches": {
+                  "description": "Additional custom switches used when the package was initially installed; preserved on upgrade",
+                  "type": "string"
                 }
               }
             }

src/AppInstallerCLICore/PackageCollection.cpp

@@ -41,6 +41,8 @@ namespace AppInstaller::CLI
             const std::string PackagesJson_Package_Version = "Version";
             const std::string PackagesJson_Package_Channel = "Channel";
             const std::string PackagesJson_Package_Scope = "Scope";
+            const std::string PackagesJson_Package_InitialOverrideArguments = "InitialOverrideArguments";
+            const std::string PackagesJson_Package_InitialCustomSwitches = "InitialCustomSwitches";
 
             static const StaticStrings& Instance()
             {
@@ -154,6 +156,16 @@ namespace AppInstaller::CLI
                 PackageCollection::Package package{ Utility::LocIndString{ id }, Utility::Version{ version }, Utility::Channel{ channel } };
                 package.Scope = Manifest::ConvertToScopeEnum(scope);
 
+                if (packageNode.isMember(ss.PackagesJson_Package_InitialOverrideArguments))
+                {
+                    package.InitialOverrideArgs = packageNode[ss.PackagesJson_Package_InitialOverrideArguments].asString();
+                }
+
+                if (packageNode.isMember(ss.PackagesJson_Package_InitialCustomSwitches))
+                {
+                    package.InitialCustomSwitches = packageNode[ss.PackagesJson_Package_InitialCustomSwitches].asString();
+                }
+
                 return package;
             }
         };
@@ -202,6 +214,16 @@ namespace AppInstaller::CLI
                 packageNode[ss.PackagesJson_Package_Scope] = std::string{ Manifest::ScopeToString(package.Scope) };
             }
 
+            if (!package.InitialOverrideArgs.empty())
+            {
+                packageNode[ss.PackagesJson_Package_InitialOverrideArguments] = package.InitialOverrideArgs;
+            }
+
+            if (!package.InitialCustomSwitches.empty())
+            {
+                packageNode[ss.PackagesJson_Package_InitialCustomSwitches] = package.InitialCustomSwitches;
+            }
+
             return sourceNode[ss.PackagesJson_Packages].append(std::move(packageNode));
         }
 

src/AppInstallerCLICore/PackageCollection.h

@@ -28,8 +28,10 @@ namespace AppInstaller::CLI
 
             Utility::LocIndString Id;
             Utility::VersionAndChannel VersionAndChannel;
-            Manifest::ScopeEnum Scope = Manifest::ScopeEnum::Unknown;
+            Manifest::ScopeEnum Scope = Manifest::ScopeEnum::Unknown;
             std::filesystem::path InstalledLocation;
+            std::string InitialOverrideArgs;
+            std::string InitialCustomSwitches;
         };
 
         // A source along with a set of packages available from it.

src/AppInstallerCLICore/Workflows/ImportExportFlow.cpp

@@ -140,7 +140,27 @@ namespace AppInstaller::CLI::Workflow
             // but take the exported version from the installed package if needed.
             PackageCollection::Package exportPackage;
             exportPackage.Id = availablePackageVersion->GetProperty(PackageVersionProperty::Id);
-            exportPackage.InstalledLocation = Utility::ConvertToUTF16(installedPackageVersion->GetMetadata()[PackageVersionMetadata::InstalledLocation]);
+
+            const auto& installedMetadata = installedPackageVersion->GetMetadata();
+
+            auto locationItr = installedMetadata.find(PackageVersionMetadata::InstalledLocation);
+            if (locationItr != installedMetadata.end())
+            {
+                exportPackage.InstalledLocation = Utility::ConvertToUTF16(locationItr->second);
+            }
+
+            auto overrideItr = installedMetadata.find(PackageVersionMetadata::InitialOverrideArguments);
+            if (overrideItr != installedMetadata.end())
+            {
+                exportPackage.InitialOverrideArgs = overrideItr->second;
+            }
+
+            auto customItr = installedMetadata.find(PackageVersionMetadata::InitialCustomSwitches);
+            if (customItr != installedMetadata.end())
+            {
+                exportPackage.InitialCustomSwitches = customItr->second;
+            }
+
             if (includeVersions)
             {
                 exportPackage.VersionAndChannel = { version.get(), channel.get() };
@@ -298,6 +318,16 @@ namespace AppInstaller::CLI::Workflow
                     searchContext.Args.AddArg(Execution::Args::Type::Channel, channelString);
                 }
 
+                if (!packageRequest.InitialOverrideArgs.empty())
+                {
+                    searchContext.Args.AddArg(Execution::Args::Type::Override, packageRequest.InitialOverrideArgs);
+                }
+
+                if (!packageRequest.InitialCustomSwitches.empty())
+                {
+                    searchContext.Args.AddArg(Execution::Args::Type::CustomSwitches, packageRequest.InitialCustomSwitches);
+                }
+
                 packageSubContexts.emplace_back(std::move(searchContextPtr));
             }
         }

src/AppInstallerCLICore/Workflows/InstallFlow.cpp

@@ -996,6 +996,8 @@ namespace AppInstaller::CLI::Workflow
             installedMetadata = context.Get<Data::InstalledPackageVersion>()->GetMetadata();
         }
 
+        bool isUpdate = WI_IsFlagSet(context.GetFlags(), ContextFlag::InstallerExecutionUseUpdate);
+
         if (context.Args.Contains(Execution::Args::Type::InstallArchitecture))
         {
             version.SetMetadata(Repository::PackageVersionMetadata::UserIntentArchitecture, context.Args.GetArg(Execution::Args::Type::InstallArchitecture));
@@ -1021,5 +1023,34 @@ namespace AppInstaller::CLI::Workflow
                 version.SetMetadata(Repository::PackageVersionMetadata::UserIntentLocale, itr->second);
             }
         }
+
+        // InitialOverrideArguments and InitialCustomSwitches capture the args from the original install.
+        // They are set only on fresh install and preserved (not updated) on upgrade.
+        if (!isUpdate)
+        {
+            if (context.Args.Contains(Execution::Args::Type::Override))
+            {
+                version.SetMetadata(Repository::PackageVersionMetadata::InitialOverrideArguments, context.Args.GetArg(Execution::Args::Type::Override));
+            }
+
+            if (context.Args.Contains(Execution::Args::Type::CustomSwitches))
+            {
+                version.SetMetadata(Repository::PackageVersionMetadata::InitialCustomSwitches, context.Args.GetArg(Execution::Args::Type::CustomSwitches));
+            }
+        }
+        else
+        {
+            auto overrideItr = installedMetadata.find(Repository::PackageVersionMetadata::InitialOverrideArguments);
+            if (overrideItr != installedMetadata.end())
+            {
+                version.SetMetadata(Repository::PackageVersionMetadata::InitialOverrideArguments, overrideItr->second);
+            }
+
+            auto customItr = installedMetadata.find(Repository::PackageVersionMetadata::InitialCustomSwitches);
+            if (customItr != installedMetadata.end())
+            {
+                version.SetMetadata(Repository::PackageVersionMetadata::InitialCustomSwitches, customItr->second);
+            }
+        }
     }
 }

src/AppInstallerCLITests/AppInstallerCLITests.vcxproj

@@ -441,6 +441,12 @@
     <CopyFileToFolders Include="TestData\ImportFile-Good-WithLicenseAgreement.json">
       <DeploymentContent>true</DeploymentContent>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\ImportFile-Good-WithOverrideArgs.json">
+      <DeploymentContent>true</DeploymentContent>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\ImportFile-Good-WithCustomSwitches.json">
+      <DeploymentContent>true</DeploymentContent>
+    </CopyFileToFolders>
     <None Include="packages.config" />
     <None Include="PropertySheet.props" />
     <CopyFileToFolders Include="TestData\InstallerArgTest_Inno_NoSwitches.yaml">

src/AppInstallerCLITests/AppInstallerCLITests.vcxproj.filters

@@ -798,6 +798,12 @@
     <CopyFileToFolders Include="TestData\ImportFile-Good-WithLicenseAgreement.json">
       <Filter>TestData</Filter>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\ImportFile-Good-WithOverrideArgs.json">
+      <Filter>TestData</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\ImportFile-Good-WithCustomSwitches.json">
+      <Filter>TestData</Filter>
+    </CopyFileToFolders>
     <CopyFileToFolders Include="TestData\ImportFile-Good-Dependencies.json">
       <Filter>TestData</Filter>
     </CopyFileToFolders>

src/AppInstallerCLITests/CompositeSource.cpp

@@ -1115,6 +1115,61 @@ TEST_CASE("CompositeSource_TrackingPackageFound_MetadataPopulatedFromTracking",
     REQUIRE(metadata[Repository::PackageVersionMetadata::PinnedState] == "PinnedByManifest");
 }
 
+TEST_CASE("CompositeSource_TrackingPackageFound_UserInstallerArgsPopulatedFromTracking", "[CompositeSource]")
+{
+    std::string availableID = "Available.ID";
+    std::string pfn = "sortof_apfn";
+
+    CompositeWithTrackingTestSetup setup;
+    auto installedPackage = setup.MakeInstalled().WithPFN(pfn);
+    auto availablePackage = setup.MakeAvailable().WithPFN(pfn).WithId(availableID).WithDefaultName(s_Everything_Query);
+
+    setup.Installed->Everything.Matches.emplace_back(installedPackage, Criteria());
+    setup.Installed->SearchFunction = [&](const SearchRequest& request)
+    {
+        RequireSearchRequestIncludes(request.Inclusions, PackageMatchField::PackageFamilyName, MatchType::Exact, pfn);
+
+        SearchResult result;
+        result.Matches.emplace_back(installedPackage, Criteria());
+        return result;
+    };
+
+    setup.Available->Everything.Matches.emplace_back(availablePackage, Criteria());
+    setup.Available->SearchFunction = [&](const SearchRequest& request)
+    {
+        if (request.Filters.empty())
+        {
+            RequireSearchRequestIncludes(request.Inclusions, PackageMatchField::PackageFamilyName, MatchType::Exact, pfn);
+        }
+        else
+        {
+            REQUIRE(request.Filters.size() == 1);
+            RequireSearchRequestIncludes(request.Filters, PackageMatchField::Id, MatchType::CaseInsensitive, availableID);
+        }
+
+        SearchResult result;
+        result.Matches.emplace_back(availablePackage, Criteria());
+        return result;
+    };
+
+    auto manifestId = setup.Tracking->GetIndex().AddManifest(availablePackage);
+
+    // InitialOverrideArguments and InitialCustomSwitches are only stored in the tracking catalog,
+    // so they must be merged from there into the composite installed version's metadata.
+    setup.Tracking->GetIndex().SetMetadataByManifestId(manifestId, Repository::PackageVersionMetadata::InitialOverrideArguments, "/silent /norestart");
+    setup.Tracking->GetIndex().SetMetadataByManifestId(manifestId, Repository::PackageVersionMetadata::InitialCustomSwitches, "--no-telemetry");
+
+    SearchResult result = setup.Search();
+
+    REQUIRE(result.Matches.size() == 1);
+    REQUIRE(result.Matches[0].Package);
+    REQUIRE(GetInstalledVersion(result.Matches[0].Package));
+
+    auto metadata = GetInstalledVersion(result.Matches[0].Package)->GetMetadata();
+    REQUIRE(metadata[Repository::PackageVersionMetadata::InitialOverrideArguments] == "/silent /norestart");
+    REQUIRE(metadata[Repository::PackageVersionMetadata::InitialCustomSwitches] == "--no-telemetry");
+}
+
 TEST_CASE("CompositeSource_TrackingFound_AvailableNot", "[CompositeSource]")
 {
     std::string availableID = "Available.ID";

src/AppInstallerCLITests/ExportFlow.cpp

@@ -2,10 +2,15 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "WorkflowCommon.h"
+#include "TestSource.h"
 #include <Commands/ExportCommand.h>
+#include <winget/ManifestYamlParser.h>
 
 using namespace TestCommon;
 using namespace AppInstaller::CLI;
+using namespace AppInstaller::Repository;
+using namespace AppInstaller::Manifest;
+using namespace AppInstaller::Manifest::YamlParser;
 
 TEST_CASE("ExportFlow_ExportAll", "[ExportFlow][workflow]")
 {
@@ -115,3 +120,72 @@ TEST_CASE("ExportFlow_ExportAll_WithVersions", "[ExportFlow][workflow]")
             return p.Id == "AppInstallerCliTest.TestExeUnknownVersion" && p.VersionAndChannel.GetVersion().ToString() == "unknown";
         }));
 }
+
+TEST_CASE("ExportFlow_ExportAll_WithUserInstallerArgs", "[ExportFlow][workflow]")
+{
+    TestCommon::TempFile exportResultPath("TestExport.json");
+
+    std::ostringstream exportOutput;
+    TestContext context{ exportOutput, std::cin };
+    auto previousThreadGlobals = context.SetForCurrentThread();
+
+    // Create a test source with packages that have InitialOverrideArguments and InitialCustomSwitches set
+    auto testSource = CreateTestSource({});
+
+    TestSourceResult exeWithOverride(
+        "AppInstallerCliTest.TestExeInstaller"sv,
+        [](std::vector<ResultMatch>& matches, std::weak_ptr<const ISource> source)
+        {
+            auto manifest = YamlParser::CreateFromPath(TestDataFile("InstallFlowTest_Exe.yaml"));
+            auto manifest2 = YamlParser::CreateFromPath(TestDataFile("UpdateFlowTest_Exe.yaml"));
+            auto manifest3 = YamlParser::CreateFromPath(TestDataFile("UpdateFlowTest_Exe_2.yaml"));
+
+            auto testPackage = TestCompositePackage::Make(
+                manifest,
+                TestCompositePackage::MetadataMap
+                {
+                    { PackageVersionMetadata::InstalledType, "Exe" },
+                    { PackageVersionMetadata::InitialOverrideArguments, "/silent /override" },
+                    { PackageVersionMetadata::InitialCustomSwitches, "--custom-flag" },
+                },
+                std::vector<Manifest>{ manifest3, manifest2, manifest },
+                source);
+            for (auto& availablePackage : testPackage->Available)
+            {
+                availablePackage->IsSameOverride = [](const IPackage*, const IPackage*) { return true; };
+            }
+            matches.emplace_back(
+                ResultMatch(
+                    testPackage,
+                    PackageMatchFilter(PackageMatchField::Id, MatchType::Exact, "AppInstallerCliTest.TestExeInstaller")));
+        });
+
+    testSource->AddResult(exeWithOverride);
+
+    OverrideForCompositeInstalledSource(context, testSource);
+    context.Args.AddArg(Execution::Args::Type::OutputFile, exportResultPath);
+
+    ExportCommand exportCommand({});
+    exportCommand.Execute(context);
+    INFO(exportOutput.str());
+
+    const auto& exportedCollection = context.Get<Execution::Data::PackageCollection>();
+    REQUIRE(exportedCollection.Sources.size() == 1);
+
+    const auto& exportedPackages = exportedCollection.Sources[0].Packages;
+    REQUIRE(exportedPackages.size() == 1);
+
+    const auto& pkg = exportedPackages[0];
+    REQUIRE(pkg.Id == "AppInstallerCliTest.TestExeInstaller");
+    REQUIRE(pkg.InitialOverrideArgs == "/silent /override");
+    REQUIRE(pkg.InitialCustomSwitches == "--custom-flag");
+
+    // Verify the values are in the exported JSON file
+    std::ifstream exportFile(exportResultPath.GetPath());
+    Json::Value exportedJson;
+    exportFile >> exportedJson;
+
+    const auto& jsonPackage = exportedJson["Sources"][0]["Packages"][0];
+    REQUIRE(jsonPackage["InitialOverrideArguments"].asString() == "/silent /override");
+    REQUIRE(jsonPackage["InitialCustomSwitches"].asString() == "--custom-flag");
+}