From aae3caa1a96b82c4dea52d67a4f9e94c0dcf1bf9 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Tue, 26 Nov 2024 16:13:36 -0800
Subject: [PATCH 01/13] add initial flow for installing a font

---
 .../v1.10.0/manifest.installer.1.10.0.json    |  6 ++-
 .../v1.10.0/manifest.singleton.1.10.0.json    |  6 ++-
 .../AppInstallerCLICore.vcxproj               |  2 +
 .../AppInstallerCLICore.vcxproj.filters       |  6 +++
 .../Commands/FontCommand.cpp                  | 49 +++++++++++++++++++
 .../Commands/FontCommand.h                    | 18 +++++++
 src/AppInstallerCLICore/FontInstaller.cpp     | 25 ++++++++++
 src/AppInstallerCLICore/FontInstaller.h       | 21 ++++++++
 src/AppInstallerCLICore/Resources.h           |  2 +
 .../Workflows/DownloadFlow.cpp                |  1 +
 .../Workflows/FontFlow.cpp                    |  4 ++
 src/AppInstallerCLICore/Workflows/FontFlow.h  | 12 +++++
 .../Workflows/InstallFlow.cpp                 | 14 ++++++
 .../Workflows/InstallFlow.h                   |  6 +++
 .../Shared/Strings/en-us/winget.resw          | 12 +++--
 .../Public/winget/ManifestCommon.h            |  1 +
 .../Public/AppInstallerErrors.h               |  1 +
 .../PackageManager.idl                        |  2 +
 18 files changed, 181 insertions(+), 7 deletions(-)
 create mode 100644 src/AppInstallerCLICore/FontInstaller.cpp
 create mode 100644 src/AppInstallerCLICore/FontInstaller.h

diff --git a/schemas/JSON/manifests/v1.10.0/manifest.installer.1.10.0.json b/schemas/JSON/manifests/v1.10.0/manifest.installer.1.10.0.json
index c64358a9e0..fc5281d36b 100644
--- a/schemas/JSON/manifests/v1.10.0/manifest.installer.1.10.0.json
+++ b/schemas/JSON/manifests/v1.10.0/manifest.installer.1.10.0.json
@@ -65,7 +65,8 @@
         "wix",
         "burn",
         "pwa",
-        "portable"
+        "portable",
+        "font"
       ],
       "description": "Enumeration of supported installer types. InstallerType is required in either root level or individual Installer level"
     },
@@ -80,7 +81,8 @@
         "nullsoft",
         "wix",
         "burn",
-        "portable"
+        "portable",
+        "font"
       ],
       "description": "Enumeration of supported nested installer types contained inside an archive file"
     },
diff --git a/schemas/JSON/manifests/v1.10.0/manifest.singleton.1.10.0.json b/schemas/JSON/manifests/v1.10.0/manifest.singleton.1.10.0.json
index 084bafedd5..1e66baf7c3 100644
--- a/schemas/JSON/manifests/v1.10.0/manifest.singleton.1.10.0.json
+++ b/schemas/JSON/manifests/v1.10.0/manifest.singleton.1.10.0.json
@@ -167,7 +167,8 @@
         "wix",
         "burn",
         "pwa",
-        "portable"
+        "portable",
+        "font"
       ],
       "description": "Enumeration of supported installer types. InstallerType is required in either root level or individual Installer level"
     },
@@ -182,7 +183,8 @@
         "nullsoft",
         "wix",
         "burn",
-        "portable"
+        "portable",
+        "font"
       ],
       "description": "Enumeration of supported nested installer types contained inside an archive file"
     },
diff --git a/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj b/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj
index 45c9c0fa04..cfff631fb3 100644
--- a/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj
+++ b/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj
@@ -398,6 +398,7 @@
     <ClInclude Include="ExecutionContext.h" />
     <ClInclude Include="ExecutionProgress.h" />
     <ClInclude Include="ExecutionReporter.h" />
+    <ClInclude Include="FontInstaller.h" />    
     <ClInclude Include="Invocation.h" />
     <ClInclude Include="pch.h" />
     <ClInclude Include="PortableInstaller.h" />
@@ -483,6 +484,7 @@
     <ClCompile Include="ExecutionContext.cpp" />
     <ClCompile Include="ExecutionProgress.cpp" />
     <ClCompile Include="ExecutionReporter.cpp" />
+    <ClCompile Include="FontInstaller.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader>Create</PrecompiledHeader>
     </ClCompile>
diff --git a/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters b/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters
index a8f48edd34..e5942dd17c 100644
--- a/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters
+++ b/src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters
@@ -266,6 +266,9 @@
     <ClInclude Include="Workflows\FontFlow.h">
       <Filter>Workflows</Filter>
     </ClInclude>
+    <ClInclude Include="FontInstaller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="pch.cpp">
@@ -502,6 +505,9 @@
     <ClCompile Include="Workflows\FontFlow.cpp">
       <Filter>Workflows</Filter>
     </ClCompile>
+    <ClCompile Include="FontInstaller.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="PropertySheet.props" />
diff --git a/src/AppInstallerCLICore/Commands/FontCommand.cpp b/src/AppInstallerCLICore/Commands/FontCommand.cpp
index c6faae5b44..2804e7aabf 100644
--- a/src/AppInstallerCLICore/Commands/FontCommand.cpp
+++ b/src/AppInstallerCLICore/Commands/FontCommand.cpp
@@ -5,6 +5,7 @@
 #include "Workflows/CompletionFlow.h"
 #include "Workflows/WorkflowBase.h"
 #include "Workflows/FontFlow.h"
+#include "Workflows/InstallFlow.h"
 #include "Resources.h"
 
 namespace AppInstaller::CLI
@@ -43,6 +44,54 @@ namespace AppInstaller::CLI
         OutputHelp(context.Reporter);
     }
 
+    std::vector<Argument> FontInstallCommand::GetArguments() const
+    {
+        return {
+            Argument::ForType(Args::Type::Manifest),
+            Argument{ Args::Type::InstallScope, Resource::String::InstallScopeDescription, ArgumentType::Standard, Argument::Visibility::Help },
+            Argument::ForType(Args::Type::Force),
+        };
+    }
+
+    Resource::LocString FontInstallCommand::ShortDescription() const
+    {
+        return { Resource::String::FontInstallCommandShortDescription };
+    }
+
+    Resource::LocString FontInstallCommand::LongDescription() const
+    {
+        return { Resource::String::FontInstallCommandLongDescription };
+    }
+
+    void FontInstallCommand::Complete(Execution::Context& context, Args::Type valueType) const
+    {
+        UNREFERENCED_PARAMETER(valueType);
+        context.Reporter.Error() << Resource::String::PendingWorkError << std::endl;
+        THROW_HR(E_NOTIMPL);
+    }
+
+    Utility::LocIndView FontInstallCommand::HelpLink() const
+    {
+        return s_FontCommand_HelpLink;
+    }
+
+    void FontInstallCommand::ValidateArgumentsInternal(Execution::Args& execArgs) const
+    {
+        Argument::ValidateCommonArguments(execArgs);
+    }
+
+    void FontInstallCommand::ExecuteInternal(Execution::Context& context) const
+    {
+        if (context.Args.Contains(Execution::Args::Type::Manifest))
+        {
+            context <<
+                Workflow::ReportExecutionStage(ExecutionStage::Discovery) <<
+                Workflow::GetManifestFromArg <<
+                Workflow::SelectInstaller <<
+                Workflow::InstallSinglePackage;
+        }
+    }
+
     std::vector<Argument> FontListCommand::GetArguments() const
     {
         return {
diff --git a/src/AppInstallerCLICore/Commands/FontCommand.h b/src/AppInstallerCLICore/Commands/FontCommand.h
index c29f703f6c..741821cd9c 100644
--- a/src/AppInstallerCLICore/Commands/FontCommand.h
+++ b/src/AppInstallerCLICore/Commands/FontCommand.h
@@ -21,6 +21,24 @@ namespace AppInstaller::CLI
         void ExecuteInternal(Execution::Context& context) const override;
     };
 
+    struct FontInstallCommand final : public Command
+    {
+        FontInstallCommand(std::string_view parent) : Command("install", parent) {}
+
+        std::vector<Argument> GetArguments() const override;
+
+        Resource::LocString ShortDescription() const override;
+        Resource::LocString LongDescription() const override;
+
+        void Complete(Execution::Context& context, Execution::Args::Type valueType) const override;
+
+        Utility::LocIndView HelpLink() const override;
+
+    protected:
+        void ValidateArgumentsInternal(Execution::Args& execArgs) const override;
+        void ExecuteInternal(Execution::Context& context) const override;
+    };
+
     struct FontListCommand final : public Command
     {
         FontListCommand(std::string_view parent) : Command("list", parent) {}
diff --git a/src/AppInstallerCLICore/FontInstaller.cpp b/src/AppInstallerCLICore/FontInstaller.cpp
new file mode 100644
index 0000000000..90a7d58033
--- /dev/null
+++ b/src/AppInstallerCLICore/FontInstaller.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "ExecutionContext.h"
+#include "FontInstaller.h"
+#include <winget/Manifest.h>
+#include <winget/ManifestCommon.h>
+#include <winget/Filesystem.h>
+#include <AppInstallerErrors.h>
+#include <AppInstallerRuntime.h>
+
+namespace AppInstaller::CLI::Font
+{
+    FontInstaller::FontInstaller(const std::string& familyName, Manifest::ScopeEnum scope)
+    {
+        m_scope = scope;
+        m_familyName = familyName;
+
+        // Get the expected state from the family name and scope. 
+    }
+
+    void FontInstaller::Install()
+    {
+    }
+}
diff --git a/src/AppInstallerCLICore/FontInstaller.h b/src/AppInstallerCLICore/FontInstaller.h
new file mode 100644
index 0000000000..fb46ff19cb
--- /dev/null
+++ b/src/AppInstallerCLICore/FontInstaller.h
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+#include <filesystem>
+
+namespace AppInstaller::CLI::Font
+{
+    // Object representation of the metadata and functionality required for installing a font package. 
+    struct FontInstaller
+    {
+        std::filesystem::path FontFileLocation;
+
+        FontInstaller(const std::string& familyName, Manifest::ScopeEnum scope);
+
+        void Install();
+
+    private:
+        Manifest::ScopeEnum m_scope;
+        std::string m_familyName;
+    };
+}
diff --git a/src/AppInstallerCLICore/Resources.h b/src/AppInstallerCLICore/Resources.h
index 0765d9f0d8..299aab16d4 100644
--- a/src/AppInstallerCLICore/Resources.h
+++ b/src/AppInstallerCLICore/Resources.h
@@ -256,6 +256,8 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(FontFamily);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFamilyNameArgumentDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFilePaths);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandLongDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandShortDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandLongDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandShortDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontVersion);
diff --git a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
index 084cbb4d3f..456525e2ee 100644
--- a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
@@ -223,6 +223,7 @@ namespace AppInstaller::CLI::Workflow
             case InstallerTypeEnum::Portable: 
             case InstallerTypeEnum::Wix:
             case InstallerTypeEnum::Zip:
+            case InstallerTypeEnum::Font:
                 context << DownloadInstallerFile;
                 break;
             case InstallerTypeEnum::Msix:
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.cpp b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
index ce9bb7a233..f3defe3395 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
@@ -121,4 +121,8 @@ namespace AppInstaller::CLI::Workflow
             OutputInstalledFontFamiliesTable(context, lines);
         }
     }
+
+    void FontInstallImpl(Execution::Context& context)
+    {
+    }
 }
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.h b/src/AppInstallerCLICore/Workflows/FontFlow.h
index c3346e1a60..ce98099b5a 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.h
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.h
@@ -10,4 +10,16 @@ namespace AppInstaller::CLI::Workflow
     // Inputs: None
     // Outputs: None
     void ReportInstalledFonts(Execution::Context& context);
+
+    // Installs the font package.
+    // Required Args: None
+    // Inputs: Manifest, Scope, Rename, Location
+    // Outputs: None
+    void FontInstallImpl(Execution::Context& context);
+
+    // Initializes the font installer.
+    // Required Args: None
+    // Inputs: Scope, Manifest, Installer
+    // Outputs: None
+    void InitializeFontInstaller(Execution::Context& context);
 }
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
index e85540c379..ae633643cd 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
@@ -276,6 +276,18 @@ namespace AppInstaller::CLI::Workflow
                 VerifyAndSetNestedInstaller <<
                 ExecuteInstallerForType(context.Get<Execution::Data::Installer>().value().NestedInstallerType);
         }
+
+        // Runs the flow for installing a font package.
+        // Required Args: None
+        // Inputs: Installer, InstallerPath
+        // Outputs: None
+        void FontInstall(Execution::Context& context)
+        {
+            context <<
+                InitializeFontInstaller <<
+                FontInstallImpl <<
+                ReportInstallerResult("Font"sv, APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, true);
+        }
     }
 
     bool ExemptFromSingleInstallLocking(InstallerTypeEnum type)
@@ -443,6 +455,8 @@ namespace AppInstaller::CLI::Workflow
         case InstallerTypeEnum::Zip:
             context << details::ArchiveInstall;
             break;
+        case InstallerTypeEnum::Font:
+            context << details::FontInstall;
         default:
             THROW_HR(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
         }
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.h b/src/AppInstallerCLICore/Workflows/InstallFlow.h
index cbc0ce70bc..30ac06dffe 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.h
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.h
@@ -49,6 +49,12 @@ namespace AppInstaller::CLI::Workflow
         // Inputs: Installer, InstallerPath, Manifest
         // Outputs: None
         void ArchiveInstall(Execution::Context& context);
+
+        // Runs the flow for intsalling a font package.
+        // Required Args: None
+        // Inputs: Installer, InstallerPath, Manifest
+        // Outputs: None
+        void FontInstall(Execution::Context& context);
     }
 
     // Ensures that there is an applicable installer.
diff --git a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
index 7897bb985a..3f8f2c2f53 100644
--- a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
+++ b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
@@ -1812,7 +1812,7 @@ Please specify one of them using the --source option to proceed.</value>
   <data name="ConfigurationSuccessfullyApplied" xml:space="preserve">
     <value>Configuration successfully applied.</value>
   </data>
-	<data name="ConfigurationUnitSuccessfullyApplied" xml:space="preserve">
+  <data name="ConfigurationUnitSuccessfullyApplied" xml:space="preserve">
     <value>Unit successfully applied.</value>
   </data>
   <data name="ConfigurationWaitingOnAnother" xml:space="preserve">
@@ -3147,7 +3147,7 @@ Please specify one of them using the --source option to proceed.</value>
   </data>
   <data name="InstallerZeroByteFile" xml:space="preserve">
     <value>Downloaded zero byte installer; ensure that your network connection is working properly.</value>
-  </data>  
+  </data>
   <data name="FontCommandShortDescription" xml:space="preserve">
     <value>Manage fonts</value>
   </data>
@@ -3183,4 +3183,10 @@ Please specify one of them using the --source option to proceed.</value>
   <data name="FontVersion" xml:space="preserve">
     <value>Version</value>
   </data>
-</root>
+  <data name="FontInstallCommandShortDescription" xml:space="preserve">
+    <value>Install a font</value>
+  </data>
+  <data name="FontInstallCommandLongDescription" xml:space="preserve">
+    <value>Installs the selected font package, either found by searching a configured source or directly from a manifest.</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h b/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
index dc6b83bc2b..07e23db191 100644
--- a/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
+++ b/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
@@ -100,6 +100,7 @@ namespace AppInstaller::Manifest
         Burn,
         MSStore,
         Portable,
