Add support for extracting archives using tar.exe

doc/Settings.md

@@ -97,6 +97,16 @@ The 'skipDependencies' behavior affects whether dependencies are installed for a
     "installBehavior": {
         "skipDependencies": true
     },
+```
+
+### Archive Extraction Method
+The 'archiveExtractionMethod' behavior affects how installer archives are extracted. Currently there are two supported values: `Tar` or `ShellApi`.
+`Tar` indicates that the archive should be extracted using the tar executable ('tar.exe') while `shellApi` indicates using the Windows Shell API. Defaults to `shellApi` if value is not set or is invalid.
+
+```json
+    "installBehavior": {
+        "archiveExtractionMethod": "tar" | "shellApi"
+    },
 ```
 
 ### Preferences and Requirements

src/AppInstallerCLICore/Workflows/ArchiveFlow.cpp

@@ -2,9 +2,10 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "ArchiveFlow.h"
-#include "PortableFlow.h"
+#include "PortableFlow.h"
+#include "ShellExecuteInstallerHandler.h"
 #include <winget/AdminSettings.h>
-#include <winget/Archive.h>
+#include <winget/Archive.h>
 #include <winget/Filesystem.h>
 
 using namespace AppInstaller::Manifest;
@@ -42,30 +43,38 @@ namespace AppInstaller::CLI::Workflow
                 }
             }
         }
-    }
-
-    void ExtractFilesFromArchive(Execution::Context& context)
-    {
+    }
+
+    void ExtractFilesFromArchive(Execution::Context& context)
+    {
         const auto& installerPath = context.Get<Execution::Data::InstallerPath>();
         std::filesystem::path destinationFolder = installerPath.parent_path() / s_Extracted;
-        std::filesystem::create_directory(destinationFolder);
-
+        std::filesystem::create_directory(destinationFolder);
+
         AICLI_LOG(CLI, Info, << "Extracting archive to: " << destinationFolder);
-        context.Reporter.Info() << Resource::String::ExtractingArchive << std::endl;
-        HRESULT result = AppInstaller::Archive::TryExtractArchive(installerPath, destinationFolder);
-
-        if (SUCCEEDED(result))
-        {
-            AICLI_LOG(CLI, Info, << "Successfully extracted archive");
-            context.Reporter.Info() << Resource::String::ExtractArchiveSucceeded << std::endl;
-        }
-        else
-        {
-            AICLI_LOG(CLI, Info, << "Failed to extract archive with code " << result);
-            context.Reporter.Error() << Resource::String::ExtractArchiveFailed << std::endl;
-            AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_EXTRACT_ARCHIVE_FAILED);
-        }
-    }
+        context.Reporter.Info() << Resource::String::ExtractingArchive << std::endl;
+
+        if (Settings::User().Get<Settings::Setting::ArchiveExtractionMethod>() == Archive::ExtractionMethod::Tar)
+        {
+            context << ShellExecuteExtractArchive(installerPath, destinationFolder);
+        }
+        else
+        {
+            HRESULT result = AppInstaller::Archive::TryExtractArchive(installerPath, destinationFolder);
+
+            if (SUCCEEDED(result))
+            {
+                AICLI_LOG(CLI, Info, << "Successfully extracted archive");
+                context.Reporter.Info() << Resource::String::ExtractArchiveSucceeded << std::endl;
+            }
+            else
+            {
+                AICLI_LOG(CLI, Info, << "Failed to extract archive with code " << result);
+                context.Reporter.Error() << Resource::String::ExtractArchiveFailed << std::endl;
+                AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_EXTRACT_ARCHIVE_FAILED);
+            }
+        }
+    }
 
     void VerifyAndSetNestedInstaller(Execution::Context& context)
     {
@@ -137,4 +146,4 @@ namespace AppInstaller::CLI::Workflow
             }
         }
     }
-}
+}

src/AppInstallerCLICore/Workflows/ArchiveFlow.h

@@ -10,12 +10,12 @@ namespace AppInstaller::CLI::Workflow
     // Inputs: InstallerPath
     // Outputs: None
     void ScanArchiveFromLocalManifest(Execution::Context& context);
-
+
     // Extracts the files from an archive
     // Required Args: None
     // Inputs: InstallerPath
-    // Outputs: None
-    void ExtractFilesFromArchive(Execution::Context& context);
+    // Outputs: None
+    void ExtractFilesFromArchive(Execution::Context& context);
 
     // Verifies that the NestedInstaller exists and sets the InstallerPath
     // Required Args: None
@@ -28,4 +28,4 @@ namespace AppInstaller::CLI::Workflow
     // Inputs: Installer, InstallerPath
     // Outputs: None
     void EnsureValidNestedInstallerMetadataForArchiveInstall(Execution::Context& context);
-}
+}

src/AppInstallerCLICore/Workflows/RepairFlow.cpp

@@ -505,4 +505,4 @@ namespace AppInstaller::CLI::Workflow
             context.Reporter.Info() << Resource::String::RepairFlowRepairSuccess << std::endl;
         }
     }
-}
+}

src/AppInstallerCLICore/Workflows/ShellExecuteInstallerHandler.cpp

@@ -538,4 +538,36 @@ namespace AppInstaller::CLI::Workflow
             context.Add<Execution::Data::OperationReturnCode>(enableFeatureResult.value());
         }
     }
-}
+
+    void ShellExecuteExtractArchive::operator()(Execution::Context& context) const
+    {
+        auto tarExecPath = AppInstaller::Filesystem::GetExpandedPath("%windir%\\system32\\tar.exe");
+
+        std::string args = "-xf \"" + m_archivePath.u8string() + "\" -C \"" + m_destPath.u8string() + "\"";
+
+        auto extractArchiveResult = context.Reporter.ExecuteWithProgress(
+            std::bind(InvokeShellExecuteEx,
+                tarExecPath,
+                args,
+                false,
+                SW_HIDE,
+                std::placeholders::_1));
+
+        if (!extractArchiveResult)
+        {
+            AICLI_TERMINATE_CONTEXT(E_ABORT);
+        }
+
+        if (extractArchiveResult.value() == ERROR_SUCCESS)
+        {
+            AICLI_LOG(CLI, Info, << "Successfully extracted archive");
+            context.Reporter.Info() << Resource::String::ExtractArchiveSucceeded << std::endl;
+        }
+        else
+        {
+            AICLI_LOG(CLI, Info, << "Failed to extract archive with exit code " << extractArchiveResult.value());
+            context.Reporter.Error() << Resource::String::ExtractArchiveFailed << std::endl;
+            AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_EXTRACT_ARCHIVE_FAILED);
+        }
+    }
+}

src/AppInstallerCLICore/Workflows/ShellExecuteInstallerHandler.h

@@ -60,4 +60,19 @@ namespace AppInstaller::CLI::Workflow
     private:
         std::string_view m_featureName;
     };
-}
+
+    // Extracts the installer archive using the tar executable.
+    // Required Args: None
+    // Inputs: InstallerPath
+    // Outputs: None
+    struct ShellExecuteExtractArchive : public WorkflowTask
+    {
+        ShellExecuteExtractArchive(const std::filesystem::path& archivePath, const std::filesystem::path& destPath) : WorkflowTask("ShellExecuteExtractArchive"), m_archivePath(archivePath), m_destPath(destPath) {}
+
+        void operator()(Execution::Context& context) const override;
+
+    private:
+        std::filesystem::path m_archivePath;
+        std::filesystem::path m_destPath;
+    };
+}

src/AppInstallerCLIE2ETests/Constants.cs

@@ -118,6 +118,7 @@ public class Constants
         public const string PathSubKey_Machine = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
 
         // User settings
+        public const string ArchiveExtractionMethod = "archiveExtractionMethod";
         public const string PortablePackageUserRoot = "portablePackageUserRoot";
         public const string PortablePackageMachineRoot = "portablePackageMachineRoot";
         public const string InstallBehaviorScope = "scope";

src/AppInstallerCLIE2ETests/InstallCommand.cs

@@ -552,6 +552,21 @@ public void InstallZipWithMsix()
             Assert.True(TestCommon.VerifyTestMsixInstalledAndCleanup());
         }
 
+        /// <summary>
+        /// Test install zip exe by extracting with tar.
+        /// </summary>
+        [Test]
+        public void InstallZip_ExtractWithTar()
+        {
+            WinGetSettingsHelper.ConfigureInstallBehavior(Constants.ArchiveExtractionMethod, "tar");
+            var installDir = TestCommon.GetRandomTestDir();
+            var result = TestCommon.RunAICLICommand("install", $"AppInstallerTest.TestZipInstallerWithExe --silent -l {installDir}");
+            WinGetSettingsHelper.ConfigureInstallBehavior(Constants.ArchiveExtractionMethod, string.Empty);
+            Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
+            Assert.True(result.StdOut.Contains("Successfully installed"));
+            Assert.True(TestCommon.VerifyTestExeInstalledAndCleanup(installDir, "/execustom"));
+        }
+
         /// <summary>
         /// Test install an installed package and convert to upgrade.
         /// </summary>
@@ -764,4 +779,4 @@ public void InstallExeThatInstallsMSIX()
             TestCommon.RemoveARPEntry(fakeProductCode);
         }
     }
-}
+}

src/AppInstallerCLITests/Archive.cpp

@@ -31,4 +31,4 @@ TEST_CASE("Scan_ZipArchive", "[archive]")
     const auto& testZipPath = testZip.GetPath();
     bool result = ScanZipFile(testZipPath);
     REQUIRE(result);
-}
+}

src/AppInstallerCLITests/InstallFlow.cpp

@@ -514,6 +514,24 @@ TEST_CASE("ExtractInstallerFromArchive_InvalidZip", "[InstallFlow][workflow]")
     REQUIRE(installOutput.str().find(Resource::LocString(Resource::String::ExtractArchiveFailed).get()) != std::string::npos);
 }
 
+TEST_CASE("ExtractInstallerFromArchiveWithTar_InvalidZip", "[InstallFlow][workflow]")
+{
+    TestCommon::TestUserSettings testSettings;
+    testSettings.Set<Setting::ArchiveExtractionMethod>(AppInstaller::Archive::ExtractionMethod::Tar);
+
+    std::ostringstream installOutput;
+    TestContext context{ installOutput, std::cin };
+    auto previousThreadGlobals = context.SetForCurrentThread();
+    auto manifest = YamlParser::CreateFromPath(TestDataFile("InstallFlowTest_Zip_Exe.yaml"));
+    context.Add<Data::Manifest>(manifest);
+    context.Add<Data::Installer>(manifest.Installers.at(0));
+    // Provide an invalid zip file which should be handled appropriately.
+    context.Add<Data::InstallerPath>(TestDataFile("AppInstallerTestExeInstaller.exe"));
+    context << ExtractFilesFromArchive;
+    REQUIRE_TERMINATED_WITH(context, APPINSTALLER_CLI_ERROR_EXTRACT_ARCHIVE_FAILED);
+    REQUIRE(installOutput.str().find(Resource::LocString(Resource::String::ExtractArchiveFailed).get()) != std::string::npos);
+}
+
 TEST_CASE("MSStoreInstallFlowWithTestManifest", "[InstallFlow][workflow]")
 {
     TestCommon::TempFile installResultPath("TestMSStoreInstalled.txt");

src/AppInstallerCLITests/UserSettings.cpp

@@ -524,6 +524,28 @@ TEST_CASE("SettingsDownloadDefaultDirectory", "[settings]")
         REQUIRE(userSettingTest.Get<Setting::DownloadDefaultDirectory>() == "C:/Foo/Bar");
         REQUIRE(userSettingTest.GetWarnings().size() == 0);
     }
+}
+
+TEST_CASE("SettingsArchiveExtractionMethod", "[settings]")
+{
+    auto again = DeleteUserSettingsFiles();
+
+    SECTION("Shell api")
+    {
+        std::string_view json = R"({ "installBehavior": { "archiveExtractionMethod": "shellApi" } })";
+        SetSetting(Stream::PrimaryUserSettings, json);
+        UserSettingsTest userSettingTest;
+
+        REQUIRE(userSettingTest.Get<Setting::ArchiveExtractionMethod>() == AppInstaller::Archive::ExtractionMethod::ShellApi);
+    }
+    SECTION("Shell api")
+    {
+        std::string_view json = R"({ "installBehavior": { "archiveExtractionMethod": "tar" } })";
+        SetSetting(Stream::PrimaryUserSettings, json);
+        UserSettingsTest userSettingTest;
+
+        REQUIRE(userSettingTest.Get<Setting::ArchiveExtractionMethod>() == AppInstaller::Archive::ExtractionMethod::Tar);
+    }
 }
 
 TEST_CASE("SettingsInstallScope", "[settings]")

src/AppInstallerCommonCore/Archive.cpp

@@ -49,7 +49,6 @@ namespace AppInstaller::Archive
         return S_OK;
     }
 
-
 #ifndef AICLI_DISABLE_TEST_HOOKS
     static bool* s_ScanArchiveResult_TestHook_Override = nullptr;
 
@@ -77,4 +76,4 @@ namespace AppInstaller::Archive
 
         return scanResult == 0;
     }
-}
+}

src/AppInstallerCommonCore/Public/winget/Archive.h

@@ -5,7 +5,13 @@
 
 namespace AppInstaller::Archive
 {
+    enum class ExtractionMethod
+    {
+        ShellApi,
+        Tar,
+    };
+
     HRESULT TryExtractArchive(const std::filesystem::path& archivePath, const std::filesystem::path& destPath);
 
     bool ScanZipFile(const std::filesystem::path& zipPath);
-}
+}

src/AppInstallerCommonCore/Public/winget/UserSettings.h

@@ -3,6 +3,7 @@
 #pragma once
 #include "AppInstallerStrings.h"
 #include "AppInstallerLogging.h"
+#include "winget/Archive.h"
 #include "winget/GroupPolicy.h"
 #include "winget/Resources.h"
 #include "winget/ManifestCommon.h"
@@ -90,6 +91,7 @@ namespace AppInstaller::Settings
         InstallerTypeRequirement,
         InstallDefaultRoot,
         InstallSkipDependencies,
+        ArchiveExtractionMethod,
         DisableInstallNotes,
         PortablePackageUserRoot,
         PortablePackageMachineRoot,
@@ -173,6 +175,7 @@ namespace AppInstaller::Settings
         SETTINGMAPPING_SPECIALIZATION(Setting::InstallerTypePreference, std::vector<std::string>, std::vector<Manifest::InstallerTypeEnum>, {}, ".installBehavior.preferences.installerTypes"sv);
         SETTINGMAPPING_SPECIALIZATION(Setting::InstallerTypeRequirement, std::vector<std::string>, std::vector<Manifest::InstallerTypeEnum>, {}, ".installBehavior.requirements.installerTypes"sv);
         SETTINGMAPPING_SPECIALIZATION(Setting::InstallSkipDependencies, bool, bool, false, ".installBehavior.skipDependencies"sv);
+        SETTINGMAPPING_SPECIALIZATION(Setting::ArchiveExtractionMethod, std::string, Archive::ExtractionMethod, Archive::ExtractionMethod::ShellApi, ".installBehavior.archiveExtractionMethod"sv);
         SETTINGMAPPING_SPECIALIZATION(Setting::DisableInstallNotes, bool, bool, false, ".installBehavior.disableInstallNotes"sv);
         SETTINGMAPPING_SPECIALIZATION(Setting::PortablePackageUserRoot, std::string, std::filesystem::path, {}, ".installBehavior.portablePackageUserRoot"sv);
         SETTINGMAPPING_SPECIALIZATION(Setting::PortablePackageMachineRoot, std::string, std::filesystem::path, {}, ".installBehavior.portablePackageMachineRoot"sv);

src/AppInstallerCommonCore/UserSettings.cpp

@@ -290,6 +290,23 @@ namespace AppInstaller::Settings
             return ValidatePathValue(value);
         }
 
+        WINGET_VALIDATE_SIGNATURE(ArchiveExtractionMethod)
+        {
+            static constexpr std::string_view s_archiveExtractionMethod_shellApi = "shellApi";
+            static constexpr std::string_view s_archiveExtractionMethod_tar = "tar";
+
+            if (Utility::CaseInsensitiveEquals(value, s_archiveExtractionMethod_tar))
+            {
+                return Archive::ExtractionMethod::Tar;
+            }
+            else if (Utility::CaseInsensitiveEquals(value, s_archiveExtractionMethod_shellApi))
+            {
+                return Archive::ExtractionMethod::ShellApi;
+            }
+
+            return {};
+        }
+
         WINGET_VALIDATE_SIGNATURE(InstallArchitecturePreference)
         {
             std::vector<Utility::Architecture> archs;