+        Font,
     };
 
     enum class UpdateBehaviorEnum
diff --git a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
index 3524d812bf..69446aed11 100644
--- a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
+++ b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
@@ -152,6 +152,7 @@
 #define APPINSTALLER_CLI_ERROR_SFSCLIENT_PACKAGE_NOT_SUPPORTED      ((HRESULT)0x8A150084)
 #define APPINSTALLER_CLI_ERROR_LICENSING_API_FAILED_FORBIDDEN       ((HRESULT)0x8A150085)
 #define APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE             ((HRESULT)0x8A150086)
+#define APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED                  ((HRESULT)0x8A150087)
 
 // Install errors.
 #define APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE                   ((HRESULT)0x8A150101)
diff --git a/src/Microsoft.Management.Deployment/PackageManager.idl b/src/Microsoft.Management.Deployment/PackageManager.idl
index 943177fc45..2b3012328f 100644
--- a/src/Microsoft.Management.Deployment/PackageManager.idl
+++ b/src/Microsoft.Management.Deployment/PackageManager.idl
@@ -467,6 +467,8 @@ namespace Microsoft.Management.Deployment
         MSStore,
         /// Portable type.
         Portable,
+        /// Font type.
+        Font,
     };
 
     /// The package installer scope.

From 42e53bfbd28ba25719517879f3393dff30b247c3 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Mon, 2 Dec 2024 16:37:16 -0800
Subject: [PATCH 02/13] initial implementaiton for font installer

---
 src/AppInstallerCLICore/FontInstaller.cpp     | 35 ++++++++++++---
 src/AppInstallerCLICore/FontInstaller.h       | 10 ++---
 .../Workflows/DownloadFlow.cpp                |  2 +
 .../Workflows/FontFlow.cpp                    | 36 +++++++++++++++
 src/AppInstallerCLICore/Workflows/FontFlow.h  |  6 ---
 .../Workflows/InstallFlow.cpp                 |  3 +-
 src/AppInstallerCommonCore/Fonts.cpp          | 44 +++++++++++++++++--
 .../Manifest/ManifestCommon.cpp               |  9 +++-
 .../Public/winget/Fonts.h                     |  6 +++
 9 files changed, 129 insertions(+), 22 deletions(-)

diff --git a/src/AppInstallerCLICore/FontInstaller.cpp b/src/AppInstallerCLICore/FontInstaller.cpp
index 90a7d58033..e045e75ad0 100644
--- a/src/AppInstallerCLICore/FontInstaller.cpp
+++ b/src/AppInstallerCLICore/FontInstaller.cpp
@@ -11,15 +11,40 @@
 
 namespace AppInstaller::CLI::Font
 {
-    FontInstaller::FontInstaller(const std::string& familyName, Manifest::ScopeEnum scope)
+    namespace
     {
-        m_scope = scope;
-        m_familyName = familyName;
+        constexpr std::wstring_view s_FontsPathSubkey = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
+    }
+
 
-        // Get the expected state from the family name and scope. 
+    FontInstaller::FontInstaller(Manifest::ScopeEnum scope) : m_scope(scope)
+    {
+        if (scope == Manifest::ScopeEnum::Machine)
+        {
+            m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsMachineInstallLocation);
+            m_key = Registry::Key::OpenIfExists(HKEY_LOCAL_MACHINE, std::wstring{ s_FontsPathSubkey });
+        }
+        else
+        {
+            m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsUserInstallLocation);
+            m_key = Registry::Key::OpenIfExists(HKEY_CURRENT_USER, std::wstring{ s_FontsPathSubkey });
+        }
     }
 
-    void FontInstaller::Install()
+    void FontInstaller::Install(const std::map<std::wstring, std::filesystem::path> fontFiles)
     {
+        // TODO: Get all font files and check if font file already exists.
+        for (const auto& [fontName, fontFilePath] : fontFiles)
+        {
+            std::filesystem::path fileName = fontFilePath.filename();
+            std::filesystem::path fontFileInstallationPath = m_installLocation / fileName;
+
+            AICLI_LOG(CLI, Info, << "Moving font file to: " << fontFileInstallationPath.u8string());
+            AppInstaller::Filesystem::RenameFile(fontFilePath, fontFileInstallationPath);
+
+            // TODO: Need to fix access permission for writing to the registry.
+            AICLI_LOG(CLI, Info, << "Creating font subkey for: " << AppInstaller::Utility::ConvertToUTF8(fontName));
+            m_key.SetValue(fontName, fontFileInstallationPath, REG_SZ);
+        }
     }
 }
diff --git a/src/AppInstallerCLICore/FontInstaller.h b/src/AppInstallerCLICore/FontInstaller.h
index fb46ff19cb..1168185889 100644
--- a/src/AppInstallerCLICore/FontInstaller.h
+++ b/src/AppInstallerCLICore/FontInstaller.h
@@ -5,17 +5,17 @@
 
 namespace AppInstaller::CLI::Font
 {
-    // Object representation of the metadata and functionality required for installing a font package. 
     struct FontInstaller
     {
-        std::filesystem::path FontFileLocation;
+        FontInstaller(Manifest::ScopeEnum scope);
 
-        FontInstaller(const std::string& familyName, Manifest::ScopeEnum scope);
+        std::filesystem::path FontFileLocation;
 
-        void Install();
+        void Install(const std::map<std::wstring, std::filesystem::path> fontFiles);
 
     private:
         Manifest::ScopeEnum m_scope;
-        std::string m_familyName;
+        std::filesystem::path m_installLocation;
+        Registry::Key m_key;
     };
 }
diff --git a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
index 456525e2ee..cf483626ed 100644
--- a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
@@ -57,6 +57,8 @@ namespace AppInstaller::CLI::Workflow
                 return L".msix"sv;
             case InstallerTypeEnum::Zip:
                 return L".zip"sv;
+            case InstallerTypeEnum::Font:
+                return L".ttf"sv;
             default:
                 THROW_HR(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
             }
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.cpp b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
index f3defe3395..1d6c7ee8c1 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
@@ -5,10 +5,12 @@
 #include "TableOutput.h"
 #include <winget/Fonts.h>
 #include <AppInstallerRuntime.h>
+#include <FontInstaller.h>
 
 namespace AppInstaller::CLI::Workflow
 {
     using namespace AppInstaller::CLI::Execution;
+    using namespace AppInstaller::CLI::Font;
 
     namespace
     {
@@ -124,5 +126,39 @@ namespace AppInstaller::CLI::Workflow
 
     void FontInstallImpl(Execution::Context& context)
     {
+        Manifest::ScopeEnum scope = AppInstaller::Manifest::ConvertToScopeEnum(context.Args.GetArg(Execution::Args::Type::InstallScope));
+        FontInstaller fontInstaller = FontInstaller(scope);
+        std::filesystem::path& installerPath = context.Get<Execution::Data::InstallerPath>();
+        std::map<std::wstring, std::filesystem::path> fontFileMap{};
+
+        try
+        {
+            context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
+
+            // InstallerPath will point to a directory if it is extracted from an archive.
+            if (std::filesystem::is_directory(installerPath))
+            {
+                const std::vector<Manifest::NestedInstallerFile>& nestedInstallerFiles = context.Get<Execution::Data::Installer>()->NestedInstallerFiles;
+
+                for (const auto& nestedInstallerFile : nestedInstallerFiles)
+                { 
+                    const std::filesystem::path& fontFilePath = installerPath / ConvertToUTF16(nestedInstallerFile.RelativeFilePath);
+                    auto fontFileEntryName = AppInstaller::Fonts::GetFontFileTitle(fontFilePath);
+                    fontFileMap.emplace(fontFileEntryName, fontFilePath);
+                }
+            }
+            else
+            {
+                auto fontName = AppInstaller::Fonts::GetFontFileTitle(installerPath);
+                fontFileMap.emplace(fontName, installerPath);
+            }
+
+            fontInstaller.Install(fontFileMap);
+            context.Add<Execution::Data::OperationReturnCode>(ERROR_SUCCESS);
+        }
+        catch (...)
+        {
+            context.Add<Execution::Data::OperationReturnCode>(Workflow::HandleException(context, std::current_exception()));
+        }
     }
 }
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.h b/src/AppInstallerCLICore/Workflows/FontFlow.h
index ce98099b5a..5ad5e0a2e8 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.h
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.h
@@ -16,10 +16,4 @@ namespace AppInstaller::CLI::Workflow
     // Inputs: Manifest, Scope, Rename, Location
     // Outputs: None
     void FontInstallImpl(Execution::Context& context);
-
-    // Initializes the font installer.
-    // Required Args: None
-    // Inputs: Scope, Manifest, Installer
-    // Outputs: None
-    void InitializeFontInstaller(Execution::Context& context);
 }
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
index ae633643cd..dcd299340e 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
@@ -3,6 +3,7 @@
 #include "pch.h"
 #include "InstallFlow.h"
 #include "DownloadFlow.h"
+#include "FontFlow.h"
 #include "UninstallFlow.h"
 #include "UpdateFlow.h"
 #include "ResumeFlow.h"
@@ -284,7 +285,6 @@ namespace AppInstaller::CLI::Workflow
         void FontInstall(Execution::Context& context)
         {
             context <<
-                InitializeFontInstaller <<
                 FontInstallImpl <<
                 ReportInstallerResult("Font"sv, APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, true);
         }
@@ -457,6 +457,7 @@ namespace AppInstaller::CLI::Workflow
             break;
         case InstallerTypeEnum::Font:
             context << details::FontInstall;
+            break;
         default:
             THROW_HR(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
         }
diff --git a/src/AppInstallerCommonCore/Fonts.cpp b/src/AppInstallerCommonCore/Fonts.cpp
index 6f5f328f93..08625d1623 100644
--- a/src/AppInstallerCommonCore/Fonts.cpp
+++ b/src/AppInstallerCommonCore/Fonts.cpp
@@ -4,6 +4,8 @@
 #include <AppInstallerStrings.h>
 #include <winget/Fonts.h>
 #include <winget/Locale.h>
+#include <ShObjIdl_core.h>
+#include <propkey.h>
 
 namespace AppInstaller::Fonts
 {
@@ -49,15 +51,13 @@ namespace AppInstaller::Fonts
     FontCatalog::FontCatalog()
     {
         m_preferredLocales = AppInstaller::Locale::GetUserPreferredLanguagesUTF16();
+        THROW_IF_FAILED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(m_factory), m_factory.put_unknown()));
     }
 
     std::vector<FontFamily> FontCatalog::GetInstalledFontFamilies(std::optional<std::wstring> familyName)
     {
-        wil::com_ptr<IDWriteFactory7> factory;
-        THROW_IF_FAILED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(factory), factory.put_unknown()));
-
         wil::com_ptr<IDWriteFontCollection> collection;
-        THROW_IF_FAILED(factory->GetSystemFontCollection(collection.addressof(), FALSE));
+        THROW_IF_FAILED(m_factory->GetSystemFontCollection(collection.addressof(), FALSE));
 
         std::vector<FontFamily> installedFontFamilies;
 
@@ -85,6 +85,20 @@ namespace AppInstaller::Fonts
         return installedFontFamilies;
     }
 
+    bool FontCatalog::IsValidFontFile(const std::filesystem::path& filePath)
+    {
+        wil::com_ptr<IDWriteFontFile> fontFile;
+        THROW_IF_FAILED(m_factory->CreateFontFileReference(filePath.c_str(), NULL, &fontFile));
+
+        BOOL isValid;
+        DWRITE_FONT_FILE_TYPE fileType;
+        DWRITE_FONT_FACE_TYPE faceType;
+        UINT32 numOfFaces;
+        THROW_IF_FAILED(fontFile->Analyze(&isValid, &fileType, &faceType, &numOfFaces));
+
+        return isValid;
+    }
+
     std::wstring FontCatalog::GetLocalizedStringFromFont(const wil::com_ptr<IDWriteLocalizedStrings>& localizedStringCollection)
     {
         UINT32 index = 0;
@@ -172,4 +186,26 @@ namespace AppInstaller::Fonts
         fontFamily.Faces = std::move(fontFaces);
         return fontFamily;
     }
+
+    std::wstring GetFontFileTitle(const std::filesystem::path& fontFilePath)
+    {
+        auto co_unitialize = wil::CoInitializeEx();
+        IPropertyStore* pps = nullptr;
+        std::wstring title;
+        HRESULT hr = SHGetPropertyStoreFromParsingName(fontFilePath.c_str(), nullptr, GPS_DEFAULT, IID_PPV_ARGS(&pps));
+        if (SUCCEEDED(hr)) {
+            PROPVARIANT prop;
+            PropVariantInit(&prop);
+            hr = pps->GetValue(PKEY_Title, &prop);
+            if (SUCCEEDED(hr)) {
+                title = prop.pwszVal;
+                PropVariantClear(&prop);
+                pps->Release();
+            }
+            PropVariantClear(&prop);
+            pps->Release();
+        }
+
+        return title;
+    }
 }
diff --git a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
index 16e759441c..491d165722 100644
--- a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
+++ b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
@@ -162,6 +162,10 @@ namespace AppInstaller::Manifest
         {
             result = InstallerTypeEnum::Portable;
         }
+        else if (inStrLower == "font")
+        {
+            result = InstallerTypeEnum::Font;
+        }
 
         return result;
     }
@@ -583,6 +587,8 @@ namespace AppInstaller::Manifest
             return "msstore"sv;
         case InstallerTypeEnum::Portable:
             return "portable"sv;
+        case InstallerTypeEnum::Font:
+            return "font"sv;
         }
 
         return "unknown"sv;
@@ -962,7 +968,8 @@ namespace AppInstaller::Manifest
             nestedInstallerType == InstallerTypeEnum::Wix ||
             nestedInstallerType == InstallerTypeEnum::Burn ||
             nestedInstallerType == InstallerTypeEnum::Portable ||
-            nestedInstallerType == InstallerTypeEnum::Msix
+            nestedInstallerType == InstallerTypeEnum::Msix ||
+            nestedInstallerType == InstallerTypeEnum::Font
             );
     }
 
diff --git a/src/AppInstallerCommonCore/Public/winget/Fonts.h b/src/AppInstallerCommonCore/Public/winget/Fonts.h
index 443dea5f7a..396c36a58e 100644
--- a/src/AppInstallerCommonCore/Public/winget/Fonts.h
+++ b/src/AppInstallerCommonCore/Public/winget/Fonts.h
@@ -20,6 +20,8 @@ namespace AppInstaller::Fonts
         std::vector<FontFace> Faces;
     };
 
+    std::wstring GetFontFileTitle(const std::filesystem::path& fontFilePath);
+
     struct FontCatalog
     {
         FontCatalog();
@@ -27,6 +29,9 @@ namespace AppInstaller::Fonts
         // Gets all installed font families on the system. If an exact family name is provided and found, returns the installed font family.
         std::vector<FontFamily> GetInstalledFontFamilies(std::optional<std::wstring> familyName = {});
 
+        // Returns a boolean value indicating whether the specified file path is a valid font file.
+        bool IsValidFontFile(const std::filesystem::path& filePath);
+
     private:
         FontFamily GetFontFamilyByIndex(const wil::com_ptr<IDWriteFontCollection>& collection, UINT32 index);
         std::wstring GetLocalizedStringFromFont(const wil::com_ptr<IDWriteLocalizedStrings>& localizedStringCollection);
@@ -34,6 +39,7 @@ namespace AppInstaller::Fonts
         std::wstring GetFontFaceName(const wil::com_ptr<IDWriteFont>& font);
         Utility::OpenTypeFontVersion GetFontFaceVersion(const wil::com_ptr<IDWriteFont>& font);
 
+        wil::com_ptr<IDWriteFactory7> m_factory;
         std::vector<std::wstring> m_preferredLocales;
     };
 }

From 4efa09f4a1e93d99ef23710a10611d89d0424d33 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Thu, 5 Dec 2024 12:45:22 -0800
Subject: [PATCH 03/13] add tests

---
 .../Commands/FontCommand.cpp                  |   2 +-
 src/AppInstallerCLICore/FontInstaller.cpp     |  55 ++++++++++++----
 src/AppInstallerCLICore/FontInstaller.h       |  14 +++-
 src/AppInstallerCLICore/Resources.h           |   1 +
 .../Workflows/FontFlow.cpp                    |  46 ++++++++-----
 .../AppInstallerCLIE2ETests.csproj            |   2 +
 src/AppInstallerCLIE2ETests/Constants.cs      |   7 ++
 src/AppInstallerCLIE2ETests/FontCommand.cs    |  61 ++++++++++++++++++
 .../Helpers/TestCommon.cs                     |  60 ++++++++++++++++-
 .../Helpers/TestIndex.cs                      |  24 ++++++-
 .../Helpers/TestSetup.cs                      |   6 ++
 src/AppInstallerCLIE2ETests/Test.runsettings  |   6 +-
 .../TestData/AppInstallerTestFont.ttf         | Bin 0 -> 229376 bytes
 .../TestData/Manifests/TestFont.yaml          |  14 ++++
 .../TestData/Manifests/TestInvalidFont.yaml   |  14 ++++
 .../TestData/localsource.json                 |   6 ++
 .../Shared/Strings/en-us/winget.resw          |   3 +
 .../AppInstallerCLITests.vcxproj              |   3 +
 .../AppInstallerCLITests.vcxproj.filters      |   3 +
 src/AppInstallerCLITests/Fonts.cpp            |  24 +++++++
 .../TestData/TestFont.ttf                     | Bin 0 -> 229376 bytes
 src/AppInstallerCommonCore/Fonts.cpp          |  34 ++++------
 .../Manifest/ManifestCommon.cpp               |   2 +
 .../Public/winget/Fonts.h                     |   2 +-
 .../Public/AppInstallerErrors.h               |   1 +
 src/LocalhostWebServer/Startup.cs             |   1 +
 .../Model/InstallerType.cs                    |   3 +-
 27 files changed, 335 insertions(+), 59 deletions(-)
 create mode 100644 src/AppInstallerCLIE2ETests/FontCommand.cs
 create mode 100644 src/AppInstallerCLIE2ETests/TestData/AppInstallerTestFont.ttf
 create mode 100644 src/AppInstallerCLIE2ETests/TestData/Manifests/TestFont.yaml
 create mode 100644 src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
 create mode 100644 src/AppInstallerCLITests/TestData/TestFont.ttf

diff --git a/src/AppInstallerCLICore/Commands/FontCommand.cpp b/src/AppInstallerCLICore/Commands/FontCommand.cpp
index 2804e7aabf..454b7c194e 100644
--- a/src/AppInstallerCLICore/Commands/FontCommand.cpp
+++ b/src/AppInstallerCLICore/Commands/FontCommand.cpp
@@ -21,6 +21,7 @@ namespace AppInstaller::CLI
     {
         return InitializeFromMoveOnly<std::vector<std::unique_ptr<Command>>>({
             std::make_unique<FontListCommand>(FullName()),
+            std::make_unique<FontInstallCommand>(FullName()),
         });
     }
 
@@ -49,7 +50,6 @@ namespace AppInstaller::CLI
         return {
             Argument::ForType(Args::Type::Manifest),
             Argument{ Args::Type::InstallScope, Resource::String::InstallScopeDescription, ArgumentType::Standard, Argument::Visibility::Help },
-            Argument::ForType(Args::Type::Force),
         };
     }
 
diff --git a/src/AppInstallerCLICore/FontInstaller.cpp b/src/AppInstallerCLICore/FontInstaller.cpp
index e045e75ad0..de6d35cc63 100644
--- a/src/AppInstallerCLICore/FontInstaller.cpp
+++ b/src/AppInstallerCLICore/FontInstaller.cpp
@@ -3,6 +3,7 @@
 #include "pch.h"
 #include "ExecutionContext.h"
 #include "FontInstaller.h"
+#include <winget/Fonts.h>
 #include <winget/Manifest.h>
 #include <winget/ManifestCommon.h>
 #include <winget/Filesystem.h>
@@ -14,37 +15,65 @@ namespace AppInstaller::CLI::Font
     namespace
     {
         constexpr std::wstring_view s_FontsPathSubkey = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
-    }
+        constexpr std::wstring_view s_TrueType = L" (TrueType)";
 
+        bool IsTrueTypeFont(DWRITE_FONT_FILE_TYPE fileType)
+        {
+            return (
+                fileType == DWRITE_FONT_FILE_TYPE_TRUETYPE ||
+                fileType == DWRITE_FONT_FILE_TYPE_TRUETYPE_COLLECTION
+                );
+        }
+    }
 
     FontInstaller::FontInstaller(Manifest::ScopeEnum scope) : m_scope(scope)
     {
         if (scope == Manifest::ScopeEnum::Machine)
         {
             m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsMachineInstallLocation);
-            m_key = Registry::Key::OpenIfExists(HKEY_LOCAL_MACHINE, std::wstring{ s_FontsPathSubkey });
+            m_key = Registry::Key::OpenIfExists(HKEY_LOCAL_MACHINE, std::wstring{ s_FontsPathSubkey }, 0, KEY_WRITE );
         }
         else
         {
             m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsUserInstallLocation);
-            m_key = Registry::Key::OpenIfExists(HKEY_CURRENT_USER, std::wstring{ s_FontsPathSubkey });
+            m_key = Registry::Key::OpenIfExists(HKEY_CURRENT_USER, std::wstring{ s_FontsPathSubkey }, 0, KEY_WRITE);
         }
     }
 
-    void FontInstaller::Install(const std::map<std::wstring, std::filesystem::path> fontFiles)
+    void FontInstaller::Install(const std::vector<FontFile>& fontFiles)
     {
-        // TODO: Get all font files and check if font file already exists.
-        for (const auto& [fontName, fontFilePath] : fontFiles)
+        for (const auto& fontFile : fontFiles)
         {
-            std::filesystem::path fileName = fontFilePath.filename();
-            std::filesystem::path fontFileInstallationPath = m_installLocation / fileName;
+            const auto& filePath = fontFile.FilePath;
+            const auto& fileName = filePath.filename();
+            const auto& destinationPath = m_installLocation / fileName;
+
+            AICLI_LOG(CLI, Info, << "Getting Font title");
 
-            AICLI_LOG(CLI, Info, << "Moving font file to: " << fontFileInstallationPath.u8string());
-            AppInstaller::Filesystem::RenameFile(fontFilePath, fontFileInstallationPath);
+            std::wstring title = AppInstaller::Fonts::GetFontFileTitle(filePath);
 
-            // TODO: Need to fix access permission for writing to the registry.
-            AICLI_LOG(CLI, Info, << "Creating font subkey for: " << AppInstaller::Utility::ConvertToUTF8(fontName));
-            m_key.SetValue(fontName, fontFileInstallationPath, REG_SZ);
+            if (IsTrueTypeFont(fontFile.FileType))
+            {
+                title += s_TrueType;
+            }
+
+            AICLI_LOG(CLI, Info, << "Moving font file to: " << destinationPath);
+            AppInstaller::Filesystem::RenameFile(filePath, destinationPath);
+
+            AICLI_LOG(CLI, Info, << "Creating font subkey with name: " << AppInstaller::Utility::ConvertToUTF8(title));
+            if (m_scope == Manifest::ScopeEnum::Machine)
+            {
+                m_key.SetValue(title, fileName, REG_SZ);
+            }
+            else
+            {
+                m_key.SetValue(title, destinationPath, REG_SZ);
+            }
         }
     }
+
+    void FontInstaller::Uninstall(const std::wstring& familyName)
+    {
+        UNREFERENCED_PARAMETER(familyName);
+    }
 }
diff --git a/src/AppInstallerCLICore/FontInstaller.h b/src/AppInstallerCLICore/FontInstaller.h
index 1168185889..9f548e0908 100644
--- a/src/AppInstallerCLICore/FontInstaller.h
+++ b/src/AppInstallerCLICore/FontInstaller.h
@@ -2,16 +2,28 @@
 // Licensed under the MIT License.
 #pragma once
 #include <filesystem>
+#include <winget/Fonts.h>
 
 namespace AppInstaller::CLI::Font
 {
+    struct FontFile
+    {
+        FontFile(std::filesystem::path filePath, DWRITE_FONT_FILE_TYPE fileType)
+            : FilePath(filePath), FileType(fileType) {}
+
+        std::filesystem::path FilePath;
+        DWRITE_FONT_FILE_TYPE FileType;
+    };
+
     struct FontInstaller
     {
         FontInstaller(Manifest::ScopeEnum scope);
 
         std::filesystem::path FontFileLocation;
 
-        void Install(const std::map<std::wstring, std::filesystem::path> fontFiles);
+        void Install(const std::vector<FontFile>& fontFiles);
+
+        void Uninstall(const std::wstring& familyName);
 
     private:
         Manifest::ScopeEnum m_scope;
diff --git a/src/AppInstallerCLICore/Resources.h b/src/AppInstallerCLICore/Resources.h
index 299aab16d4..335751e5e9 100644
--- a/src/AppInstallerCLICore/Resources.h
+++ b/src/AppInstallerCLICore/Resources.h
@@ -255,6 +255,7 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(FontFaces);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFamily);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFamilyNameArgumentDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFileNotSupported);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFilePaths);
         WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandLongDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandShortDescription);
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.cpp b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
index 1d6c7ee8c1..1d1a1c12b5 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
@@ -126,34 +126,50 @@ namespace AppInstaller::CLI::Workflow
 
     void FontInstallImpl(Execution::Context& context)
     {
-        Manifest::ScopeEnum scope = AppInstaller::Manifest::ConvertToScopeEnum(context.Args.GetArg(Execution::Args::Type::InstallScope));
-        FontInstaller fontInstaller = FontInstaller(scope);
-        std::filesystem::path& installerPath = context.Get<Execution::Data::InstallerPath>();
-        std::map<std::wstring, std::filesystem::path> fontFileMap{};
-
         try
         {
-            context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
+            const auto& installerPath = context.Get<Execution::Data::InstallerPath>();
+            std::vector<std::filesystem::path> filePaths;
 
-            // InstallerPath will point to a directory if it is extracted from an archive.
+            // InstallerPath will point to a directory if extracted from an archive.
             if (std::filesystem::is_directory(installerPath))
             {
                 const std::vector<Manifest::NestedInstallerFile>& nestedInstallerFiles = context.Get<Execution::Data::Installer>()->NestedInstallerFiles;
-
                 for (const auto& nestedInstallerFile : nestedInstallerFiles)
-                { 
-                    const std::filesystem::path& fontFilePath = installerPath / ConvertToUTF16(nestedInstallerFile.RelativeFilePath);
-                    auto fontFileEntryName = AppInstaller::Fonts::GetFontFileTitle(fontFilePath);
-                    fontFileMap.emplace(fontFileEntryName, fontFilePath);
+                {
+                    filePaths.emplace_back(installerPath / ConvertToUTF16(nestedInstallerFile.RelativeFilePath));
                 }
             }
             else
             {
-                auto fontName = AppInstaller::Fonts::GetFontFileTitle(installerPath);
-                fontFileMap.emplace(fontName, installerPath);
+                filePaths.emplace_back(installerPath);
             }
 
-            fontInstaller.Install(fontFileMap);
+            std::vector<FontFile> fontFiles;
+            Fonts::FontCatalog fontCatalog;
+
+            for (const auto& file : filePaths)
+            {
+                DWRITE_FONT_FILE_TYPE fileType;
+                if (!fontCatalog.IsFontFileSupported(file, fileType))
+                {
+                    AICLI_LOG(CLI, Warning, << "Font file is not supported: " << file);
+                    context.Reporter.Error() << Resource::String::FontFileNotSupported << std::endl;
+                    AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED);
+                }
+                else
+                {
+                    AICLI_LOG(CLI, Warning, << "Font file is supported: " << file);
+                    fontFiles.emplace_back(FontFile(file, fileType));
+                }
+            }
+
+            context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
+
+            Manifest::ScopeEnum scope = AppInstaller::Manifest::ConvertToScopeEnum(context.Args.GetArg(Execution::Args::Type::InstallScope));
+            FontInstaller fontInstaller = FontInstaller(scope);
+
+            fontInstaller.Install(fontFiles);
             context.Add<Execution::Data::OperationReturnCode>(ERROR_SUCCESS);
         }
         catch (...)
diff --git a/src/AppInstallerCLIE2ETests/AppInstallerCLIE2ETests.csproj b/src/AppInstallerCLIE2ETests/AppInstallerCLIE2ETests.csproj
index 179ffb1583..5806dd9080 100644
--- a/src/AppInstallerCLIE2ETests/AppInstallerCLIE2ETests.csproj
+++ b/src/AppInstallerCLIE2ETests/AppInstallerCLIE2ETests.csproj
@@ -61,6 +61,8 @@
     <None Remove="TestData\Configuration\ShowDetails_TestRepo_0_3.yml" />
     <None Remove="TestData\Configuration\WithParameters_0_3.yml" />
     <None Remove="TestData\empty" />
+    <None Remove="TestData\Manifests\TestFont.yaml" />
+    <None Remove="TestData\Manifests\TestInvalidFont.yaml" />
     <None Remove="TestData\Manifests\TestUpgradeAddsDependency.1.0.yaml" />
     <None Remove="TestData\Manifests\TestUpgradeAddsDependency.2.0.yaml" />
     <None Remove="TestData\Manifests\TestUpgradeAddsDependencyDependent.1.0.yaml" />
diff --git a/src/AppInstallerCLIE2ETests/Constants.cs b/src/AppInstallerCLIE2ETests/Constants.cs
index 25fcb6d72c..f121fd5103 100644
--- a/src/AppInstallerCLIE2ETests/Constants.cs
+++ b/src/AppInstallerCLIE2ETests/Constants.cs
@@ -27,6 +27,7 @@ public class Constants
         public const string MsiInstallerPathParameter = "MsiTestInstallerPath";
         public const string MsiInstallerV2PathParameter = "MsiTestInstallerV2Path";
         public const string MsixInstallerPathParameter = "MsixTestInstallerPath";
+        public const string FontPathParameter = "FontTestPath";
         public const string PackageCertificatePathParameter = "PackageCertificatePath";
         public const string PowerShellModulePathParameter = "PowerShellModulePath";
         public const string SkipTestSourceParameter = "SkipTestSource";
@@ -55,11 +56,13 @@ public class Constants
         public const string MsiInstaller = "AppInstallerTestMsiInstaller";
         public const string MsixInstaller = "AppInstallerTestMsixInstaller";
         public const string ZipInstaller = "AppInstallerTestZipInstaller";
+        public const string Font = "AppInstallerTestFont";
         public const string ExeInstallerFileName = "AppInstallerTestExeInstaller.exe";
         public const string MsiInstallerFileName = "AppInstallerTestMsiInstaller.msi";
         public const string MsiInstallerV2FileName = "AppInstallerTestMsiInstallerV2.msi";
         public const string MsixInstallerFileName = "AppInstallerTestMsixInstaller.msix";
         public const string ZipInstallerFileName = "AppInstallerTestZipInstaller.zip";
+        public const string FontFileName = "AppInstallerTestFont.ttf";
         public const string ModifyRepairInstaller = "AppInstallerTest.TestModifyRepair";
         public const string IndexPackage = "source.msix";
         public const string MakeAppx = "makeappx.exe";
@@ -118,6 +121,8 @@ public class Constants
         public const string UninstallSubKey = @"Software\Microsoft\Windows\CurrentVersion\Uninstall";
         public const string PathSubKey_User = @"Environment";
         public const string PathSubKey_Machine = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
+        public const string FontsSubKey = @"Software\Microsoft\Windows NT\CurrentVersion\Fonts";
+        public const string TestFontSubKeyName = "Cascadia Code PL (True Type)";
 
         // User settings
         public const string ArchiveExtractionMethod = "archiveExtractionMethod";
@@ -271,6 +276,8 @@ public class ErrorCode
             public const int ERROR_ADMIN_CONTEXT_REPAIR_PROHIBITED = unchecked((int)0x8A15007D);
 
             public const int ERROR_INSTALLER_ZERO_BYTE_FILE = unchecked((int)0x8A150086);
+            public const int ERROR_FONT_INSTALL_FAILED = unchecked((int)0x8A150087);
+            public const int ERROR_FONT_FILE_NOT_SUPPORTED = unchecked((int)0x8A150088);
 
             public const int ERROR_INSTALL_PACKAGE_IN_USE = unchecked((int)0x8A150101);
             public const int ERROR_INSTALL_INSTALL_IN_PROGRESS = unchecked((int)0x8A150102);
diff --git a/src/AppInstallerCLIE2ETests/FontCommand.cs b/src/AppInstallerCLIE2ETests/FontCommand.cs
new file mode 100644
index 0000000000..e32b05b727
--- /dev/null
+++ b/src/AppInstallerCLIE2ETests/FontCommand.cs
@@ -0,0 +1,61 @@
+// -----------------------------------------------------------------------------
+// <copyright file="FontCommand.cs" company="Microsoft Corporation">
+//     Copyright (c) Microsoft Corporation. Licensed under the MIT License.
+// </copyright>
+// -----------------------------------------------------------------------------
+
+namespace AppInstallerCLIE2ETests
+{
+    using AppInstallerCLIE2ETests.Helpers;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Test font command.
+    /// </summary>
+    public class FontCommand : BaseCommand
+    {
+        /// <summary>
+        /// One time set up.
+        /// </summary>
+        [SetUp]
+        public void OneTimeSetup()
+        {
+            WinGetSettingsHelper.ConfigureFeature("fonts", true);
+        }
+
+        /// <summary>
+        /// Test install a font with user scope.
+        /// </summary>
+        [Test]
+        public void InstallFont()
+        {
+            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestFont.yaml")}");
+            Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
+            Assert.True(result.StdOut.Contains("Successfully installed"));
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName);
+        }
+
+        /// <summary>
+        /// Test install a font with machine scope.
+        /// </summary>
+        [Test]
+        public void InstallFont_MachineScope()
+        {
+            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestFont.yaml")} --scope Machine");
+            Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
+            Assert.True(result.StdOut.Contains("Successfully installed"));
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
+        }
+
+        /// <summary>
+        /// Test install an invalid font file.
+        /// </summary>
+        [Test]
+        public void InstallInvalidFont()
+        {
+            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestInvalidFont.yaml")} --scope Machine");
+            Assert.AreEqual(Constants.ErrorCode.ERROR_FONT_FILE_NOT_SUPPORTED, result.ExitCode);
+            Assert.True(result.StdOut.Contains("The font file is not supported and cannot be installed."));
+        }
+    }
+}
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index 88fb61d5c0..658b022baf 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -344,6 +344,64 @@ public static string GetCheckpointsDirectory()
             }
         }
 
+        /// <summary>
+        /// Gets the fonts directory based on scope.
+        /// </summary>
+        /// <param name="scope">Scope.</param>
+        /// <returns>The path of the fonts directory.</returns>
+        public static string GetFontsDirectory(Scope scope)
+        {
+            if (scope == Scope.Machine)
+            {
+                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Fonts");
+            }
+            else
+            {
+                return Path.Combine(Environment.GetEnvironmentVariable("LocalAppData"), "Microsoft", "Windows", "Fonts");
+            }
+        }
+
+        /// <summary>
+        /// Verify font package.
+        /// </summary>
+        /// <param name="fontSubKeyName">Name of the font registry subkey entry.</param>
+        /// <param name="fontFileName">Filename of the installed font file.</param>
+        /// <param name="scope">Scope.</param>
+        /// <param name="shouldExist">Should exist.</param>
+        public static void VerifyFontPackage(
+            string fontSubKeyName,
+            string fontFileName,
+            Scope scope = Scope.User,
+            bool shouldExist = true)
+        {
+            // TODO: Update this function to be able to handle the font uninstall scenario.
+            string expectedFontInstallPath = Path.Combine(GetFontsDirectory(scope), fontFileName);
+            bool fontFileExists = File.Exists(expectedFontInstallPath);
+
+            bool fontEntryExists;
+            RegistryKey baseKey = scope == Scope.Machine ? Registry.LocalMachine : Registry.CurrentUser;
+            using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
+            {
+                RegistryKey fontEntry = fontsRegistryKey.OpenSubKey(fontSubKeyName, true);
+                fontEntryExists = fontEntry != null;
+            }
+
+            if (shouldExist)
+            {
+                // TODO: Replace with font uninstall when implemented.
+                File.Delete(expectedFontInstallPath);
+
+                using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
+                {
+                    fontsRegistryKey.DeleteSubKey(fontSubKeyName);
+                    RegistryKey fontEntry = fontsRegistryKey.OpenSubKey(fontSubKeyName, true);
+                }
+            }
+
+            Assert.AreEqual(shouldExist, fontFileExists, $"Expected font path: {expectedFontInstallPath}");
+            Assert.AreEqual(shouldExist, fontEntryExists, $"Expected {fontSubKeyName} subkey in registry path: {Constants.FontsSubKey}");
+        }
+
         /// <summary>
         /// Verify portable package.
         /// </summary>
@@ -351,7 +409,7 @@ public static string GetCheckpointsDirectory()
         /// <param name="commandAlias">Command alias.</param>
         /// <param name="filename">File name.</param>
         /// <param name="productCode">Product code.</param>
-        /// <param name="shouldExist">Should exists.</param>
+        /// <param name="shouldExist">Should exist.</param>
         /// <param name="scope">Scope.</param>
         /// <param name="installDirectoryAddedToPath">Install directory added to path instead of the symlink directory.</param>
         public static void VerifyPortablePackage(
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestIndex.cs b/src/AppInstallerCLIE2ETests/Helpers/TestIndex.cs
index 2728661e86..d2eb625e7a 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestIndex.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestIndex.cs
@@ -8,7 +8,6 @@ namespace AppInstallerCLIE2ETests.Helpers
 {
     using System;
     using System.IO;
-    using System.Text.Json;
     using Microsoft.WinGetSourceCreator;
     using WinGetSourceCreator.Model;
 
@@ -25,6 +24,7 @@ static TestIndex()
             TestIndex.MsiInstallerV2 = Path.Combine(TestSetup.Parameters.StaticFileRootPath, Constants.MsiInstaller, Constants.MsiInstallerV2FileName);
             TestIndex.MsixInstaller = Path.Combine(TestSetup.Parameters.StaticFileRootPath, Constants.MsixInstaller, Constants.MsixInstallerFileName);
             TestIndex.ZipInstaller = Path.Combine(TestSetup.Parameters.StaticFileRootPath, Constants.ZipInstaller, Constants.ZipInstallerFileName);
+            TestIndex.Font = Path.Combine(TestSetup.Parameters.StaticFileRootPath, Constants.Font, Constants.FontFileName);
         }
 
         /// <summary>
@@ -52,6 +52,11 @@ static TestIndex()
         /// </summary>
         public static string ZipInstaller { get; private set; }
 
+        /// <summary>
+        /// Gets the font file path used by the manifests in the E2E test.
+        /// </summary>
+        public static string Font { get; private set; }
+
         /// <summary>
         /// Generate test source.
         /// </summary>
@@ -99,6 +104,16 @@ public static void GenerateE2ESource()
                 throw new FileNotFoundException(testParams.MsixInstallerPath);
             }
 
+            if (string.IsNullOrEmpty(testParams.FontPath))
+            {
+                throw new ArgumentNullException($"{Constants.FontPathParameter} is required");
+            }
+
+            if (!File.Exists(testParams.FontPath))
+            {
+                throw new FileNotFoundException(testParams.FontPath);
+            }
+
             if (string.IsNullOrEmpty(testParams.PackageCertificatePath))
             {
                 throw new ArgumentNullException($"{Constants.PackageCertificatePathParameter} is required");
@@ -148,6 +163,13 @@ public static void GenerateE2ESource()
                         HashToken = "<MSIXHASH>",
                         SignatureToken = "<SIGNATUREHASH>",
                     },
+                    new LocalInstaller
+                    {
+                        Type = InstallerType.Font,
+                        Name = Path.Combine(Constants.Font, Constants.FontFileName),
+                        Input = testParams.FontPath,
+                        HashToken = "<FONTHASH>",
+                    },
                 },
                 DynamicInstallers = new ()
                 {
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestSetup.cs b/src/AppInstallerCLIE2ETests/Helpers/TestSetup.cs
index b681fc710f..73faa5afcd 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestSetup.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestSetup.cs
@@ -44,6 +44,7 @@ private TestSetup()
             this.MsiInstallerPath = this.InitializeFileParam(Constants.MsiInstallerPathParameter);
             this.MsixInstallerPath = this.InitializeFileParam(Constants.MsixInstallerPathParameter);
             this.MsiInstallerV2Path = this.InitializeFileParam(Constants.MsiInstallerV2PathParameter);
+            this.MsiInstallerV2Path = this.InitializeFileParam(Constants.FontPathParameter);
 
             this.ForcedExperimentalFeatures = this.InitializeStringArrayParam(Constants.ForcedExperimentalFeaturesParameter);
         }
@@ -119,6 +120,11 @@ public static TestSetup Parameters
         /// </summary>
         public string ZipInstallerPath { get; }
 
+        /// <summary>
+        /// Gets the font path.
+        /// </summary>
+        public string FontPath { get; }
+
         /// <summary>
         /// Gets the package cert path.
         /// </summary>
diff --git a/src/AppInstallerCLIE2ETests/Test.runsettings b/src/AppInstallerCLIE2ETests/Test.runsettings
index 6f6079e24e..6c4742a3f4 100644
--- a/src/AppInstallerCLIE2ETests/Test.runsettings
+++ b/src/AppInstallerCLIE2ETests/Test.runsettings
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 
 <RunSettings>
   <!-- 
@@ -18,6 +18,7 @@
     MsiTestInstallerPath: The Msi Installer executable under test.
     MsixTestInstallerPath: The MSIX (or APPX) Installer executable under test.
     ExeTestInstallerPath: The Exe Installer executable under test.
+    FontTestFilePath: The Font package under test.
     PackageCertificatePath: Signing Certificate Path used to certify Index Source Package.
     PowerShellModulePath: Path to the PowerShell module manifest file under test.
     LocalServerCertPathParameter: The cert used for the local server.
@@ -34,9 +35,10 @@
     <Parameter name="MsiTestInstallerPath" value="MsiTestInstaller.msi" />
     <Parameter name="MsixTestInstallerPath" value="MsixTestInstaller.msix" />
     <Parameter name="ExeTestInstallerPath" value="ExeTestInstaller.exe" />
+    <Parameter name="FontTestFilePath" value="TestFont.ttf" />
     <Parameter name="PackageCertificatePath" value="certificate.pfx"/>
     <Parameter name="PowerShellModulePath" value="TestPowerShellModule.psd1" />
     <Parameter name="LocalServerCertPathParameter" value="servercert.cer" />
     <Parameter name="SkipTestSource" value="false" />
   </TestRunParameters>
-</RunSettings>
\ No newline at end of file
+</RunSettings>
diff --git a/src/AppInstallerCLIE2ETests/TestData/AppInstallerTestFont.ttf b/src/AppInstallerCLIE2ETests/TestData/AppInstallerTestFont.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..d71e7b2f30eb7dbaf8601c7eff65040e0d8edfdb
GIT binary patch
literal 229376
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
F{6E?;lG^|P

literal 0
HcmV?d00001

diff --git a/src/AppInstallerCLIE2ETests/TestData/Manifests/TestFont.yaml b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestFont.yaml
new file mode 100644
index 0000000000..950b627294
--- /dev/null
+++ b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestFont.yaml
@@ -0,0 +1,14 @@
+PackageIdentifier: AppInstallerTest.TestFont
+PackageVersion: 1.0.0.0
+PackageName: TestFont
+PackageLocale: en-US
+Publisher: AppInstallerTest
+License: Test
+ShortDescription: E2E test for font install.
+Installers:
+  - Architecture: x64
+    InstallerUrl: https://localhost:5001/TestKit/AppInstallerTestFont/AppInstallerTestFont.ttf
+    InstallerType: font
+    InstallerSha256: <FONTHASH>
+ManifestType: singleton
+ManifestVersion: 1.10.0
diff --git a/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
new file mode 100644
index 0000000000..1535a8264d
--- /dev/null
+++ b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
@@ -0,0 +1,14 @@
+PackageIdentifier: AppInstallerTest.TestInvalidFont
+PackageVersion: 1.0.0.0
+PackageName: TestInvalidFont
+PackageLocale: en-US
+Publisher: AppInstallerTest
+License: Test
+ShortDescription: E2E test for installing an invalid font.
+Installers:
+  - Architecture: x64
+    InstallerUrl: https://localhost:5001/TestKit/AppInstallerTestExeInsatller/AppInstallerTestExeInstaller.exe
+    InstallerType: font
+    InstallerSha256: <EXEHASH>
+ManifestType: singleton
+ManifestVersion: 1.10.0
diff --git a/src/AppInstallerCLIE2ETests/TestData/localsource.json b/src/AppInstallerCLIE2ETests/TestData/localsource.json
index 77eb3bd41d..4090794748 100644
--- a/src/AppInstallerCLIE2ETests/TestData/localsource.json
+++ b/src/AppInstallerCLIE2ETests/TestData/localsource.json
@@ -29,6 +29,12 @@
       "Input": "%BUILD_ARTIFACTSTAGINGDIRECTORY%/AppInstallerTestMsixInstaller.msix",
       "HashToken": "<MSIXHASH>",
       "SignatureToken": "<SIGNATUREHASH>"
+    },
+    {
+      "Type": "font",
+      "Name": "AppInstallerTestFont/AppInstallerTestFont.ttf",
+      "Input": "%BUILD_ARTIFACTSTAGINGDIRECTORY%/AppInstallerTestFont.ttf",
+      "HashToken": "<FONTHASH>"
     }
   ],
   "DynamicInstallers": [
diff --git a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
index 3f8f2c2f53..d4d668f0a1 100644
--- a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
+++ b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
@@ -3189,4 +3189,7 @@ Please specify one of them using the --source option to proceed.</value>
   <data name="FontInstallCommandLongDescription" xml:space="preserve">
     <value>Installs the selected font package, either found by searching a configured source or directly from a manifest.</value>
   </data>
+  <data name="FontFileNotSupported" xml:space="preserve">
+    <value>The font file is not supported and cannot be installed.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj b/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj
index 367e3108a2..25d155a4d9 100644
--- a/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj
+++ b/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj
@@ -1030,6 +1030,9 @@
     <CopyFileToFolders Include="TestData\ContainsEscapeControlCode.yaml">
       <DeploymentContent>true</DeploymentContent>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\TestFont.ttf">
+      <DeploymentContent>true</DeploymentContent>
+    </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\AppInstallerCLICore\AppInstallerCLICore.vcxproj">
diff --git a/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj.filters b/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj.filters
index 50ed22705d..a54b10482d 100644
--- a/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj.filters
+++ b/src/AppInstallerCLITests/AppInstallerCLITests.vcxproj.filters
@@ -1041,5 +1041,8 @@
     <CopyFileToFolders Include="TestData\ContainsEscapeControlCode.yaml">
       <Filter>TestData</Filter>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="TestData\TestFont.ttf">
+      <Filter>TestData</Filter>
+    </CopyFileToFolders>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/AppInstallerCLITests/Fonts.cpp b/src/AppInstallerCLITests/Fonts.cpp
index 81a50791e8..ecfa476a23 100644
--- a/src/AppInstallerCLITests/Fonts.cpp
+++ b/src/AppInstallerCLITests/Fonts.cpp
@@ -8,6 +8,8 @@ using namespace AppInstaller::Fonts;
 using namespace TestCommon;
 
 constexpr std::wstring_view s_testFontName = L"Times New Roman";
+constexpr std::string_view s_FontFile = "TestFont.ttf";
+constexpr std::string_view s_InvalidFontFile = "Installer-Good.msix";
 
 TEST_CASE("GetInstalledFonts", "[fonts]")
 {
@@ -35,3 +37,25 @@ TEST_CASE("GetInvalidFontFamily", "[fonts]")
     REQUIRE_NOTHROW(fontFamily = fontCatalog.GetInstalledFontFamilies(L"Invalid Font"));
     REQUIRE(fontFamily.empty());
 }
+
+TEST_CASE("ValidFontFile", "[fonts]")
+{
+    TestDataFile testFont(s_FontFile);
+    const auto& testFontPath = testFont.GetPath();
+
+    FontCatalog fontCatalog;
+    DWRITE_FONT_FILE_TYPE fontFileType;
+    REQUIRE(fontCatalog.IsFontFileSupported(testFontPath, fontFileType));
+    REQUIRE(fontFileType == DWRITE_FONT_FILE_TYPE::DWRITE_FONT_FILE_TYPE_TRUETYPE);
+}
+
+TEST_CASE("InvalidFontFile", "[fonts]")
+{
+    TestDataFile testFont(s_InvalidFontFile);
+    const auto& testFontPath = testFont.GetPath();
+
+    FontCatalog fontCatalog;
+    DWRITE_FONT_FILE_TYPE fontFileType;
+    REQUIRE_FALSE(fontCatalog.IsFontFileSupported(testFontPath, fontFileType));
+    REQUIRE(fontFileType == DWRITE_FONT_FILE_TYPE::DWRITE_FONT_FILE_TYPE_UNKNOWN);
+}
diff --git a/src/AppInstallerCLITests/TestData/TestFont.ttf b/src/AppInstallerCLITests/TestData/TestFont.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..d71e7b2f30eb7dbaf8601c7eff65040e0d8edfdb
GIT binary patch
literal 229376
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
F{6E?;lG^|P

literal 0
HcmV?d00001

diff --git a/src/AppInstallerCommonCore/Fonts.cpp b/src/AppInstallerCommonCore/Fonts.cpp
index 08625d1623..3c0c60b483 100644
--- a/src/AppInstallerCommonCore/Fonts.cpp
+++ b/src/AppInstallerCommonCore/Fonts.cpp
@@ -85,18 +85,16 @@ namespace AppInstaller::Fonts
         return installedFontFamilies;
     }
 
-    bool FontCatalog::IsValidFontFile(const std::filesystem::path& filePath)
+    bool FontCatalog::IsFontFileSupported(const std::filesystem::path& filePath, DWRITE_FONT_FILE_TYPE& fileType)
     {
         wil::com_ptr<IDWriteFontFile> fontFile;
         THROW_IF_FAILED(m_factory->CreateFontFileReference(filePath.c_str(), NULL, &fontFile));
 
-        BOOL isValid;
-        DWRITE_FONT_FILE_TYPE fileType;
+        BOOL isSupported;
         DWRITE_FONT_FACE_TYPE faceType;
         UINT32 numOfFaces;
-        THROW_IF_FAILED(fontFile->Analyze(&isValid, &fileType, &faceType, &numOfFaces));
-
-        return isValid;
+        THROW_IF_FAILED(fontFile->Analyze(&isSupported, &fileType, &faceType, &numOfFaces));
+        return isSupported;
     }
 
     std::wstring FontCatalog::GetLocalizedStringFromFont(const wil::com_ptr<IDWriteLocalizedStrings>& localizedStringCollection)
@@ -189,23 +187,13 @@ namespace AppInstaller::Fonts
 
     std::wstring GetFontFileTitle(const std::filesystem::path& fontFilePath)
     {
-        auto co_unitialize = wil::CoInitializeEx();
-        IPropertyStore* pps = nullptr;
-        std::wstring title;
-        HRESULT hr = SHGetPropertyStoreFromParsingName(fontFilePath.c_str(), nullptr, GPS_DEFAULT, IID_PPV_ARGS(&pps));
-        if (SUCCEEDED(hr)) {
-            PROPVARIANT prop;
-            PropVariantInit(&prop);
-            hr = pps->GetValue(PKEY_Title, &prop);
-            if (SUCCEEDED(hr)) {
-                title = prop.pwszVal;
-                PropVariantClear(&prop);
-                pps->Release();
-            }
-            PropVariantClear(&prop);
-            pps->Release();
-        }
-
+        wil::com_ptr<IPropertyStore> pPropertyStore;
+        THROW_IF_FAILED(SHGetPropertyStoreFromParsingName(fontFilePath.c_str(), nullptr, GPS_DEFAULT, IID_PPV_ARGS(&pPropertyStore)));
+        PROPVARIANT prop;
+        PropVariantInit(&prop);
+        THROW_IF_FAILED(pPropertyStore->GetValue(PKEY_Title, &prop));
+        std::wstring title = prop.pwszVal;
+        THROW_IF_FAILED(PropVariantClear(&prop));
         return title;
     }
 }
diff --git a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
index 491d165722..c02d042dbe 100644
--- a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
+++ b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
@@ -926,6 +926,7 @@ namespace AppInstaller::Manifest
     bool DoesInstallerTypeIgnoreScopeFromManifest(InstallerTypeEnum installerType)
     {
         return
+            installerType == InstallerTypeEnum::Font ||
             installerType == InstallerTypeEnum::Portable ||
             installerType == InstallerTypeEnum::Msix ||
             installerType == InstallerTypeEnum::MSStore;
@@ -934,6 +935,7 @@ namespace AppInstaller::Manifest
     bool DoesInstallerTypeRequireAdminForMachineScopeInstall(InstallerTypeEnum installerType)
     {
         return
+            installerType == InstallerTypeEnum::Font ||
             installerType == InstallerTypeEnum::Portable ||
             installerType == InstallerTypeEnum::MSStore ||
             installerType == InstallerTypeEnum::Msix;
diff --git a/src/AppInstallerCommonCore/Public/winget/Fonts.h b/src/AppInstallerCommonCore/Public/winget/Fonts.h
index 396c36a58e..40843e4a8f 100644
--- a/src/AppInstallerCommonCore/Public/winget/Fonts.h
+++ b/src/AppInstallerCommonCore/Public/winget/Fonts.h
@@ -30,7 +30,7 @@ namespace AppInstaller::Fonts
         std::vector<FontFamily> GetInstalledFontFamilies(std::optional<std::wstring> familyName = {});
 
         // Returns a boolean value indicating whether the specified file path is a valid font file.
-        bool IsValidFontFile(const std::filesystem::path& filePath);
+        bool IsFontFileSupported(const std::filesystem::path& filePath, DWRITE_FONT_FILE_TYPE& fileType);
 
     private:
         FontFamily GetFontFamilyByIndex(const wil::com_ptr<IDWriteFontCollection>& collection, UINT32 index);
diff --git a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
index 69446aed11..5b69d884f2 100644
--- a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
+++ b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
@@ -153,6 +153,7 @@
 #define APPINSTALLER_CLI_ERROR_LICENSING_API_FAILED_FORBIDDEN       ((HRESULT)0x8A150085)
 #define APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE             ((HRESULT)0x8A150086)
 #define APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED                  ((HRESULT)0x8A150087)
+#define APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED              ((HRESULT)0x8A150088)
 
 // Install errors.
 #define APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE                   ((HRESULT)0x8A150101)
diff --git a/src/LocalhostWebServer/Startup.cs b/src/LocalhostWebServer/Startup.cs
index de71561b2b..48f1fffce1 100644
--- a/src/LocalhostWebServer/Startup.cs
+++ b/src/LocalhostWebServer/Startup.cs
@@ -62,6 +62,7 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
             provider.Mappings[".appx"] = "application/vns.ms-appx";
             provider.Mappings[".appxbundle"] = "application/vns.ms-appx";
             provider.Mappings[".mszyml"] = "application/x-ms-zip-yaml";
+            provider.Mappings[".ttf"] = "application/x-font-ttf";
 
             //Enable static file serving
             app.UseStaticFiles(new StaticFileOptions
diff --git a/src/WinGetSourceCreator/Model/InstallerType.cs b/src/WinGetSourceCreator/Model/InstallerType.cs
index e4a505b677..526b20fc77 100644
--- a/src/WinGetSourceCreator/Model/InstallerType.cs
+++ b/src/WinGetSourceCreator/Model/InstallerType.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace WinGetSourceCreator.Model
@@ -9,5 +9,6 @@ public enum InstallerType
         Exe,
         Msi,
         Zip,
+        Font,
     }
 }

From aeab6472ed8dcd8ab68b13091146ef3588cf6d24 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Thu, 5 Dec 2024 13:10:18 -0800
Subject: [PATCH 04/13] minor fixes

---
 .../Workflows/DownloadFlow.cpp                | 35 +++++++++++--------
 src/AppInstallerSharedLib/Errors.cpp          |  2 ++
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
index cf483626ed..219be19126 100644
--- a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
@@ -57,8 +57,6 @@ namespace AppInstaller::CLI::Workflow
                 return L".msix"sv;
             case InstallerTypeEnum::Zip:
                 return L".zip"sv;
-            case InstallerTypeEnum::Font:
-                return L".ttf"sv;
             default:
                 THROW_HR(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
             }
@@ -73,23 +71,30 @@ namespace AppInstaller::CLI::Workflow
         // Gets the file name that can be used to ShellExecute the file.
         std::filesystem::path GetInstallerPostHashValidationFileName(Execution::Context& context)
         {
+            const auto& installer = context.Get<Execution::Data::Installer>();
+
             // Get file name from download URI
-            std::filesystem::path filename = GetFileNameFromURI(context.Get<Execution::Data::Installer>()->Url);
-            std::wstring_view installerExtension = GetInstallerFileExtension(context);
+            std::filesystem::path filename = GetFileNameFromURI(installer->Url);
 
-            // Assuming that we find a safe stem value in the URI, use it.
-            // This should be extremely common, but just in case fall back to the older name style.
-            if (filename.has_stem() && ((filename.wstring().size() + installerExtension.size()) < MAX_PATH))
+            // Default to URI for fonts since fonts can have multiple file extensions.
+            if (installer->BaseInstallerType != InstallerTypeEnum::Font)
             {
-                filename = filename.stem();
-            }
-            else
-            {
-                const auto& manifest = context.Get<Execution::Data::Manifest>();
-                filename = Utility::ConvertToUTF16(manifest.Id + '.' + manifest.Version);
-            }
+                std::wstring_view installerExtension = GetInstallerFileExtension(context);
 
-            filename += installerExtension;
+                // Assuming that we find a safe stem value in the URI, use it.
+                // This should be extremely common, but just in case fall back to the older name style.
+                if (filename.has_stem() && ((filename.wstring().size() + installerExtension.size()) < MAX_PATH))
+                {
+                    filename = filename.stem();
+                }
+                else
+                {
+                    const auto& manifest = context.Get<Execution::Data::Manifest>();
+                    filename = Utility::ConvertToUTF16(manifest.Id + '.' + manifest.Version);
+                }
+
+                filename += installerExtension;
+            }
 
             // Make file name suitable for file system path
             filename = Utility::ConvertToUTF16(Utility::MakeSuitablePathPart(filename.u8string()));
diff --git a/src/AppInstallerSharedLib/Errors.cpp b/src/AppInstallerSharedLib/Errors.cpp
index 73e81ef12e..58392ad0a4 100644
--- a/src/AppInstallerSharedLib/Errors.cpp
+++ b/src/AppInstallerSharedLib/Errors.cpp
@@ -222,6 +222,8 @@ namespace AppInstaller
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_SFSCLIENT_PACKAGE_NOT_SUPPORTED, "The Microsoft Store package does not support download."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_LICENSING_API_FAILED_FORBIDDEN, "Failed to retrieve Microsoft Store package license. The Microsoft Entra Id account does not have the required privilege."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE, "Downloaded zero byte installer; ensure that your network connection is working properly."),
+            WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, "Failed to install font package"),
+            WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED, "Font file is not supported and cannot be installed."),
 
             // Install errors.
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE, "Application is currently running. Exit the application then try again."),

From e73e8af3de8f4a725f73ff85695574f6ce9f915a Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Fri, 6 Dec 2024 12:58:15 -0800
Subject: [PATCH 05/13] fix localsource.json and spelling

---
 .github/actions/spelling/expect.txt                           | 4 ++++
 src/AppInstallerCLICore/Workflows/InstallFlow.h               | 2 +-
 .../TestData/Manifests/TestInvalidFont.yaml                   | 2 +-
 src/AppInstallerCLIE2ETests/TestData/localsource.json         | 2 +-
 4 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.github/actions/spelling/expect.txt b/.github/actions/spelling/expect.txt
index e1646184d6..669e9de686 100644
--- a/.github/actions/spelling/expect.txt
+++ b/.github/actions/spelling/expect.txt
@@ -427,6 +427,7 @@ pid
 pidl
 pidlist
 PKCS
+PKEY
 pkgmgr
 pkindex
 pkix
@@ -440,7 +441,10 @@ PRIMARYKEY
 processthreads
 productcode
 PRODUCTICON
+propkey
+PROPVARIANT
 proxystub
+pwsz
 pscustomobject
 pseudocode
 PSHOST
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.h b/src/AppInstallerCLICore/Workflows/InstallFlow.h
index 30ac06dffe..cc3df3810f 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.h
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.h
@@ -50,7 +50,7 @@ namespace AppInstaller::CLI::Workflow
         // Outputs: None
         void ArchiveInstall(Execution::Context& context);
 
-        // Runs the flow for intsalling a font package.
+        // Runs the flow for installing a font package.
         // Required Args: None
         // Inputs: Installer, InstallerPath, Manifest
         // Outputs: None
diff --git a/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
index 1535a8264d..4a3807c5bd 100644
--- a/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
+++ b/src/AppInstallerCLIE2ETests/TestData/Manifests/TestInvalidFont.yaml
@@ -7,7 +7,7 @@ License: Test
 ShortDescription: E2E test for installing an invalid font.
 Installers:
   - Architecture: x64
-    InstallerUrl: https://localhost:5001/TestKit/AppInstallerTestExeInsatller/AppInstallerTestExeInstaller.exe
+    InstallerUrl: https://localhost:5001/TestKit/AppInstallerTestExeInstaller/AppInstallerTestExeInstaller.exe
     InstallerType: font
     InstallerSha256: <EXEHASH>
 ManifestType: singleton
diff --git a/src/AppInstallerCLIE2ETests/TestData/localsource.json b/src/AppInstallerCLIE2ETests/TestData/localsource.json
index 4090794748..129e335ae7 100644
--- a/src/AppInstallerCLIE2ETests/TestData/localsource.json
+++ b/src/AppInstallerCLIE2ETests/TestData/localsource.json
@@ -33,7 +33,7 @@
     {
       "Type": "font",
       "Name": "AppInstallerTestFont/AppInstallerTestFont.ttf",
-      "Input": "%BUILD_ARTIFACTSTAGINGDIRECTORY%/AppInstallerTestFont.ttf",
+      "Input": "%BUILD_SOURCESDIRECTORY%/src/AppInstallerCLIE2ETests/TestData/AppInstallerTestFont.ttf",
       "HashToken": "<FONTHASH>"
     }
   ],

From 8678d12f256098207fbd030f62c1487dd224c482 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Fri, 6 Dec 2024 13:01:03 -0800
Subject: [PATCH 06/13] fix spelling again

---
 .github/actions/spelling/expect.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/actions/spelling/expect.txt b/.github/actions/spelling/expect.txt
index 669e9de686..382162dc12 100644
--- a/.github/actions/spelling/expect.txt
+++ b/.github/actions/spelling/expect.txt
@@ -180,6 +180,7 @@ FOF
 foldc
 foldcase
 FOLDERID
+FONTHASH
 FORPARSING
 foundfr
 fsanitize

From 745a4ed23ee7aa5bdf934219fe66a56e6606abfd Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Fri, 6 Dec 2024 15:01:43 -0800
Subject: [PATCH 07/13] enable local manifests for fonts e2e tests

---
 src/AppInstallerCLIE2ETests/FontCommand.cs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/AppInstallerCLIE2ETests/FontCommand.cs b/src/AppInstallerCLIE2ETests/FontCommand.cs
index e32b05b727..1ca17ba2ed 100644
--- a/src/AppInstallerCLIE2ETests/FontCommand.cs
+++ b/src/AppInstallerCLIE2ETests/FontCommand.cs
@@ -17,10 +17,23 @@ public class FontCommand : BaseCommand
         /// <summary>
         /// One time set up.
         /// </summary>
-        [SetUp]
+        [OneTimeSetUp]
         public void OneTimeSetup()
         {
             WinGetSettingsHelper.ConfigureFeature("fonts", true);
+
+            // TODO: Remove once font manifests can be installed from a source.
+            TestCommon.RunAICLICommand("settings", "--enable LocalManifestFiles");
+        }
+
+        /// <summary>
+        /// One time tear down.
+        /// </summary>
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            // TODO: Remove once font manifests can be installed from a source.
+            TestCommon.RunAICLICommand("settings", "--disable LocalManifestFiles");
         }
 
         /// <summary>

From b5f3c16fa6f578c9b30b3c8f03d3db972997a584 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Mon, 9 Dec 2024 14:57:24 -0800
Subject: [PATCH 08/13] try installing font from source

---
 src/AppInstallerCLIE2ETests/FontCommand.cs | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/src/AppInstallerCLIE2ETests/FontCommand.cs b/src/AppInstallerCLIE2ETests/FontCommand.cs
index 1ca17ba2ed..3fdc287c63 100644
--- a/src/AppInstallerCLIE2ETests/FontCommand.cs
+++ b/src/AppInstallerCLIE2ETests/FontCommand.cs
@@ -21,19 +21,6 @@ public class FontCommand : BaseCommand
         public void OneTimeSetup()
         {
             WinGetSettingsHelper.ConfigureFeature("fonts", true);
-
-            // TODO: Remove once font manifests can be installed from a source.
-            TestCommon.RunAICLICommand("settings", "--enable LocalManifestFiles");
-        }
-
-        /// <summary>
-        /// One time tear down.
-        /// </summary>
-        [OneTimeTearDown]
-        public void OneTimeTearDown()
-        {
-            // TODO: Remove once font manifests can be installed from a source.
-            TestCommon.RunAICLICommand("settings", "--disable LocalManifestFiles");
         }
 
         /// <summary>
@@ -42,7 +29,7 @@ public void OneTimeTearDown()
         [Test]
         public void InstallFont()
         {
-            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestFont.yaml")}");
+            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
             TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName);
@@ -54,7 +41,7 @@ public void InstallFont()
         [Test]
         public void InstallFont_MachineScope()
         {
-            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestFont.yaml")} --scope Machine");
+            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont --scope Machine");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
             TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
@@ -66,7 +53,7 @@ public void InstallFont_MachineScope()
         [Test]
         public void InstallInvalidFont()
         {
-            var result = TestCommon.RunAICLICommand("font install", $"-m {TestCommon.GetTestDataFile(@"Manifests\TestInvalidFont.yaml")} --scope Machine");
+            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestInvalidFont");
             Assert.AreEqual(Constants.ErrorCode.ERROR_FONT_FILE_NOT_SUPPORTED, result.ExitCode);
             Assert.True(result.StdOut.Contains("The font file is not supported and cannot be installed."));
         }

From bc8221ffb1cc5eb45fc720012a3317c3e377cda9 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Mon, 9 Dec 2024 18:49:13 -0800
Subject: [PATCH 09/13] try again

---
 src/AppInstallerCLIE2ETests/Constants.cs          |  2 +-
 src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/AppInstallerCLIE2ETests/Constants.cs b/src/AppInstallerCLIE2ETests/Constants.cs
index f121fd5103..a23bc4260d 100644
--- a/src/AppInstallerCLIE2ETests/Constants.cs
+++ b/src/AppInstallerCLIE2ETests/Constants.cs
@@ -122,7 +122,7 @@ public class Constants
         public const string PathSubKey_User = @"Environment";
         public const string PathSubKey_Machine = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
         public const string FontsSubKey = @"Software\Microsoft\Windows NT\CurrentVersion\Fonts";
-        public const string TestFontSubKeyName = "Cascadia Code PL (True Type)";
+        public const string TestFontSubKeyName = "Cascadia Code PL Regular (TrueType)";
 
         // User settings
         public const string ArchiveExtractionMethod = "archiveExtractionMethod";
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index 658b022baf..9af7afee4b 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -389,12 +389,17 @@ public static void VerifyFontPackage(
             if (shouldExist)
             {
                 // TODO: Replace with font uninstall when implemented.
-                File.Delete(expectedFontInstallPath);
+                if (fontEntryExists)
+                {
+                    using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
+                    {
+                        fontsRegistryKey.DeleteSubKey(fontSubKeyName);
+                    }
+                }
 
-                using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
+                if (fontFileExists)
                 {
-                    fontsRegistryKey.DeleteSubKey(fontSubKeyName);
-                    RegistryKey fontEntry = fontsRegistryKey.OpenSubKey(fontSubKeyName, true);
+                    File.Delete(expectedFontInstallPath);
                 }
             }
 

From 8f7a47d870706c03f7866950c0e5cd0d1fd1c8be Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Mon, 9 Dec 2024 20:52:07 -0800
Subject: [PATCH 10/13] try again

---
 .../Helpers/TestCommon.cs                     | 26 ++++++++++++++-----
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index 9af7afee4b..a5715f7749 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -374,16 +374,21 @@ public static void VerifyFontPackage(
             Scope scope = Scope.User,
             bool shouldExist = true)
         {
-            // TODO: Update this function to be able to handle the font uninstall scenario.
+            // Expected font file path.
             string expectedFontInstallPath = Path.Combine(GetFontsDirectory(scope), fontFileName);
             bool fontFileExists = File.Exists(expectedFontInstallPath);
 
-            bool fontEntryExists;
-            RegistryKey baseKey = scope == Scope.Machine ? Registry.LocalMachine : Registry.CurrentUser;
+            // Expected font registry entry.
+            bool fontEntryExists = false;
+            RegistryKey baseKey = (scope == Scope.Machine) ? Registry.LocalMachine : Registry.CurrentUser;
+            string expectedSubKeyValue = (scope == Scope.Machine) ? Path.GetFileName(expectedFontInstallPath) : expectedFontInstallPath;
             using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
             {
-                RegistryKey fontEntry = fontsRegistryKey.OpenSubKey(fontSubKeyName, true);
-                fontEntryExists = fontEntry != null;
+                var fontSubKeyValue = fontsRegistryKey.GetValue(fontSubKeyName);
+                if (fontSubKeyValue != null)
+                {
+                    fontEntryExists = fontSubKeyValue.Equals(expectedSubKeyValue);
+                }
             }
 
             if (shouldExist)
@@ -399,12 +404,19 @@ public static void VerifyFontPackage(
 
                 if (fontFileExists)
                 {
-                    File.Delete(expectedFontInstallPath);
+                    try
+                    {
+                        File.Delete(expectedFontInstallPath);
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        // TODO: This error occurs for user mode if the font is in use. Skip cleanup.
+                    }
                 }
             }
 
             Assert.AreEqual(shouldExist, fontFileExists, $"Expected font path: {expectedFontInstallPath}");
-            Assert.AreEqual(shouldExist, fontEntryExists, $"Expected {fontSubKeyName} subkey in registry path: {Constants.FontsSubKey}");
+            Assert.AreEqual(shouldExist, fontEntryExists, $"Expected {fontSubKeyName} subkey with value {expectedSubKeyValue} in registry path: {Constants.FontsSubKey}");
         }
 
         /// <summary>

From fa1c9950adb27dfd7c09813f98a361f5e5ab0567 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Mon, 9 Dec 2024 22:53:59 -0800
Subject: [PATCH 11/13] this should work

---
 src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index a5715f7749..f0b640abff 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -398,7 +398,7 @@ public static void VerifyFontPackage(
                 {
                     using (RegistryKey fontsRegistryKey = baseKey.OpenSubKey(Constants.FontsSubKey, true))
                     {
-                        fontsRegistryKey.DeleteSubKey(fontSubKeyName);
+                        fontsRegistryKey.DeleteValue(fontSubKeyName);
                     }
                 }
 

From d21f3ee922183ab3a9b38c6599a6a940b48a41bf Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Wed, 11 Dec 2024 12:27:10 -0800
Subject: [PATCH 12/13] address PR comments

---
 .../package-manager/winget/returnCodes.md     |  4 ++-
 .../Commands/FontCommand.cpp                  |  1 -
 src/AppInstallerCLICore/FontInstaller.cpp     | 29 +++++++++++++++----
 src/AppInstallerCLICore/FontInstaller.h       |  2 +-
 .../Workflows/DownloadFlow.cpp                |  2 +-
 .../Workflows/FontFlow.cpp                    |  8 ++---
 .../Workflows/InstallFlow.cpp                 |  1 +
 src/AppInstallerCLIE2ETests/FontCommand.cs    | 17 ++++++-----
 .../Helpers/TestCommon.cs                     |  2 +-
 .../Manifest/ManifestCommon.cpp               |  5 ++++
 .../Public/winget/ManifestCommon.h            |  3 ++
 src/AppInstallerSharedLib/Errors.cpp          |  2 +-
 12 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/doc/windows/package-manager/winget/returnCodes.md b/doc/windows/package-manager/winget/returnCodes.md
index caad7a5ef4..2acacdd1b4 100644
--- a/doc/windows/package-manager/winget/returnCodes.md
+++ b/doc/windows/package-manager/winget/returnCodes.md
@@ -146,6 +146,8 @@ ms.localizationpriority: medium
 | 0x8A150084 | -1978335100 | APPINSTALLER_CLI_ERROR_SFSCLIENT_PACKAGE_NOT_SUPPORTED | The Microsoft Store package does not support download command. |
 | 0x8A150085 | -1978335099 | APPINSTALLER_CLI_ERROR_LICENSING_API_FAILED_FORBIDDEN | Failed to retrieve Microsoft Store package license. The Microsoft Entra Id account does not have required privilege. |
 | 0x8A150086 | -1978335098 | APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE | Downloaded zero byte installer; ensure that your network connection is working properly. |
+| 0x8A150087 | -1978335097 | APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED | Failed to install font package. |
+| 0x8A150088 | -1978335096 | APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED | Font file is not supported and cannot be installed. |
 
 ## Install errors.
 
@@ -170,7 +172,7 @@ ms.localizationpriority: medium
 | 0x8A150111 | -1978334959 | APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE_BY_APPLICATION | Application is currently in use by another application. |
 | 0x8A150112 | -1978334958 | APPINSTALLER_CLI_ERROR_INSTALL_INVALID_PARAMETER | Invalid parameter. |
 | 0x8A150113 | -1978334957 | APPINSTALLER_CLI_ERROR_INSTALL_SYSTEM_NOT_SUPPORTED | Package not supported by the system. |
-| 0x8A150114 | -1978334956 | APPINSTALLER_CLI_ERROR_INSTALL_UPGRADE_NOT_SUPPORTED | The installer does not support upgrading an existing package. |
+| 0x8A150114 | -1978334956 | APPINSTALLER_CLI_ERROR_INSTALL_UPGRADE_NOT_SUPPORTED | The installer does not support upgrading an existing package. |
 | 0x8A150115 | -1978334955 | APPINSTALLER_CLI_ERROR_INSTALL_CUSTOM_ERROR | Installation failed with installer custom error. |
 
 ## Check for package installed status
diff --git a/src/AppInstallerCLICore/Commands/FontCommand.cpp b/src/AppInstallerCLICore/Commands/FontCommand.cpp
index 454b7c194e..1cb01acbd7 100644
--- a/src/AppInstallerCLICore/Commands/FontCommand.cpp
+++ b/src/AppInstallerCLICore/Commands/FontCommand.cpp
@@ -49,7 +49,6 @@ namespace AppInstaller::CLI
     {
         return {
             Argument::ForType(Args::Type::Manifest),
-            Argument{ Args::Type::InstallScope, Resource::String::InstallScopeDescription, ArgumentType::Standard, Argument::Visibility::Help },
         };
     }
 
diff --git a/src/AppInstallerCLICore/FontInstaller.cpp b/src/AppInstallerCLICore/FontInstaller.cpp
index de6d35cc63..dde9699265 100644
--- a/src/AppInstallerCLICore/FontInstaller.cpp
+++ b/src/AppInstallerCLICore/FontInstaller.cpp
@@ -31,12 +31,12 @@ namespace AppInstaller::CLI::Font
         if (scope == Manifest::ScopeEnum::Machine)
         {
             m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsMachineInstallLocation);
-            m_key = Registry::Key::OpenIfExists(HKEY_LOCAL_MACHINE, std::wstring{ s_FontsPathSubkey }, 0, KEY_WRITE );
+            m_key = Registry::Key::Create(HKEY_LOCAL_MACHINE, std::wstring{ s_FontsPathSubkey });
         }
         else
         {
             m_installLocation = Runtime::GetPathTo(Runtime::PathName::FontsUserInstallLocation);
-            m_key = Registry::Key::OpenIfExists(HKEY_CURRENT_USER, std::wstring{ s_FontsPathSubkey }, 0, KEY_WRITE);
+            m_key = Registry::Key::Create(HKEY_CURRENT_USER, std::wstring{ s_FontsPathSubkey });
         }
     }
 
@@ -48,7 +48,7 @@ namespace AppInstaller::CLI::Font
             const auto& fileName = filePath.filename();
             const auto& destinationPath = m_installLocation / fileName;
 
-            AICLI_LOG(CLI, Info, << "Getting Font title");
+            AICLI_LOG(CLI, Verbose, << "Getting Font title");
 
             std::wstring title = AppInstaller::Fonts::GetFontFileTitle(filePath);
 
@@ -57,8 +57,24 @@ namespace AppInstaller::CLI::Font
                 title += s_TrueType;
             }
 
-            AICLI_LOG(CLI, Info, << "Moving font file to: " << destinationPath);
-            AppInstaller::Filesystem::RenameFile(filePath, destinationPath);
+            // If font subkey already exists, remove the font file if it exists.
+            if (m_key[title].has_value())
+            {
+                AICLI_LOG(CLI, Info, << "Existing font subkey found:" << AppInstaller::Utility::ConvertToUTF8(title));
+                std::filesystem::path existingFontFilePath = { m_key[title]->GetValue<Registry::Value::Type::String>() };
+
+                if (m_scope == Manifest::ScopeEnum::Machine)
+                {
+                    // Font entries in the HKEY_LOCAL_MACHINE hive only have the filename specified as the value. Prepend install location.
+                    existingFontFilePath = m_installLocation / existingFontFilePath;
+                }
+
+                if (std::filesystem::exists(existingFontFilePath))
+                {
+                    AICLI_LOG(CLI, Info, << "Removing existing font file at:" << existingFontFilePath);
+                    std::filesystem::remove(existingFontFilePath);
+                }
+            }
 
             AICLI_LOG(CLI, Info, << "Creating font subkey with name: " << AppInstaller::Utility::ConvertToUTF8(title));
             if (m_scope == Manifest::ScopeEnum::Machine)
@@ -69,6 +85,9 @@ namespace AppInstaller::CLI::Font
             {
                 m_key.SetValue(title, destinationPath, REG_SZ);
             }
+
+            AICLI_LOG(CLI, Info, << "Moving font file to: " << destinationPath);
+            AppInstaller::Filesystem::RenameFile(filePath, destinationPath);
         }
     }
 
diff --git a/src/AppInstallerCLICore/FontInstaller.h b/src/AppInstallerCLICore/FontInstaller.h
index 9f548e0908..51d3a6ab0c 100644
--- a/src/AppInstallerCLICore/FontInstaller.h
+++ b/src/AppInstallerCLICore/FontInstaller.h
@@ -9,7 +9,7 @@ namespace AppInstaller::CLI::Font
     struct FontFile
     {
         FontFile(std::filesystem::path filePath, DWRITE_FONT_FILE_TYPE fileType)
-            : FilePath(filePath), FileType(fileType) {}
+            : FilePath(std::move(filePath)), FileType(fileType) {}
 
         std::filesystem::path FilePath;
         DWRITE_FONT_FILE_TYPE FileType;
diff --git a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
index 219be19126..d97d046a46 100644
--- a/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/DownloadFlow.cpp
@@ -77,7 +77,7 @@ namespace AppInstaller::CLI::Workflow
             std::filesystem::path filename = GetFileNameFromURI(installer->Url);
 
             // Default to URI for fonts since fonts can have multiple file extensions.
-            if (installer->BaseInstallerType != InstallerTypeEnum::Font)
+            if (!DoesInstallerTypeSupportMultipleFileExtensions(installer->BaseInstallerType))
             {
                 std::wstring_view installerExtension = GetInstallerFileExtension(context);
 
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.cpp b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
index 1d1a1c12b5..b99ed61660 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
@@ -159,18 +159,18 @@ namespace AppInstaller::CLI::Workflow
                 }
                 else
                 {
-                    AICLI_LOG(CLI, Warning, << "Font file is supported: " << file);
+                    AICLI_LOG(CLI, Verbose, << "Font file is supported: " << file);
                     fontFiles.emplace_back(FontFile(file, fileType));
                 }
             }
 
             context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
 
-            Manifest::ScopeEnum scope = AppInstaller::Manifest::ConvertToScopeEnum(context.Args.GetArg(Execution::Args::Type::InstallScope));
-            FontInstaller fontInstaller = FontInstaller(scope);
+            // TODO: Default to installing to HKEY_LOCAL_MACHINE registry as user install is not yet fully supported. 
+            FontInstaller fontInstaller = FontInstaller(Manifest::ScopeEnum::Machine);
 
             fontInstaller.Install(fontFiles);
-            context.Add<Execution::Data::OperationReturnCode>(ERROR_SUCCESS);
+            context.Add<Execution::Data::OperationReturnCode>(S_OK);
         }
         catch (...)
         {
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
index dcd299340e..eb7b528784 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
@@ -285,6 +285,7 @@ namespace AppInstaller::CLI::Workflow
         void FontInstall(Execution::Context& context)
         {
             context <<
+                EnsureRunningAsAdmin <<
                 FontInstallImpl <<
                 ReportInstallerResult("Font"sv, APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, true);
         }
diff --git a/src/AppInstallerCLIE2ETests/FontCommand.cs b/src/AppInstallerCLIE2ETests/FontCommand.cs
index 3fdc287c63..3dc6eb00e3 100644
--- a/src/AppInstallerCLIE2ETests/FontCommand.cs
+++ b/src/AppInstallerCLIE2ETests/FontCommand.cs
@@ -24,27 +24,28 @@ public void OneTimeSetup()
         }
 
         /// <summary>
-        /// Test install a font with user scope.
+        /// Test install a font with machine scope.
         /// </summary>
         [Test]
-        public void InstallFont()
+        public void InstallFont_MachineScope()
         {
             var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
-            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName);
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
         }
 
         /// <summary>
-        /// Test install a font with machine scope.
+        /// Test install a font with user scope.
         /// </summary>
-        [Test]
-        public void InstallFont_MachineScope()
+        // [Test]
+        public void InstallFont_UserScope()
         {
-            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont --scope Machine");
+            // TODO: Enable this test once user scope installs are fully supported.
+            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont --scope User");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
-            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.User);
         }
 
         /// <summary>
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index f0b640abff..c0d94c4393 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -371,7 +371,7 @@ public static string GetFontsDirectory(Scope scope)
         public static void VerifyFontPackage(
             string fontSubKeyName,
             string fontFileName,
-            Scope scope = Scope.User,
+            Scope scope = Scope.Machine,
             bool shouldExist = true)
         {
             // Expected font file path.
diff --git a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
index c02d042dbe..07006a8bad 100644
--- a/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
+++ b/src/AppInstallerCommonCore/Manifest/ManifestCommon.cpp
@@ -950,6 +950,11 @@ namespace AppInstaller::Manifest
             installerType == InstallerTypeEnum::Exe;
     }
 
+    bool DoesInstallerTypeSupportMultipleFileExtensions(InstallerTypeEnum installerType)
+    {
+        return (installerType == InstallerTypeEnum::Font);
+    }
+
     bool IsArchiveType(InstallerTypeEnum installerType)
     {
         return (installerType == InstallerTypeEnum::Zip);
diff --git a/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h b/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
index 07e23db191..6fe764c297 100644
--- a/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
+++ b/src/AppInstallerCommonCore/Public/winget/ManifestCommon.h
@@ -448,6 +448,9 @@ namespace AppInstaller::Manifest
     // Gets a value indicating whether the given installer requires RepairBehavior for repair.
     bool DoesInstallerTypeRequireRepairBehaviorForRepair(InstallerTypeEnum installerType);
 
+    // Gets a value indicating whether the given installer can have multiple file extensions.
+    bool DoesInstallerTypeSupportMultipleFileExtensions(InstallerTypeEnum installerType);
+
     // Gets a value indicating whether the given installer type is an archive.
     bool IsArchiveType(InstallerTypeEnum installerType);
 
diff --git a/src/AppInstallerSharedLib/Errors.cpp b/src/AppInstallerSharedLib/Errors.cpp
index 58392ad0a4..c192c97932 100644
--- a/src/AppInstallerSharedLib/Errors.cpp
+++ b/src/AppInstallerSharedLib/Errors.cpp
@@ -222,7 +222,7 @@ namespace AppInstaller
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_SFSCLIENT_PACKAGE_NOT_SUPPORTED, "The Microsoft Store package does not support download."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_LICENSING_API_FAILED_FORBIDDEN, "Failed to retrieve Microsoft Store package license. The Microsoft Entra Id account does not have the required privilege."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE, "Downloaded zero byte installer; ensure that your network connection is working properly."),
-            WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, "Failed to install font package"),
+            WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, "Failed to install font package."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED, "Font file is not supported and cannot be installed."),
 
             // Install errors.

From 1491913662e523ee61815c425920ee7fa9c87697 Mon Sep 17 00:00:00 2001
From: --global <ryfu@microsoft.com>
Date: Thu, 12 Dec 2024 18:27:05 -0800
Subject: [PATCH 13/13] add cleanup functionality and better handling of edge
 scenarios

---
 .../Commands/FontCommand.cpp                  |   2 +-
 src/AppInstallerCLICore/FontInstaller.cpp     | 106 +++++++++++++-----
 src/AppInstallerCLICore/FontInstaller.h       |  19 +++-
 src/AppInstallerCLICore/Resources.h           |   2 +
 .../Workflows/FontFlow.cpp                    |  36 ++++--
 .../Workflows/InstallFlow.cpp                 |   1 -
 src/AppInstallerCLIE2ETests/FontCommand.cs    |  17 ++-
 .../Helpers/TestCommon.cs                     |   2 +-
 .../Shared/Strings/en-us/winget.resw          |   6 +
 src/AppInstallerSharedLib/Errors.cpp          |   1 +
 .../Public/AppInstallerErrors.h               |   1 +
 .../Public/winget/Registry.h                  |   3 +
 src/AppInstallerSharedLib/Registry.cpp        |  31 +++++
 13 files changed, 171 insertions(+), 56 deletions(-)

diff --git a/src/AppInstallerCLICore/Commands/FontCommand.cpp b/src/AppInstallerCLICore/Commands/FontCommand.cpp
index 1cb01acbd7..7eb2f8e108 100644
--- a/src/AppInstallerCLICore/Commands/FontCommand.cpp
+++ b/src/AppInstallerCLICore/Commands/FontCommand.cpp
@@ -49,6 +49,7 @@ namespace AppInstaller::CLI
     {
         return {
             Argument::ForType(Args::Type::Manifest),
+            Argument{ Args::Type::InstallScope, Resource::String::InstallScopeDescription, ArgumentType::Standard, Argument::Visibility::Help },
         };
     }
 
@@ -66,7 +67,6 @@ namespace AppInstaller::CLI
     {
         UNREFERENCED_PARAMETER(valueType);
         context.Reporter.Error() << Resource::String::PendingWorkError << std::endl;
-        THROW_HR(E_NOTIMPL);
     }
 
     Utility::LocIndView FontInstallCommand::HelpLink() const
diff --git a/src/AppInstallerCLICore/FontInstaller.cpp b/src/AppInstallerCLICore/FontInstaller.cpp
index dde9699265..7cd4e38602 100644
--- a/src/AppInstallerCLICore/FontInstaller.cpp
+++ b/src/AppInstallerCLICore/FontInstaller.cpp
@@ -26,6 +26,17 @@ namespace AppInstaller::CLI::Font
         }
     }
 
+    FontFile::FontFile(std::filesystem::path filePath, DWRITE_FONT_FILE_TYPE fileType)
+        : FilePath(std::move(filePath)), FileType(fileType)
+    {
+        Title = AppInstaller::Fonts::GetFontFileTitle(FilePath);
+
+        if (IsTrueTypeFont(FileType))
+        {
+            Title += s_TrueType;
+        }
+    }
+
     FontInstaller::FontInstaller(Manifest::ScopeEnum scope) : m_scope(scope)
     {
         if (scope == Manifest::ScopeEnum::Machine)
@@ -40,28 +51,78 @@ namespace AppInstaller::CLI::Font
         }
     }
 
-    void FontInstaller::Install(const std::vector<FontFile>& fontFiles)
+    bool FontInstaller::EnsureInstall()
     {
-        for (const auto& fontFile : fontFiles)
+        for (auto& fontFile : m_fontFiles)
         {
-            const auto& filePath = fontFile.FilePath;
-            const auto& fileName = filePath.filename();
-            const auto& destinationPath = m_installLocation / fileName;
+            if (m_key[fontFile.Title].has_value())
+            {
+                if (!std::filesystem::exists(m_key[fontFile.Title]->GetValue<Registry::Value::Type::String>()))
+                {
+                    AICLI_LOG(CLI, Info, << "Removing existing font value as font file does not exist.");
+                    m_key.DeleteValue(fontFile.Title);
+                }
+                else
+                {
+                    AICLI_LOG(CLI, Info, << "Existing font value found: " << AppInstaller::Utility::ConvertToUTF8(fontFile.Title));
+                    return false;
+                }
+            }
+
+            std::filesystem::path destinationPath = m_installLocation / fontFile.FilePath.filename();
+            auto initialStem = fontFile.FilePath.stem();
+            auto extension = fontFile.FilePath.extension();
+
+            // If a file exists at the destination path, make the filename unique.
+            int index = 0;
+            while (std::filesystem::exists(destinationPath))
+            {
+                std::filesystem::path unique = { "_" + std::to_string(index) };
+                auto duplicateStem = initialStem;
+                duplicateStem += unique;
+                duplicateStem += extension;
+                destinationPath = m_installLocation / duplicateStem;
+                index++;
+            }
 
-            AICLI_LOG(CLI, Verbose, << "Getting Font title");
+            fontFile.DestinationPath = std::move(destinationPath);
+        }
 
-            std::wstring title = AppInstaller::Fonts::GetFontFileTitle(filePath);
+        return true;
+    }
+
+    void FontInstaller::Install()
+    {
+        bool isMachineScope = m_scope == Manifest::ScopeEnum::Machine;
 
-            if (IsTrueTypeFont(fontFile.FileType))
+        for (const auto& fontFile : m_fontFiles)
+        {
+            AICLI_LOG(CLI, Info, << "Creating font value with name : " << AppInstaller::Utility::ConvertToUTF8(fontFile.Title));
+            if (isMachineScope)
             {
-                title += s_TrueType;
+                m_key.SetValue(fontFile.Title, fontFile.DestinationPath.filename(), REG_SZ);
             }
+            else
+            {
+                m_key.SetValue(fontFile.Title, fontFile.DestinationPath, REG_SZ);
+            }
+        }
 
-            // If font subkey already exists, remove the font file if it exists.
-            if (m_key[title].has_value())
+        for (const auto& fontFile : m_fontFiles)
+        {
+            AICLI_LOG(CLI, Info, << "Moving font file to: " << fontFile.DestinationPath);
+            AppInstaller::Filesystem::RenameFile(fontFile.FilePath, fontFile.DestinationPath);
+        }
+    }
+
+    void FontInstaller::Uninstall()
+    {
+        for (const auto& fontFile : m_fontFiles)
+        {
+            if (m_key[fontFile.Title].has_value())
             {
-                AICLI_LOG(CLI, Info, << "Existing font subkey found:" << AppInstaller::Utility::ConvertToUTF8(title));
-                std::filesystem::path existingFontFilePath = { m_key[title]->GetValue<Registry::Value::Type::String>() };
+                AICLI_LOG(CLI, Info, << "Existing font value found:" << AppInstaller::Utility::ConvertToUTF8(fontFile.Title));
+                std::filesystem::path existingFontFilePath = { m_key[fontFile.Title]->GetValue<Registry::Value::Type::String>() };
 
                 if (m_scope == Manifest::ScopeEnum::Machine)
                 {
@@ -74,25 +135,10 @@ namespace AppInstaller::CLI::Font
                     AICLI_LOG(CLI, Info, << "Removing existing font file at:" << existingFontFilePath);
                     std::filesystem::remove(existingFontFilePath);
                 }
-            }
 
-            AICLI_LOG(CLI, Info, << "Creating font subkey with name: " << AppInstaller::Utility::ConvertToUTF8(title));
-            if (m_scope == Manifest::ScopeEnum::Machine)
-            {
-                m_key.SetValue(title, fileName, REG_SZ);
-            }
-            else
-            {
-                m_key.SetValue(title, destinationPath, REG_SZ);
+                AICLI_LOG(CLI, Info, << "Deleting registry value:" << existingFontFilePath);
+                m_key.DeleteValue(fontFile.Title);
             }
-
-            AICLI_LOG(CLI, Info, << "Moving font file to: " << destinationPath);
-            AppInstaller::Filesystem::RenameFile(filePath, destinationPath);
         }
     }
-
-    void FontInstaller::Uninstall(const std::wstring& familyName)
-    {
-        UNREFERENCED_PARAMETER(familyName);
-    }
 }
diff --git a/src/AppInstallerCLICore/FontInstaller.h b/src/AppInstallerCLICore/FontInstaller.h
index 51d3a6ab0c..0e4395ddad 100644
--- a/src/AppInstallerCLICore/FontInstaller.h
+++ b/src/AppInstallerCLICore/FontInstaller.h
@@ -8,11 +8,12 @@ namespace AppInstaller::CLI::Font
 {
     struct FontFile
     {
-        FontFile(std::filesystem::path filePath, DWRITE_FONT_FILE_TYPE fileType)
-            : FilePath(std::move(filePath)), FileType(fileType) {}
+        FontFile(std::filesystem::path filePath, DWRITE_FONT_FILE_TYPE fileType);
 
         std::filesystem::path FilePath;
         DWRITE_FONT_FILE_TYPE FileType;
+        std::wstring Title;
+        std::filesystem::path DestinationPath;
     };
 
     struct FontInstaller
@@ -21,13 +22,23 @@ namespace AppInstaller::CLI::Font
 
         std::filesystem::path FontFileLocation;
 
-        void Install(const std::vector<FontFile>& fontFiles);
+        void SetFontFiles(const std::vector<FontFile>& fontFiles)
+        {
+            m_fontFiles = fontFiles;
+        }
 
-        void Uninstall(const std::wstring& familyName);
+        // Checks if all expected registry values and font files can be installed prior to installation.
+        bool EnsureInstall();
+
+        void Install();
+
+        void Uninstall();
 
     private:
         Manifest::ScopeEnum m_scope;
         std::filesystem::path m_installLocation;
         Registry::Key m_key;
+
+        std::vector<FontFile> m_fontFiles;
     };
 }
diff --git a/src/AppInstallerCLICore/Resources.h b/src/AppInstallerCLICore/Resources.h
index 6d95441a40..c87a166f79 100644
--- a/src/AppInstallerCLICore/Resources.h
+++ b/src/AppInstallerCLICore/Resources.h
@@ -250,6 +250,7 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(FileNotFound);
         WINGET_DEFINE_RESOURCE_STRINGID(FilesRemainInInstallDirectory);
         WINGET_DEFINE_RESOURCE_STRINGID(FlagContainAdjoinedError);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontAlreadyInstalled);
         WINGET_DEFINE_RESOURCE_STRINGID(FontCommandLongDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontCommandShortDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontFace);
@@ -260,6 +261,7 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(FontFilePaths);
         WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandLongDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontInstallCommandShortDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontInstallFailed);
         WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandLongDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandShortDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(FontVersion);
diff --git a/src/AppInstallerCLICore/Workflows/FontFlow.cpp b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
index b99ed61660..dc9bb827ec 100644
--- a/src/AppInstallerCLICore/Workflows/FontFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/FontFlow.cpp
@@ -126,6 +126,16 @@ namespace AppInstaller::CLI::Workflow
 
     void FontInstallImpl(Execution::Context& context)
     {
+        Manifest::ScopeEnum scope = Manifest::ScopeEnum::Unknown;
+        if (context.Args.Contains(Execution::Args::Type::InstallScope))
+        {
+            scope = Manifest::ConvertToScopeEnum(context.Args.GetArg(Execution::Args::Type::InstallScope));
+        }
+
+        FontInstaller fontInstaller = FontInstaller(scope);
+
+        context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
+
         try
         {
             const auto& installerPath = context.Get<Execution::Data::InstallerPath>();
@@ -145,36 +155,42 @@ namespace AppInstaller::CLI::Workflow
                 filePaths.emplace_back(installerPath);
             }
 
-            std::vector<FontFile> fontFiles;
             Fonts::FontCatalog fontCatalog;
+            std::vector<FontFile> fontFiles;
 
-            for (const auto& file : filePaths)
+            for (std::filesystem::path filePath : filePaths)
             {
                 DWRITE_FONT_FILE_TYPE fileType;
-                if (!fontCatalog.IsFontFileSupported(file, fileType))
+                if (!fontCatalog.IsFontFileSupported(filePath, fileType))
                 {
-                    AICLI_LOG(CLI, Warning, << "Font file is not supported: " << file);
+                    AICLI_LOG(CLI, Warning, << "Font file is not supported: " << filePath);
                     context.Reporter.Error() << Resource::String::FontFileNotSupported << std::endl;
                     AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED);
                 }
                 else
                 {
-                    AICLI_LOG(CLI, Verbose, << "Font file is supported: " << file);
-                    fontFiles.emplace_back(FontFile(file, fileType));
+                    AICLI_LOG(CLI, Verbose, << "Font file is supported: " << filePath);
+                    fontFiles.emplace_back(FontFile(filePath, fileType));
                 }
             }
 
-            context.Reporter.Info() << Resource::String::InstallFlowStartingPackageInstall << std::endl;
+            fontInstaller.SetFontFiles(fontFiles);
 
-            // TODO: Default to installing to HKEY_LOCAL_MACHINE registry as user install is not yet fully supported. 
-            FontInstaller fontInstaller = FontInstaller(Manifest::ScopeEnum::Machine);
+            if (!fontInstaller.EnsureInstall())
+            {
+                context.Reporter.Warn() << Resource::String::FontAlreadyInstalled << std::endl;
+                AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_FONT_ALREADY_INSTALLED);
+            }
 
-            fontInstaller.Install(fontFiles);
+            fontInstaller.Install();
             context.Add<Execution::Data::OperationReturnCode>(S_OK);
         }
         catch (...)
         {
             context.Add<Execution::Data::OperationReturnCode>(Workflow::HandleException(context, std::current_exception()));
+            context.Reporter.Warn() << Resource::String::FontInstallFailed << std::endl;
+            fontInstaller.Uninstall();
+            AICLI_TERMINATE_CONTEXT(APPINSTALLER_CLI_ERROR_PORTABLE_INSTALL_FAILED);
         }
     }
 }
diff --git a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
index eb7b528784..dcd299340e 100644
--- a/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
+++ b/src/AppInstallerCLICore/Workflows/InstallFlow.cpp
@@ -285,7 +285,6 @@ namespace AppInstaller::CLI::Workflow
         void FontInstall(Execution::Context& context)
         {
             context <<
-                EnsureRunningAsAdmin <<
                 FontInstallImpl <<
                 ReportInstallerResult("Font"sv, APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, true);
         }
diff --git a/src/AppInstallerCLIE2ETests/FontCommand.cs b/src/AppInstallerCLIE2ETests/FontCommand.cs
index 3dc6eb00e3..1292caad24 100644
--- a/src/AppInstallerCLIE2ETests/FontCommand.cs
+++ b/src/AppInstallerCLIE2ETests/FontCommand.cs
@@ -24,28 +24,27 @@ public void OneTimeSetup()
         }
 
         /// <summary>
-        /// Test install a font with machine scope.
+        /// Test install a font with user scope.
         /// </summary>
         [Test]
-        public void InstallFont_MachineScope()
+        public void InstallFont_UserScope()
         {
             var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
-            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.User);
         }
 
         /// <summary>
-        /// Test install a font with user scope.
+        /// Test install a font with machine scope.
         /// </summary>
-        // [Test]
-        public void InstallFont_UserScope()
+        [Test]
+        public void InstallFont_MachineScope()
         {
-            // TODO: Enable this test once user scope installs are fully supported.
-            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont --scope User");
+            var result = TestCommon.RunAICLICommand("install", "AppInstallerTest.TestFont --scope Machine");
             Assert.AreEqual(Constants.ErrorCode.S_OK, result.ExitCode);
             Assert.True(result.StdOut.Contains("Successfully installed"));
-            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.User);
+            TestCommon.VerifyFontPackage(Constants.TestFontSubKeyName, Constants.FontFileName, TestCommon.Scope.Machine);
         }
 
         /// <summary>
diff --git a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
index c0d94c4393..f0b640abff 100644
--- a/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
+++ b/src/AppInstallerCLIE2ETests/Helpers/TestCommon.cs
@@ -371,7 +371,7 @@ public static string GetFontsDirectory(Scope scope)
         public static void VerifyFontPackage(
             string fontSubKeyName,
             string fontFileName,
-            Scope scope = Scope.Machine,
+            Scope scope = Scope.User,
             bool shouldExist = true)
         {
             // Expected font file path.
diff --git a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
index 62b0ca25fa..e6912e645c 100644
--- a/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
+++ b/src/AppInstallerCLIPackage/Shared/Strings/en-us/winget.resw
@@ -3196,4 +3196,10 @@ Please specify one of them using the --source option to proceed.</value>
   <data name="FontFileNotSupported" xml:space="preserve">
     <value>The font file is not supported and cannot be installed.</value>
   </data>
+  <data name="FontInstallFailed" xml:space="preserve">
+    <value>Font install failed; Cleaning up...</value>
+  </data>
+  <data name="FontAlreadyInstalled" xml:space="preserve">
+    <value>Font already installed</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/AppInstallerSharedLib/Errors.cpp b/src/AppInstallerSharedLib/Errors.cpp
index c192c97932..2761e798be 100644
--- a/src/AppInstallerSharedLib/Errors.cpp
+++ b/src/AppInstallerSharedLib/Errors.cpp
@@ -224,6 +224,7 @@ namespace AppInstaller
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE, "Downloaded zero byte installer; ensure that your network connection is working properly."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED, "Failed to install font package."),
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED, "Font file is not supported and cannot be installed."),
+            WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_FONT_ALREADY_INSTALLED, "Font already installed."),
 
             // Install errors.
             WINGET_HRESULT_INFO(APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE, "Application is currently running. Exit the application then try again."),
diff --git a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
index 5b69d884f2..06b6daabef 100644
--- a/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
+++ b/src/AppInstallerSharedLib/Public/AppInstallerErrors.h
@@ -154,6 +154,7 @@
 #define APPINSTALLER_CLI_ERROR_INSTALLER_ZERO_BYTE_FILE             ((HRESULT)0x8A150086)
 #define APPINSTALLER_CLI_ERROR_FONT_INSTALL_FAILED                  ((HRESULT)0x8A150087)
 #define APPINSTALLER_CLI_ERROR_FONT_FILE_NOT_SUPPORTED              ((HRESULT)0x8A150088)
+#define APPINSTALLER_CLI_ERROR_FONT_ALREADY_INSTALLED               ((HRESULT)0x8A150089)
 
 // Install errors.
 #define APPINSTALLER_CLI_ERROR_INSTALL_PACKAGE_IN_USE                   ((HRESULT)0x8A150101)
diff --git a/src/AppInstallerSharedLib/Public/winget/Registry.h b/src/AppInstallerSharedLib/Public/winget/Registry.h
index 88c69b3bc6..3dc29c667a 100644
--- a/src/AppInstallerSharedLib/Public/winget/Registry.h
+++ b/src/AppInstallerSharedLib/Public/winget/Registry.h
@@ -271,6 +271,9 @@ namespace AppInstaller::Registry
         std::optional<Value> operator[](std::string_view name) const;
         std::optional<Value> operator[](const std::wstring& name) const;
 
+        void DeleteValue(std::string_view name) const;
+        void DeleteValue(const std::wstring& name) const;
+
         std::optional<Key> SubKey(std::string_view name, DWORD options = 0) const;
         std::optional<Key> SubKey(const std::wstring& name, DWORD options = 0) const;
 
diff --git a/src/AppInstallerSharedLib/Registry.cpp b/src/AppInstallerSharedLib/Registry.cpp
index cac167136b..dbc23bc20c 100644
--- a/src/AppInstallerSharedLib/Registry.cpp
+++ b/src/AppInstallerSharedLib/Registry.cpp
@@ -132,6 +132,20 @@ namespace AppInstaller::Registry
 
             return true;
         }
+
+        bool TryDeleteRegistryValueData(const wil::shared_hkey& key, const std::wstring& valueName)
+        {
+            LSTATUS status = RegDeleteValueW(key.get(), valueName.c_str());
+
+            if (status == ERROR_FILE_NOT_FOUND)
+            {
+                return false;
+            }
+
+            THROW_IF_WIN32_ERROR(status);
+
+            return true;
+        }
     }
 
     namespace details
@@ -415,6 +429,23 @@ namespace AppInstaller::Registry
         }
     }
 
+    void Key::DeleteValue(std::string_view name) const
+    {
+        DeleteValue(Utility::ConvertToUTF16(name));
+    }
+
+    void Key::DeleteValue(const std::wstring& name) const
+    {
+        if (TryDeleteRegistryValueData(m_key, name))
+        {
+            AICLI_LOG(Core, Verbose, << "Registry value '" << Utility::ConvertToUTF8(name) << "' deleted successfully.");
+        }
+        else
+        {
+            AICLI_LOG(Core, Verbose, << "Registry value '" << Utility::ConvertToUTF8(name) << "' does not exist.");
+        }
+    }
+
     std::optional<Key> Key::SubKey(std::string_view subKey, DWORD options) const
     {
         return SubKey(Utility::ConvertToUTF16(subKey), options);