fix

_⚠️ targets #39955_

This adds history support to the new run page.

* It'll initialize the history with the history from the run dialog, if
there is any.
* Any new commands that are run, or files/dirs that are opened will also
get added to the history
* history will persist across reboots

.github/actions/spell-check/allow/code.txt

@@ -282,3 +282,9 @@ xef
 xes
 PACKAGEVERSIONNUMBER
 APPXMANIFESTVERSION
+
+# MRU lists
+CACHEWRITE
+MRUCMPPROC
+MRUINFO
+REGSTR

.github/actions/spell-check/expect.txt

@@ -38,6 +38,7 @@ ALLAPPS
 ALLCHILDREN
 ALLINPUT
 Allman
+Allmodule
 ALLOWUNDO
 ALLVIEW
 ALPHATYPE
@@ -246,6 +247,7 @@ CONTEXTMENUHANDLER
 contractversion
 CONTROLPARENT
 copiedcolorrepresentation
+coppied
 copyable
 COPYPEN
 COREWINDOW
@@ -444,6 +446,7 @@ ERRORIMAGE
 ERRORTITLE
 ESettings
 esrp
+etd
 ETDT
 etl
 etw
@@ -528,8 +531,8 @@ frm
 FROMTOUCH
 fsanitize
 fsmgmt
-fxf
 fuzzingtesting
+fxf
 FZE
 gacutil
 Gaeilge
@@ -734,6 +737,7 @@ INSTALLSTARTMENUSHORTCUT
 INSTALLSTATE
 Inste
 Interlop
+intput
 INTRESOURCE
 INVALIDARG
 invalidoperatioexception
@@ -816,6 +820,7 @@ LMEM
 LMENU
 LOADFROMFILE
 LOBYTE
+localappdata
 localpackage
 LOCALSYSTEM
 LOCATIONCHANGE
@@ -1118,6 +1123,7 @@ oldtheme
 oleaut
 OLECHAR
 onebranch
+OOBEUI
 openas
 opencode
 OPENFILENAME
@@ -1383,8 +1389,8 @@ RIDEV
 RIGHTSCROLLBAR
 riid
 RKey
-RNumber
 Rns
+RNumber
 rop
 ROUNDSMALL
 ROWSETEXT
@@ -1395,6 +1401,7 @@ Rsp
 rstringalnum
 rstringalpha
 rstringdigit
+rtb
 RTB
 RTLREADING
 rtm
@@ -1529,6 +1536,7 @@ SLGP
 sln
 SMALLICON
 smartphone
+smileys
 SMTO
 SNAPPROCESS
 snk
@@ -1756,8 +1764,8 @@ Uptool
 urld
 Usb
 USEDEFAULT
-USEINSTALLERFORTEST
 USEFILEATTRIBUTES
+USEINSTALLERFORTEST
 USESHOWWINDOW
 USESTDHANDLES
 USRDLL

Directory.Packages.props

@@ -70,6 +70,7 @@
     <PackageVersion Include="NLog.Schema" Version="5.2.8" />
     <PackageVersion Include="OpenAI" Version="2.0.0" />
     <PackageVersion Include="ReverseMarkdown" Version="4.1.0" />
+    <PackageVersion Include="RtfPipe" Version="2.0.7677.4303" />
     <PackageVersion Include="ScipBe.Common.Office.OneNote" Version="3.0.1" />
     <PackageVersion Include="SharpCompress" Version="0.37.2" />
     <!-- Don't update SkiaSharp.Views.WinUI to version 3.* branch as this brakes the HexBox control in Registry Preview. -->

PowerToys.sln

@@ -751,6 +751,16 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.TimeDa
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.WindowWalker.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests.csproj", "{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UITest-Settings", "src\settings-ui\UITest-Settings\UITest-Settings.csproj", "{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UITest-ColorPicker", "src\modules\colorPicker\UITest-ColorPicker\UITest-ColorPicker.csproj", "{E4BAAD93-A499-42FD-A741-7E9591594B61}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AdvancedPaste-UITests", "src\modules\AdvancedPaste\UITest-AdvancedPaste\AdvancedPaste-UITests.csproj", "{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{9B3962F4-AB69-4C2A-8917-2C8448AC6960}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.Calc.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.Calc.UnitTests\Microsoft.CmdPal.Ext.Calc.UnitTests.csproj", "{E816D7AC-4688-4ECB-97CC-3D8E798F3825}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|ARM64 = Debug|ARM64
@@ -2733,14 +2743,6 @@ Global
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|ARM64.Build.0 = Release|ARM64
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|x64.ActiveCfg = Release|x64
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|x64.Build.0 = Release|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.Build.0 = Debug|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.ActiveCfg = Debug|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.Build.0 = Debug|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.ActiveCfg = Release|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.Build.0 = Release|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.ActiveCfg = Release|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.Build.0 = Release|x64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|ARM64.ActiveCfg = Debug|ARM64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|ARM64.Build.0 = Debug|ARM64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|x64.ActiveCfg = Debug|x64
@@ -2757,6 +2759,14 @@ Global
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|ARM64.Build.0 = Release|ARM64
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|x64.ActiveCfg = Release|x64
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|x64.Build.0 = Release|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.Build.0 = Debug|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.ActiveCfg = Debug|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.Build.0 = Debug|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.ActiveCfg = Release|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.Build.0 = Release|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.ActiveCfg = Release|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.Build.0 = Release|x64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|ARM64.ActiveCfg = Debug|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|ARM64.Build.0 = Debug|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|x64.ActiveCfg = Debug|x64
@@ -2797,6 +2807,38 @@ Global
 		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|ARM64.Build.0 = Release|ARM64
 		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.ActiveCfg = Release|x64
 		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.Build.0 = Release|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|x64.ActiveCfg = Debug|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|x64.Build.0 = Debug|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|ARM64.Build.0 = Release|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|x64.ActiveCfg = Release|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|x64.Build.0 = Release|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|x64.ActiveCfg = Debug|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|x64.Build.0 = Debug|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|ARM64.Build.0 = Release|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|x64.ActiveCfg = Release|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|x64.Build.0 = Release|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|x64.ActiveCfg = Debug|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|x64.Build.0 = Debug|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|ARM64.Build.0 = Release|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|x64.ActiveCfg = Release|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|x64.Build.0 = Release|x64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Debug|x64.ActiveCfg = Debug|x64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Debug|x64.Build.0 = Debug|x64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Release|ARM64.Build.0 = Release|ARM64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Release|x64.ActiveCfg = Release|x64
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -3054,8 +3096,8 @@ Global
 		{3A9A7297-92C4-4F16-B6F9-8D4AB652C86C} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
 		{605E914B-7232-4789-AF46-BF5D3DDFC14E} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
 		{E81A7D20-9862-ABDB-0AAE-9BC5B517A9F9} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
-		{D5E5F5EA-1B6C-4A73-88BE-304F36C9E4EE} = {9873BA05-4C41-4819-9283-CF45D795431B}
-		{7F5B9557-5878-4438-A721-3E28296BA193} = {9873BA05-4C41-4819-9283-CF45D795431B}
+		{D5E5F5EA-1B6C-4A73-88BE-304F36C9E4EE} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
+		{7F5B9557-5878-4438-A721-3E28296BA193} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
 		{DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C} = {4574FDD0-F61D-4376-98BF-E5A1262C11EC}
 		{0A84F764-3A88-44CD-AA96-41BDBD48627B} = {DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C}
 		{E4585179-2AC1-4D5F-A3FF-CFC5392F694C} = {DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C}
@@ -3081,16 +3123,21 @@ Global
 		{43E779F3-D83C-48B1-BA8D-1912DBD76FC9} = {A2221D7E-55E7-4BEA-90D1-4F162D670BBF}
 		{2CF78CF7-8FEB-4BE1-9591-55FA25B48FC6} = {1AFB6476-670D-4E80-A464-657E01DFF482}
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A} = {1AFB6476-670D-4E80-A464-657E01DFF482}
-		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{9D3F3793-EFE3-4525-8782-238015DABA62} = {89E20BCE-EB9C-46C8-8B50-E01A82E6FDC3}
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1} = {17B4FA70-001E-4D33-BBBB-0D142DBC2E20}
+		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2} = {7520A2FE-00A2-49B8-83ED-DB216E874C04}
 		{15EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
 		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{790247CB-2B95-E139-E933-09D10137EEAF} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{18525614-CDB2-8BBE-B1B4-3812CD990C22} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A} = {C3081D9A-1586-441A-B5F4-ED815B3719C1}
+		{E4BAAD93-A499-42FD-A741-7E9591594B61} = {1D78B84B-CA39-406C-98F4-71F7EC266CC0}
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
+		{9B3962F4-AB69-4C2A-8917-2C8448AC6960} = {9873BA05-4C41-4819-9283-CF45D795431B}
+		{E816D7AC-4688-4ECB-97CC-3D8E798F3825} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {C3A2F9D1-7930-4EF4-A6FC-7EE0A99821D0}

src/common/UITestAutomation/Element/ComboBox.cs

@@ -24,5 +24,16 @@ namespace Microsoft.PowerToys.UITest
         {
             this.Find<NavigationViewItem>(value).Click();
         }
+
+        /// <summary>
+        /// Select a text item from the ComboBox.
+        /// </summary>
+        /// <param name="value">The text to select from the ComboBox.</param>
+        public void SelectTxt(string value)
+        {
+            this.Click(); // First click to expand the ComboBox
+            Thread.Sleep(100); // Wait for the dropdown to appear
+            this.Find<Element>(value).Click(); // Find and click the text item using basic Element type
+        }
     }
 }

src/common/UITestAutomation/Element/RadioButton.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.PowerToys.UITest
+{
+    /// <summary>
+    /// Represents a radio button UI element in the application.
+    /// </summary>
+    public class RadioButton : Element
+    {
+        private static readonly string ExpectedControlType = "ControlType.RadioButton";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RadioButton"/> class.
+        /// </summary>
+        public RadioButton()
+        {
+            this.TargetControlType = RadioButton.ExpectedControlType;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the RadioButton is selected.
+        /// </summary>
+        public bool IsSelected => this.Selected;
+
+        /// <summary>
+        /// Select the RadioButton.
+        /// </summary>
+        public void Select()
+        {
+            if (!this.IsSelected)
+            {
+                this.Click();
+            }
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/AdvancedPaste-UITests.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}</ProjectGuid>
+		<RootNamespace>Microsoft.AdvancedPaste.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\..\$(Platform)\$(Configuration)\tests\UITests-AdvancedPaste\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<Content Include="TestFiles\**\*.*">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</Content>
+	</ItemGroup>
+
+</Project>

src/modules/AdvancedPaste/UITest-AdvancedPaste/AdvancedPasteUITest.cs

@@ -0,0 +1,791 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.Globalization;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Windows.Forms;
+
+using Microsoft.AdvancedPaste.UITests.Helper;
+using Microsoft.CodeCoverage.Core.Reports.Coverage;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OpenQA.Selenium;
+using Windows.ApplicationModel.DataTransfer;
+using static System.Net.Mime.MediaTypeNames;
+using static System.Resources.ResXFileRef;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolTip;
+
+namespace Microsoft.AdvancedPaste.UITests
+{
+    [TestClass]
+    public class AdvancedPasteUITest : UITestBase
+    {
+        private readonly string testFilesFolderPath;
+        private readonly string tempRTFFileName = "TempFile.rtf";
+        private readonly string pasteAsPlainTextRawFileName = "PasteAsPlainTextFileRaw.rtf";
+        private readonly string pasteAsPlainTextPlainFileName = "PasteAsPlainTextFilePlain.rtf";
+        private readonly string pasteAsPlainTextPlainNoRepeatFileName = "PasteAsPlainTextFilePlainNoRepeat.rtf";
+        private readonly string wordpadPath = @"C:\Program Files\wordpad\wordpad.exe";
+
+        private readonly string tempTxtFileName = "TempFile.txt";
+        private readonly string pasteAsMarkdownSrcFile = "PasteAsMarkdownFile.html";
+        private readonly string pasteAsMarkdownResultFile = "PasteAsMarkdownResultFile.txt";
+
+        private readonly string pasteAsJsonFileName = "PasteAsJsonFile.xml";
+        private readonly string pasteAsJsonResultFile = "PasteAsJsonResultFile.txt";
+
+        private bool _notepadSettingsChanged;
+
+        // Static constructor - runs before any instance is created
+        static AdvancedPasteUITest()
+        {
+            // Using the predefined settings.
+            // paste as plain text: win + ctrl + alt + o
+            // paste as markdown text: win + ctrl + alt + m
+            // paste as json text: win + ctrl + alt + j
+            CopySettingsFileBeforeTests();
+        }
+
+        public AdvancedPasteUITest()
+            : base(PowerToysModule.PowerToysSettings, size: WindowSize.Small)
+        {
+            Type currentTestType = typeof(AdvancedPasteUITest);
+            string? dirName = Path.GetDirectoryName(currentTestType.Assembly.Location);
+            Assert.IsNotNull(dirName, "Failed to get directory name of the current test assembly.");
+
+            string testFilesFolder = Path.Combine(dirName, "TestFiles");
+            Assert.IsTrue(Directory.Exists(testFilesFolder), $"Test files directory not found at: {testFilesFolder}");
+
+            testFilesFolderPath = testFilesFolder;
+
+            // ignore the notepad settings in pipeline
+            _notepadSettingsChanged = true;
+        }
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            Session.CloseMainWindow();
+            SendKeys(Key.Win, Key.M);
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsPlainText")]
+        [Ignore("Temporarily disabled due to wordpad.exe is missing in pipeline.")]
+        public void TestCasePasteAsPlainText()
+        {
+            // Copy some rich text(e.g word of the text is different color, another work is bold, underlined, etd.).
+            // Paste the text using standard Windows Ctrl + V shortcut and ensure that rich text is pasted(with all colors, formatting, etc.)
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteDirectly(tempRTFFileName, isRTF: true);
+
+            var resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextRawFileName),
+                compareFormatting: true);
+
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical including formatting");
+
+            // Paste the text using Paste As Plain Text activation shortcut and ensure that plain text without any formatting is pasted.
+            // Paste again the text using standard Windows Ctrl + V shortcut and ensure the text is now pasted plain without formatting as well.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteWithShortcutThenPasteAgain(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteCase3(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainNoRepeatFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteCase4(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainNoRepeatFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsMarkdownCase1")]
+        public void TestCasePasteAsMarkdownCase1()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some text(e.g.some HTML text - convertible to Markdown)
+            // Paste the text using set hotkey and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase1(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsMarkdownCase2")]
+        public void TestCasePasteAsMarkdownCase2()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+            // Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase2(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsMarkdownCase3")]
+        public void TestCasePasteAsMarkdownCase3()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+            // Open Advanced Paste window using hotkey, press Ctrl + 2 and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase3(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsJSONCase1")]
+        public void TestCasePasteAsJSONCase1()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some XML or CSV text(or any other text, it will be converted to simple JSON object)
+            // Paste the text using set hotkey and confirm that pasted text is converted to JSON
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase1(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsJSONCase2")]
+        public void TestCasePasteAsJSONCase2()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+            // Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase2(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsJSONCase3")]
+        public void TestCasePasteAsJSONCase3()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+            // Open Advanced Paste window using hotkey, press Ctrl + 3 and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase3(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+        }
+
+        /*
+         * Clipboard History
+           - [] Open Settings and Enable clipboard history (if not enabled already). Open Advanced Paste window with hotkey, click Clipboard history and try deleting some entry. Check OS clipboard history (Win+V), and confirm that the same entry no longer exist.
+           - [] Open Advanced Paste window with hotkey, click Clipboard history, and click any entry (but first). Observe that entry is put on top of clipboard history. Check OS clipboard history (Win+V), and confirm that the same entry is on top of the clipboard.
+           - [] Open Settings and Disable clipboard history. Open Advanced Paste window with hotkey and observe that Clipboard history button is disabled.
+         * Disable Advanced Paste, try different Advanced Paste hotkeys and confirm that it's disabled and nothing happens.
+         */
+        private void TestCaseClipboardHistory()
+        {
+        }
+
+        private void ContentCopyAndPasteDirectly(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.V);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Backspace);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteWithShortcutThenPasteAgain(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.O);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.V);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteCase3(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // Click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as plain text").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteCase4(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(1000);
+
+            // press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            this.SendKeys(Key.LCtrl, Key.Num1);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase1(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.M);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase2(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // click Paste as markdown button and confirm that pasted text is converted to markdown
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as markdown").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase3(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            this.SendKeys(Key.LCtrl, Key.Num2);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase1(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.J);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase2(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // click Paste as markdown button and confirm that pasted text is converted to markdown
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as JSON").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase3(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle(Path.GetFileName(tempFile), isRTF);
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            this.SendKeys(Key.LCtrl, Key.Num3);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private string DeleteAndCopyFile(string sourceFileName, string destinationFileName)
+        {
+            string sourcePath = Path.Combine(testFilesFolderPath, sourceFileName);
+            string destinationPath = Path.Combine(testFilesFolderPath, destinationFileName);
+
+            // Check if source file exists
+            if (!File.Exists(sourcePath))
+            {
+                throw new FileNotFoundException($"Source file not found: {sourcePath}");
+            }
+
+            // Delete destination file if it exists
+            if (File.Exists(destinationPath))
+            {
+                try
+                {
+                    File.Delete(destinationPath);
+                }
+                catch (IOException ex)
+                {
+                    throw new IOException($"Failed to delete file {destinationPath}. The file may be in use: {ex.Message}", ex);
+                }
+            }
+
+            // Copy the source file to the destination
+            try
+            {
+                File.Copy(sourcePath, destinationPath);
+            }
+            catch (IOException ex)
+            {
+                throw new IOException($"Failed to copy file from {sourcePath} to {destinationPath}: {ex.Message}", ex);
+            }
+
+            return destinationPath;
+        }
+
+        private void ChangeNotePadSettings()
+        {
+            Process process = Process.Start("notepad.exe");
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start Notepad.exe");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = FindWindowWithFlexibleTitle("Untitled", false);
+
+            window.Find<PowerToys.UITest.Button>("Settings").Click();
+            var combobox = window.Find<PowerToys.UITest.ComboBox>("Opening files");
+            combobox.SelectTxt("Open in a new window");
+
+            window.Find<Group>("When Notepad starts").Click();
+
+            window.Find<PowerToys.UITest.RadioButton>("Open a new window").Select();
+
+            _notepadSettingsChanged = true;
+            window.Close();
+        }
+
+        /// <summary>
+        /// Finds a window with flexible title matching, trying multiple title variations
+        /// </summary>
+        /// <param name="baseTitle">The base title to search for</param>
+        /// <param name="isRTF">Whether the window is a WordPad window</param>
+        /// <returns>The found Window element or throws an exception if not found</returns>
+        private Window FindWindowWithFlexibleTitle(string baseTitle, bool isRTF)
+        {
+            Window? window = null;
+            string appType = isRTF ? "WordPad" : "Notepad";
+
+            // Try different title variations
+            string[] titleVariations = new string[]
+            {
+                baseTitle + (isRTF ? " - WordPad" : " - Notepad"),  // With suffix
+                baseTitle,                                          // Without suffix
+                Path.GetFileNameWithoutExtension(baseTitle) + (isRTF ? " - WordPad" : " - Notepad"),  // Without extension, with suffix
+                Path.GetFileNameWithoutExtension(baseTitle),        // Without extension, without suffix
+            };
+
+            Exception? lastException = null;
+
+            foreach (string title in titleVariations)
+            {
+                try
+                {
+                    window = this.Find<Window>(title, global: true);
+                    if (window != null)
+                    {
+                        return window;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    // Save the exception, but continue trying other variations
+                    lastException = ex;
+                }
+            }
+
+            // If we couldn't find the window with any variation, throw an exception with details
+            throw new InvalidOperationException(
+                $"Failed to find {appType} window with title containing '{baseTitle}'. ");
+        }
+
+        private static void CopySettingsFileBeforeTests()
+        {
+            try
+            {
+                // Determine the assembly location and test files path
+                string? assemblyLocation = Path.GetDirectoryName(typeof(AdvancedPasteUITest).Assembly.Location);
+                if (assemblyLocation == null)
+                {
+                    Debug.WriteLine("ERROR: Failed to get assembly location");
+                    return;
+                }
+
+                string testFilesFolder = Path.Combine(assemblyLocation, "TestFiles");
+                if (!Directory.Exists(testFilesFolder))
+                {
+                    Debug.WriteLine($"ERROR: Test files directory not found at: {testFilesFolder}");
+                    return;
+                }
+
+                // Settings file source path
+                string settingsFileName = "settings.json";
+                string sourceSettingsPath = Path.Combine(testFilesFolder, settingsFileName);
+
+                // Make sure the source file exists
+                if (!File.Exists(sourceSettingsPath))
+                {
+                    Debug.WriteLine($"ERROR: Settings file not found at: {sourceSettingsPath}");
+                    return;
+                }
+
+                // Determine the target directory in %LOCALAPPDATA%
+                string targetDirectory = Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                    "Microsoft",
+                    "PowerToys",
+                    "AdvancedPaste");
+
+                // Create the directory if it doesn't exist
+                if (!Directory.Exists(targetDirectory))
+                {
+                    Directory.CreateDirectory(targetDirectory);
+                }
+
+                string targetSettingsPath = Path.Combine(targetDirectory, settingsFileName);
+
+                // Copy the file and overwrite if it exists
+                File.Copy(sourceSettingsPath, targetSettingsPath, true);
+
+                Debug.WriteLine($"Successfully copied settings file from {sourceSettingsPath} to {targetSettingsPath}");
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"ERROR copying settings file: {ex.Message}");
+            }
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/Helper/FileReader.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Windows.Forms;
+
+namespace Microsoft.AdvancedPaste.UITests.Helper;
+
+public class FileReader
+{
+    public static string ReadContent(string filePath)
+    {
+        try
+        {
+            return File.ReadAllText(filePath);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to read file: {ex.Message}", ex);
+        }
+    }
+
+    public static string ReadRTFPlainText(string filePath)
+    {
+        try
+        {
+            using (var rtb = new System.Windows.Forms.RichTextBox())
+            {
+                rtb.Rtf = File.ReadAllText(filePath);
+                return rtb.Text;
+            }
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to read plain text from file: {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>
+    /// Compares the contents of two RTF files to check if they are consistent.
+    /// </summary>
+    /// <param name="firstFilePath">Path to the first RTF file</param>
+    /// <param name="secondFilePath">Path to the second RTF file</param>
+    /// <param name="compareFormatting">If true, compares the raw RTF content (including formatting).
+    /// If false, compares only the plain text content.</param>
+    /// <returns>
+    /// A tuple containing: (bool isConsistent, string firstContent, string secondContent)
+    /// - isConsistent: true if the files are consistent according to the comparison method
+    /// - firstContent: the content of the first file
+    /// - secondContent: the content of the second file
+    /// </returns>
+    public static (bool IsConsistent, string FirstContent, string SecondContent) CompareRtfFiles(
+        string firstFilePath,
+        string secondFilePath,
+        bool compareFormatting = false)
+    {
+        try
+        {
+            string firstContent, secondContent;
+
+            if (compareFormatting)
+            {
+                // Compare raw RTF content (including formatting)
+                firstContent = ReadContent(firstFilePath);
+                secondContent = ReadContent(secondFilePath);
+            }
+            else
+            {
+                // Compare only the plain text content
+                firstContent = ReadRTFPlainText(firstFilePath);
+                secondContent = ReadRTFPlainText(secondFilePath);
+            }
+
+            bool isConsistent = string.Equals(firstContent, secondContent, StringComparison.Ordinal);
+            return (isConsistent, firstContent, secondContent);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to compare RTF files: {ex.Message}", ex);
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsJsonFile.xml

@@ -0,0 +1,6 @@
+<note>
+    <to>Tove</to>
+    <from>Jani</from>
+    <heading>Reminder</heading>
+    <body>Don't forget me this weekend!</body>
+</note>

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsJsonResultFile.txt

@@ -0,0 +1,8 @@
+{
+  "note": {
+    "to": "Tove",
+    "from": "Jani",
+    "heading": "Reminder",
+    "body": "Don't forget me this weekend!"
+  }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsMarkdownFile.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+
+    <h2 title="I'm a header">The title Attribute</h2>
+
+    <p title="I'm a tooltip">Mouse over this paragraph, to display the title attribute as a tooltip.</p>
+
+</body>
+
+</html>

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsMarkdownResultFile.txt

@@ -0,0 +1,3 @@
+## The title Attribute
+ 
+Mouse over this paragraph, to display the title attribute as a tooltip.

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/settings.json

@@ -0,0 +1 @@
+{"properties":{"IsAdvancedAIEnabled":{"value":false},"ShowCustomPreview":{"value":true},"CloseAfterLosingFocus":{"value":false},"advanced-paste-ui-hotkey":{"win":true,"ctrl":false,"alt":false,"shift":true,"code":86,"key":""},"paste-as-plain-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":79,"key":""},"paste-as-markdown-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":77,"key":""},"paste-as-json-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":74,"key":""},"custom-actions":{"value":[]},"additional-actions":{"image-to-text":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-file":{"isShown":true,"paste-as-txt-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-png-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-html-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}},"transcode":{"isShown":true,"transcode-to-mp3":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"transcode-to-mp4":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}}}},"name":"AdvancedPaste","version":"1"}

src/modules/AdvancedPaste/UITest-AdvancedPaste/UITestAdvancedPaste.md

@@ -0,0 +1,41 @@
+## [Advanced Paste](tests-checklist-template-advanced-paste-section.md)
+  NOTES:
+    When using Advanced Paste, make sure that window focused while starting/using Advanced paste is text editor or has text input field focused (e.g. Word).
+ * Paste As Plain Text
+   - [x] Copy some rich text (e.g word of the text is different color, another work is bold, underlined, etd.).
+   - [x] Paste the text using standard Windows Ctrl + V shortcut and ensure that rich text is pasted (with all colors, formatting, etc.)
+   - [x] Paste the text using Paste As Plain Text activation shortcut and ensure that plain text without any formatting is pasted.
+   - [x] Paste again the text using standard Windows Ctrl + V shortcut and ensure the text is now pasted plain without formatting as well.
+   - [x] Copy some rich text again.
+   - [x] Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+   - [x] Copy some rich text again.
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+ * Paste As Markdown
+   - [] Open Settings and set Paste as Markdown directly hotkey
+   - [x] Copy some text (e.g. some HTML text - convertible to Markdown)
+   - [x] Paste the text using set hotkey and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+   - [x] Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 2 and confirm that pasted text is converted to markdown
+ * Paste As JSON
+   - [] Open Settings and set Paste as JSON directly hotkey
+   - [x] Copy some XML or CSV text (or any other text, it will be converted to simple JSON object)
+   - [x] Paste the text using set hotkey and confirm that pasted text is converted to JSON
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+   - [x] Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 3 and confirm that pasted text is converted to markdown
+ * Paste as custom format using AI
+   - [] Open Settings, navigate to Enable Paste with AI and set OpenAI key.
+   - [] Copy some text to clipboard. Any text.
+   - [] Open Advanced Paste window using hotkey, and confirm that Custom intput text box is now enabled. Write "Insert smiley after every word" and press Enter. Observe that result preview shows coppied text with smileys between words. Press Enter to paste the result and observe that it is pasted.
+   - [] Open Advanced Paste window using hotkey. Input some query (any, feel free to play around) and press Enter. When result is shown, click regenerate button, to see if new result is generated. Select one of the results and paste. Observe that correct result is pasted.
+   - [] Create few custom actions. Set up hotkey for custom actions and confirm they work. Enable/disable custom actions and confirm that the change is reflected in Advanced Paste UI - custom action is not listed. Try different ctrl + <num> in-app shortcuts for custom actions. Try moving custom actions up/down and confirm that the change is reflected in Advanced Paste UI.
+   - [] Open Settings and disable Custom format preview. Open Advanced Paste window with hotkey, enter some query and press enter. Observe that result is now pasted right away, without showing the preview first.
+   - [] Open Settings and Disable Enable Paste with AI. Open Advanced Paste window with hotkey and observe that Custom Input text box is now disabled.
+ * Clipboard History
+   - [] Open Settings and Enable clipboard history (if not enabled already). Open Advanced Paste window with hotkey, click Clipboard history and try deleting some entry. Check OS clipboard history (Win+V), and confirm that the same entry no longer exist.
+   - [] Open Advanced Paste window with hotkey, click Clipboard history, and click any entry (but first). Observe that entry is put on top of clipboard history. Check OS clipboard history (Win+V), and confirm that the same entry is on top of the clipboard.
+   - [] Open Settings and Disable clipboard history. Open Advanced Paste window with hotkey and observe that Clipboard history button is disabled.
+ * Disable Advanced Paste, try different Advanced Paste hotkeys and confirm that it's disabled and nothing happens.

src/modules/cmdpal/Microsoft.CmdPal.Common/Services/IRunHistoryService.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+
+namespace Microsoft.CmdPal.Common.Services;
+
+public interface IRunHistoryService
+{
+    /// <summary>
+    /// Gets the run history.
+    /// </summary>
+    /// <returns>A list of run history items.</returns>
+    IReadOnlyList<string> GetRunHistory();
+
+    /// <summary>
+    /// Clears the run history.
+    /// </summary>
+    void ClearRunHistory();
+
+    /// <summary>
+    /// Adds a run history item.
+    /// </summary>
+    /// <param name="item">The run history item to add.</param>
+    void AddRunHistoryItem(string item);
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/AppStateModel.cs

@@ -21,8 +21,12 @@ public partial class AppStateModel : ObservableObject
 
     ///////////////////////////////////////////////////////////////////////////
     // STATE HERE
+    // Make sure that you make the setters public (JsonSerializer.Deserialize will fail silently otherwise)!
+    // Make sure that any new types you add are added to JsonSerializationContext!
     public RecentCommandsManager RecentCommands { get; set; } = new();
 
+    public List<string> RunHistory { get; set; } = [];
+
     // END SETTINGS
     ///////////////////////////////////////////////////////////////////////////
 
@@ -86,7 +90,7 @@ public partial class AppStateModel : ObservableObject
                 {
                     foreach (var item in newSettings)
                     {
-                        savedSettings[item.Key] = item.Value != null ? item.Value.DeepClone() : null;
+                        savedSettings[item.Key] = item.Value?.DeepClone();
                     }
 
                     var serialized = savedSettings.ToJsonString(JsonSerializationContext.Default.AppStateModel.Options);
@@ -121,20 +125,4 @@ public partial class AppStateModel : ObservableObject
         // now, the settings is just next to the exe
         return Path.Combine(directory, "state.json");
     }
-
-    // [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "<Pending>")]
-    // private static readonly JsonSerializerOptions _serializerOptions = new()
-    // {
-    //    WriteIndented = true,
-    //    Converters = { new JsonStringEnumConverter() },
-    // };
-
-    // private static readonly JsonSerializerOptions _deserializerOptions = new()
-    // {
-    //    PropertyNameCaseInsensitive = true,
-    //    IncludeFields = true,
-    //    AllowTrailingCommas = true,
-    //    PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate,
-    //    ReadCommentHandling = JsonCommentHandling.Skip,
-    // };
 }

src/modules/cmdpal/Microsoft.CmdPal.UI/App.xaml.cs

@@ -101,6 +101,7 @@ public partial class App : Application
         var files = new IndexerCommandsProvider();
         files.SuppressFallbackWhen(ShellCommandsProvider.SuppressFileFallbackIf);
         services.AddSingleton<ICommandProvider>(allApps);
+
         services.AddSingleton<ICommandProvider, ShellCommandsProvider>();
         services.AddSingleton<ICommandProvider, CalculatorCommandProvider>();
         services.AddSingleton<ICommandProvider>(files);
@@ -146,6 +147,7 @@ public partial class App : Application
         services.AddSingleton(state);
         services.AddSingleton<IExtensionService, ExtensionService>();
         services.AddSingleton<TrayIconService>();
+        services.AddSingleton<IRunHistoryService, RunHistoryService>();
 
         services.AddSingleton<IRootPageService, PowerToysRootPageService>();
         services.AddSingleton<IAppHostService, PowerToysAppHostService>();

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/SearchBar.xaml.cs

@@ -336,8 +336,6 @@ public sealed partial class SearchBar : UserControl,
                     // ... Move the cursor to the end of the input
                     FilterBox.Select(FilterBox.Text.Length, 0);
                 }
-
-                // TODO! deal with suggestion
             }
             else if (property == nameof(ListViewModel.InitialSearchText))
             {

src/modules/cmdpal/Microsoft.CmdPal.UI/RunHistoryService.cs

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.Common.Services;
+using Microsoft.CmdPal.UI.ViewModels;
+
+namespace Microsoft.CmdPal.UI;
+
+internal sealed class RunHistoryService : IRunHistoryService
+{
+    private readonly AppStateModel _appStateModel;
+
+    public RunHistoryService(AppStateModel appStateModel)
+    {
+        _appStateModel = appStateModel;
+    }
+
+    public IReadOnlyList<string> GetRunHistory()
+    {
+        if (_appStateModel.RunHistory.Count == 0)
+        {
+            var history = Microsoft.Terminal.UI.RunHistory.CreateRunHistory();
+            _appStateModel.RunHistory.AddRange(history);
+        }
+
+        return _appStateModel.RunHistory;
+    }
+
+    public void ClearRunHistory()
+    {
+        _appStateModel.RunHistory.Clear();
+    }
+
+    public void AddRunHistoryItem(string item)
+    {
+        // insert at the beginning of the list
+        if (string.IsNullOrWhiteSpace(item))
+        {
+            return; // Do not add empty or whitespace items
+        }
+
+        _appStateModel.RunHistory.Remove(item);
+
+        // Add the item to the front of the history
+        _appStateModel.RunHistory.Insert(0, item);
+
+        AppStateModel.SaveState(_appStateModel);
+    }
+}

src/modules/cmdpal/Microsoft.Terminal.UI/IconPathConverter.cpp

@@ -383,4 +383,5 @@ namespace winrt::Microsoft::Terminal::UI::implementation
         icon.Height(targetSize);
         return icon;
     }
+
 }

src/modules/cmdpal/Microsoft.Terminal.UI/IconPathConverter.h

@@ -13,6 +13,7 @@ namespace winrt::Microsoft::Terminal::UI::implementation
         static Microsoft::UI::Xaml::Controls::IconSource IconSourceMUX(const winrt::hstring& iconPath, bool convertToGrayscale, const int targetSize=24);
         static Microsoft::UI::Xaml::Controls::IconElement IconMUX(const winrt::hstring& iconPath);
         static Microsoft::UI::Xaml::Controls::IconElement IconMUX(const winrt::hstring& iconPath, const int targetSize);
+
     };
 }
 

src/modules/cmdpal/Microsoft.Terminal.UI/Microsoft.Terminal.UI.vcxproj

@@ -153,6 +153,9 @@
     <ClInclude Include="IconPathConverter.h">
       <DependentUpon>IconPathConverter.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="RunHistory.h">
+      <DependentUpon>RunHistory.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="ResourceString.h">
       <DependentUpon>ResourceString.idl</DependentUpon>
     </ClInclude>
@@ -168,6 +171,9 @@
     <ClCompile Include="IconPathConverter.cpp">
       <DependentUpon>IconPathConverter.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="RunHistory.cpp">
+      <DependentUpon>RunHistory.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="ResourceString.cpp">
       <DependentUpon>ResourceString.idl</DependentUpon>
     </ClCompile>
@@ -176,6 +182,7 @@
   <ItemGroup>
     <Midl Include="Converters.idl" />
     <Midl Include="IconPathConverter.idl" />
+    <Midl Include="RunHistory.idl" />
     <Midl Include="IDirectKeyListener.idl" />
     <Midl Include="ResourceString.idl" />
   </ItemGroup>

src/modules/cmdpal/Microsoft.Terminal.UI/RunHistory.cpp

@@ -0,0 +1,87 @@
+#include "pch.h"
+#include "RunHistory.h"
+#include "RunHistory.g.cpp"
+
+
+using namespace winrt::Windows;
+
+namespace winrt::Microsoft::Terminal::UI::implementation
+{
+    // Run history
+    // Largely copied from the Run work circa 2022.
+
+    winrt::Windows::Foundation::Collections::IVector<hstring> RunHistory::CreateRunHistory()
+    {
+        // Load MRU history
+        std::vector<hstring> history;
+
+        wil::unique_hmodule _comctl;
+        HANDLE(WINAPI* _createMRUList)(MRUINFO* lpmi);
+        int(WINAPI* _enumMRUList)(HANDLE hMRU,int nItem,void* lpData,UINT uLen);
+        void(WINAPI *_freeMRUList)(HANDLE hMRU);
+        int(WINAPI *_addMRUString)(HANDLE hMRU, LPCWSTR szString);
+
+        // Lazy load comctl32.dll
+        // Theoretically, we could cache this into a magic static, but we shouldn't need to actually do this more than once in CmdPal
+        _comctl.reset(LoadLibraryExW(L"comctl32.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32));
+
+        _createMRUList = reinterpret_cast<decltype(_createMRUList)>(GetProcAddress(_comctl.get(), "CreateMRUListW"));
+        FAIL_FAST_LAST_ERROR_IF(!_createMRUList);
+
+        _enumMRUList = reinterpret_cast<decltype(_enumMRUList)>(GetProcAddress(_comctl.get(), "EnumMRUListW"));
+        FAIL_FAST_LAST_ERROR_IF(!_enumMRUList);
+
+        _freeMRUList = reinterpret_cast<decltype(_freeMRUList)>(GetProcAddress(_comctl.get(), "FreeMRUList"));
+        FAIL_FAST_LAST_ERROR_IF(!_freeMRUList);
+
+        _addMRUString = reinterpret_cast<decltype(_addMRUString)>(GetProcAddress(_comctl.get(), "AddMRUStringW"));
+        FAIL_FAST_LAST_ERROR_IF(!_addMRUString);
+
+        static const WCHAR c_szRunMRU[] = REGSTR_PATH_EXPLORER L"\\RunMRU";
+        MRUINFO mi = {
+            sizeof(mi),
+            26,
+            MRU_CACHEWRITE,
+            HKEY_CURRENT_USER,
+            c_szRunMRU,
+            NULL // NOTE: use default string compare
+            // since this is a GLOBAL MRU
+        };
+
+        if (const auto hMruList = _createMRUList(&mi))
+        {
+            auto freeMRUList = wil::scope_exit([=]() {
+                _freeMRUList(hMruList);
+            });
+
+            for (int nMax = _enumMRUList(hMruList, -1, NULL, 0), i = 0; i < nMax; ++i)
+            {
+                WCHAR szCommand[MAX_PATH + 2];
+
+                const auto length = _enumMRUList(hMruList, i, szCommand, ARRAYSIZE(szCommand));
+                if (length > 1)
+                {
+                    // clip off the null-terminator
+                    std::wstring_view text{ szCommand, wil::safe_cast<size_t>(length - 1) };
+//#pragma disable warning(C26493)
+#pragma warning( push )
+#pragma warning( disable : 26493 )
+                    if (text.back() == L'\\')
+                    {
+                        // old MRU format has a slash at the end with the show cmd
+                        text = { szCommand, wil::safe_cast<size_t>(length - 2) };
+#pragma warning( pop )
+                        if (text.empty())
+                        {
+                            continue;
+                        }
+                    }
+                    history.emplace_back(text);
+                }
+            }
+        }
+
+        // Update dropdown & initial value
+        return winrt::single_threaded_observable_vector<winrt::hstring>(std::move(history));
+    }
+}

src/modules/cmdpal/Microsoft.Terminal.UI/RunHistory.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RunHistory.g.h"
+#include "types.h"
+
+namespace winrt::Microsoft::Terminal::UI::implementation
+{
+    struct RunHistory
+    {
+        RunHistory() = default;
+        static winrt::Windows::Foundation::Collections::IVector<hstring> CreateRunHistory();
+
+    private:
+        winrt::Windows::Foundation::Collections::IVector<hstring> _mruHistory;
+    };
+}
+
+namespace winrt::Microsoft::Terminal::UI::factory_implementation
+{
+    BASIC_FACTORY(RunHistory);
+}

src/modules/cmdpal/Microsoft.Terminal.UI/RunHistory.idl

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+namespace Microsoft.Terminal.UI
+{
+    static runtimeclass RunHistory
+    {
+        static Windows.Foundation.Collections.IVector<String> CreateRunHistory();
+    };
+
+}

src/modules/cmdpal/Microsoft.Terminal.UI/pch.h

@@ -64,6 +64,8 @@
 
 // WIL
 #include <wil/com.h>
+#include <wil/resource.h>
+#include <wil/safecast.h>
 #include <wil/stl.h>
 #include <wil/filesystem.h>
 // Due to the use of RESOURCE_SUPPRESS_STL in result.h, we need to include resource.h first, which happens
@@ -90,6 +92,7 @@
 
 #include <winrt/Windows.ApplicationModel.Resources.h>
 #include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
 
 #include <winrt/Windows.Graphics.Imaging.h>
 #include <Windows.Graphics.Imaging.Interop.h>

src/modules/cmdpal/Microsoft.Terminal.UI/types.h

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#define MRU_CACHEWRITE 0x0002
+#define REGSTR_PATH_EXPLORER TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer")
+
+// https://learn.microsoft.com/en-us/windows/win32/shell/mrucmpproc
+typedef int(CALLBACK* MRUCMPPROC)(
+    LPCTSTR pString1,
+    LPCTSTR pString2);
+
+// https://learn.microsoft.com/en-us/windows/win32/shell/mruinfo
+struct MRUINFO
+{
+    DWORD cbSize;
+    UINT uMax;
+    UINT fFlags;
+    HKEY hKey;
+    LPCTSTR lpszSubKey;
+    MRUCMPPROC lpfnCompare;
+};

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Calc.UnitTests/BracketHelperTests.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.Ext.Calc.Helper;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Calc.UnitTests;
+
+[TestClass]
+public class BracketHelperTests
+{
+    [DataTestMethod]
+    [DataRow(null)]
+    [DataRow("")]
+    [DataRow("\t \r\n")]
+    [DataRow("none")]
+    [DataRow("()")]
+    [DataRow("(())")]
+    [DataRow("()()")]
+    [DataRow("(()())")]
+    [DataRow("([][])")]
+    [DataRow("([(()[])[](([]()))])")]
+    public void IsBracketComplete_TestValid_WhenCalled(string input)
+    {
+        // Arrange
+
+        // Act
+        var result = BracketHelper.IsBracketComplete(input);
+
+        // Assert
+        Assert.IsTrue(result);
+    }
+
+    [DataTestMethod]
+    [DataRow("((((", "only opening brackets")]
+    [DataRow("]]]", "only closing brackets")]
+    [DataRow("([)(])", "inner bracket mismatch")]
+    [DataRow(")(", "opening and closing reversed")]
+    [DataRow("(]", "mismatch in bracket type")]
+    public void IsBracketComplete_TestInvalid_WhenCalled(string input, string invalidReason)
+    {
+        // Arrange
+
+        // Act
+        var result = BracketHelper.IsBracketComplete(input);
+
+        // Assert
+        Assert.IsFalse(result, invalidReason);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Calc.UnitTests/ExtendedCalculatorParserTests.cs

@@ -0,0 +1,389 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using Microsoft.CmdPal.Ext.Calc.Helper;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Calc.UnitTests;
+
+[TestClass]
+public class ExtendedCalculatorParserTests
+{
+    [DataTestMethod]
+    [DataRow(null)]
+    [DataRow("")]
+    [DataRow("  ")]
+    public void InputValid_ThrowError_WhenCalledNullOrEmpty(string input)
+    {
+        // Act
+        Assert.IsTrue(!CalculateHelper.InputValid(input));
+    }
+
+    [DataTestMethod]
+    [DataRow("test")]
+    [DataRow("[10,10]")] // '[10,10]' is interpreted as array by mages engine
+    public void Interpret_NoResult_WhenCalled(string input)
+    {
+        var settings = new SettingsManager();
+
+        var result = CalculateEngine.Interpret(settings, input, CultureInfo.CurrentCulture, out _);
+
+        // Assert
+        Assert.AreEqual(default(CalculateResult), result);
+    }
+
+    private static IEnumerable<object[]> Interpret_NoErrors_WhenCalledWithRounding_Data =>
+        [
+            ["2 * 2", 4M],
+            ["-2 ^ 2", -4M],
+            ["-(2 ^ 2)", -4M],
+            ["2 * pi", 6.28318530717959M],
+            ["round(2 * pi)", 6M],
+
+            // ["1 == 2", default(decimal)],
+            ["pi * ( sin ( cos ( 2)))", -1.26995475603563M],
+            ["5.6/2", 2.8M],
+            ["123 * 4.56", 560.88M],
+            ["1 - 9.0 / 10", 0.1M],
+            ["0.5 * ((2*-395.2)+198.2)", -296.1M],
+            ["2+2.11", 4.11M],
+            ["8.43 + 4.43 - 12.86", 0M],
+            ["8.43 + 4.43 - 12.8", 0.06M],
+            ["exp(5)", 148.413159102577M],
+            ["e^5", 148.413159102577M],
+            ["e*2", 5.43656365691809M],
+            ["ln(3)", 1.09861228866811M],
+            ["log(3)", 0.47712125471966M],
+            ["log2(3)", 1.58496250072116M],
+            ["log10(3)", 0.47712125471966M],
+            ["ln(e)", 1M],
+            ["cosh(0)", 1M],
+        ];
+
+    [DataTestMethod]
+    [DynamicData(nameof(Interpret_NoErrors_WhenCalledWithRounding_Data))]
+    public void Interpret_NoErrors_WhenCalledWithRounding(string input, decimal expectedResult)
+    {
+        var settings = new SettingsManager();
+
+        // Act
+        // Using InvariantCulture since this is internal
+        var result = CalculateEngine.Interpret(settings, input, CultureInfo.InvariantCulture, out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(CalculateEngine.FormatMax15Digits(expectedResult, new CultureInfo("en-US")), result.RoundedResult);
+    }
+
+    private static IEnumerable<object[]> Interpret_GreaterPrecision_WhenCalled_Data =>
+        [
+            ["0.100000000000000000000", 0.1M],
+            ["0.200000000000000000000000", 0.2M],
+        ];
+
+    [DynamicData(nameof(Interpret_GreaterPrecision_WhenCalled_Data))]
+    [DataTestMethod]
+    public void Interpret_GreaterPrecision_WhenCalled(string input, decimal expectedResult)
+    {
+        // Arrange
+        var settings = new SettingsManager();
+
+        // Act
+        // Using InvariantCulture since this is internal
+        var result = CalculateEngine.Interpret(settings, input, CultureInfo.InvariantCulture, out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result.Result);
+    }
+
+    private static IEnumerable<object[]> Interpret_DifferentCulture_WhenCalled_Data =>
+        [
+            ["4.5/3", 1.5M, "nl-NL"],
+            ["4.5/3", 1.5M, "en-EN"],
+            ["4.5/3", 1.5M, "de-DE"],
+        ];
+
+    [DataTestMethod]
+    [DynamicData(nameof(Interpret_DifferentCulture_WhenCalled_Data))]
+    public void Interpret_DifferentCulture_WhenCalled(string input, decimal expectedResult, string cultureName)
+    {
+        // Arrange
+        var cultureInfo = CultureInfo.GetCultureInfo(cultureName);
+        var settings = new SettingsManager();
+
+        // Act
+        var result = CalculateEngine.Interpret(settings, input, cultureInfo, out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(CalculateEngine.Round(expectedResult), result.RoundedResult);
+    }
+
+    [DataTestMethod]
+    [DataRow("log(3)", true)]
+    [DataRow("ln(3)", true)]
+    [DataRow("log2(3)", true)]
+    [DataRow("log10(3)", true)]
+    [DataRow("log2", false)]
+    [DataRow("log10", false)]
+    [DataRow("log", false)]
+    [DataRow("ln", false)]
+    [DataRow("ceil(2 * (pi ^ 2))", true)]
+    [DataRow("((1 * 2)", false)]
+    [DataRow("(1 * 2)))", false)]
+    [DataRow("abcde", false)]
+    [DataRow("1 + 2 +", false)]
+    [DataRow("1+2*", false)]
+    [DataRow("1+2/", false)]
+    [DataRow("1+2%", false)]
+    [DataRow("1 && 3 &&", false)]
+    [DataRow("sqrt( 36)", true)]
+    [DataRow("max 4", false)]
+    [DataRow("sin(0)", true)]
+    [DataRow("sinh(1)", true)]
+    [DataRow("tanh(0)", true)]
+    [DataRow("artanh(pi/2)", true)]
+    [DataRow("cosh", false)]
+    [DataRow("cos", false)]
+    [DataRow("abs", false)]
+    [DataRow("1+1.1e3", true)]
+    [DataRow("randi(8)", true)]
+    [DataRow("randi()", false)]
+    [DataRow("randi(0.5)", true)]
+    [DataRow("rand()", true)]
+    [DataRow("rand(0.5)", false)]
+    [DataRow("0X78AD+0o123", true)]
+    [DataRow("0o9", false)]
+    public void InputValid_TestValid_WhenCalled(string input, bool valid)
+    {
+        // Act
+        var result = CalculateHelper.InputValid(input);
+
+        // Assert
+        Assert.AreEqual(valid, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("1-1")]
+    [DataRow("sin(0)")]
+    [DataRow("sinh(0)")]
+    public void Interpret_MustReturnResult_WhenResultIsZero(string input)
+    {
+        // Arrange
+        var settings = new SettingsManager();
+
+        // Act
+        // Using InvariantCulture since this is internal
+        var result = CalculateEngine.Interpret(settings, input, CultureInfo.InvariantCulture, out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(0.0M, result.Result);
+    }
+
+    private static IEnumerable<object[]> Interpret_MustReturnExpectedResult_WhenCalled_Data =>
+        [
+
+            // ["factorial(5)", 120M], ToDo: this don't support now
+            // ["sign(-2)", -1M],
+            // ["sign(2)", +1M],
+            ["abs(-2)", 2M],
+            ["abs(2)", 2M],
+            ["0+(1*2)/(0+1)", 2M], // Validate that division by "(0+1)" is not interpret as division by zero.
+            ["0+(1*2)/0.5", 4M], // Validate that division by number with decimal digits is not interpret as division by zero.
+        ];
+
+    [DataTestMethod]
+    [DynamicData(nameof(Interpret_MustReturnExpectedResult_WhenCalled_Data))]
+    public void Interpret_MustReturnExpectedResult_WhenCalled(string input, decimal expectedResult)
+    {
+        // Arrange
+        var settings = new SettingsManager();
+
+        // Act
+        // Using en-us culture to have a fixed number style
+        var result = CalculateEngine.Interpret(settings, input, new CultureInfo("en-us", false), out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result.Result);
+    }
+
+    private static IEnumerable<object[]> Interpret_TestScientificNotation_WhenCalled_Data =>
+        [
+            ["0.2E1", "en-US", 2M],
+            ["0,2E1", "pt-PT", 2M],
+        ];
+
+    [DataTestMethod]
+    [DynamicData(nameof(Interpret_TestScientificNotation_WhenCalled_Data))]
+    public void Interpret_TestScientificNotation_WhenCalled(string input, string sourceCultureName, decimal expectedResult)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo(sourceCultureName, false), new CultureInfo("en-US", false));
+        var settings = new SettingsManager();
+
+        // Act
+        // Using en-us culture to have a fixed number style
+        var translatedInput = translator.Translate(input);
+        var result = CalculateEngine.Interpret(settings, translatedInput, new CultureInfo("en-US", false), out _);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result.Result);
+    }
+
+    [DataTestMethod]
+    [DataRow("sin(90)", "sin((pi / 180) * (90))")]
+    [DataRow("arcsin(0.5)", "(180 / pi) * (arcsin(0.5))")]
+    [DataRow("sin(sin(30))", "sin((pi / 180) * (sin((pi / 180) * (30))))")]
+    [DataRow("cos(tan(45))", "cos((pi / 180) * (tan((pi / 180) * (45))))")]
+    [DataRow("arctan(sin(30))", "(180 / pi) * (arctan(sin((pi / 180) * (30))))")]
+    [DataRow("sin(cos(tan(30)))", "sin((pi / 180) * (cos((pi / 180) * (tan((pi / 180) * (30))))))")]
+    [DataRow("sin(arcsin(0.5))", "sin((pi / 180) * ((180 / pi) * (arcsin(0.5))))")]
+    [DataRow("sin(30) + cos(60)", "sin((pi / 180) * (30)) + cos((pi / 180) * (60))")]
+    [DataRow("sin(30 + 15)", "sin((pi / 180) * (30 + 15))")]
+    [DataRow("sin(45) * cos(45) - tan(30)", "sin((pi / 180) * (45)) * cos((pi / 180) * (45)) - tan((pi / 180) * (30))")]
+    [DataRow("arcsin(arccos(0.5))", "(180 / pi) * (arcsin((180 / pi) * (arccos(0.5))))")]
+    [DataRow("sin(sin(sin(30)))", "sin((pi / 180) * (sin((pi / 180) * (sin((pi / 180) * (30))))))")]
+    [DataRow("log(10)", "log(10)")]
+    [DataRow("sin(30) + pi", "sin((pi / 180) * (30)) + pi")]
+    [DataRow("sin(-30)", "sin((pi / 180) * (-30))")]
+    [DataRow("sin((30))", "sin((pi / 180) * ((30)))")]
+    [DataRow("arcsin(1) * 2", "(180 / pi) * (arcsin(1)) * 2")]
+    [DataRow("cos(1/2)", "cos((pi / 180) * (1/2))")]
+    [DataRow("sin ( 90 )", "sin ((pi / 180) * ( 90 ))")]
+    [DataRow("cos(arcsin(sin(45)))", "cos((pi / 180) * ((180 / pi) * (arcsin(sin((pi / 180) * (45))))))")]
+    public void UpdateTrigFunctions_Degrees(string input, string expectedResult)
+    {
+        // Call UpdateTrigFunctions in degrees mode
+        var result = CalculateHelper.UpdateTrigFunctions(input, CalculateEngine.TrigMode.Degrees);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("sin(90)", "sin((pi / 200) * (90))")]
+    [DataRow("arcsin(0.5)", "(200 / pi) * (arcsin(0.5))")]
+    [DataRow("sin(sin(30))", "sin((pi / 200) * (sin((pi / 200) * (30))))")]
+    [DataRow("cos(tan(45))", "cos((pi / 200) * (tan((pi / 200) * (45))))")]
+    [DataRow("arctan(sin(30))", "(200 / pi) * (arctan(sin((pi / 200) * (30))))")]
+    [DataRow("sin(cos(tan(30)))", "sin((pi / 200) * (cos((pi / 200) * (tan((pi / 200) * (30))))))")]
+    [DataRow("sin(arcsin(0.5))", "sin((pi / 200) * ((200 / pi) * (arcsin(0.5))))")]
+    [DataRow("sin(30) + cos(60)", "sin((pi / 200) * (30)) + cos((pi / 200) * (60))")]
+    [DataRow("sin(30 + 15)", "sin((pi / 200) * (30 + 15))")]
+    [DataRow("sin(45) * cos(45) - tan(30)", "sin((pi / 200) * (45)) * cos((pi / 200) * (45)) - tan((pi / 200) * (30))")]
+    [DataRow("arcsin(arccos(0.5))", "(200 / pi) * (arcsin((200 / pi) * (arccos(0.5))))")]
+    [DataRow("sin(sin(sin(30)))", "sin((pi / 200) * (sin((pi / 200) * (sin((pi / 200) * (30))))))")]
+    [DataRow("log(10)", "log(10)")]
+    [DataRow("sin(30) + pi", "sin((pi / 200) * (30)) + pi")]
+    [DataRow("sin(-30)", "sin((pi / 200) * (-30))")]
+    [DataRow("sin((30))", "sin((pi / 200) * ((30)))")]
+    [DataRow("arcsin(1) * 2", "(200 / pi) * (arcsin(1)) * 2")]
+    [DataRow("cos(1/2)", "cos((pi / 200) * (1/2))")]
+    [DataRow("sin ( 90 )", "sin ((pi / 200) * ( 90 ))")]
+    [DataRow("cos(arcsin(sin(45)))", "cos((pi / 200) * ((200 / pi) * (arcsin(sin((pi / 200) * (45))))))")]
+    public void UpdateTrigFunctions_Gradians(string input, string expectedResult)
+    {
+        // Call UpdateTrigFunctions in gradians mode
+        var result = CalculateHelper.UpdateTrigFunctions(input, CalculateEngine.TrigMode.Gradians);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("rad(30)", "(180 / pi) * (30)")]
+    [DataRow("rad( 30 )", "(180 / pi) * ( 30 )")]
+    [DataRow("deg(30)", "(30)")]
+    [DataRow("grad(30)", "(9 / 10) * (30)")]
+    [DataRow("rad(  30)", "(180 / pi) * (  30)")]
+    [DataRow("rad(30  )", "(180 / pi) * (30  )")]
+    [DataRow("rad(  30  )", "(180 / pi) * (  30  )")]
+    [DataRow("rad(deg(30))", "(180 / pi) * ((30))")]
+    [DataRow("deg(rad(30))", "((180 / pi) * (30))")]
+    [DataRow("grad(rad(30))", "(9 / 10) * ((180 / pi) * (30))")]
+    [DataRow("rad(grad(30))", "(180 / pi) * ((9 / 10) * (30))")]
+    [DataRow("rad(30) + deg(45)", "(180 / pi) * (30) + (45)")]
+    [DataRow("sin(rad(30))", "sin((180 / pi) * (30))")]
+    [DataRow("cos( rad( 45 ) )", "cos( (180 / pi) * ( 45 ) )")]
+    [DataRow("tan(rad(grad(90)))", "tan((180 / pi) * ((9 / 10) * (90)))")]
+    [DataRow("rad(30) + rad(45)", "(180 / pi) * (30) + (180 / pi) * (45)")]
+    [DataRow("rad(30) * grad(90)", "(180 / pi) * (30) * (9 / 10) * (90)")]
+    [DataRow("rad(30)/rad(45)", "(180 / pi) * (30)/(180 / pi) * (45)")]
+    public void ExpandTrigConversions_Degrees(string input, string expectedResult)
+    {
+        // Call ExpandTrigConversions in degrees mode
+        var result = CalculateHelper.ExpandTrigConversions(input, CalculateEngine.TrigMode.Degrees);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("rad(30)", "(30)")]
+    [DataRow("rad( 30 )", "( 30 )")]
+    [DataRow("deg(30)", "(pi / 180) * (30)")]
+    [DataRow("grad(30)", "(pi / 200) * (30)")]
+    [DataRow("rad(  30)", "(  30)")]
+    [DataRow("rad(30  )", "(30  )")]
+    [DataRow("rad(  30  )", "(  30  )")]
+    [DataRow("rad(deg(30))", "((pi / 180) * (30))")]
+    [DataRow("deg(rad(30))", "(pi / 180) * ((30))")]
+    [DataRow("grad(rad(30))", "(pi / 200) * ((30))")]
+    [DataRow("rad(grad(30))", "((pi / 200) * (30))")]
+    [DataRow("rad(30) + deg(45)", "(30) + (pi / 180) * (45)")]
+    [DataRow("sin(rad(30))", "sin((30))")]
+    [DataRow("cos( rad( 45 ) )", "cos( ( 45 ) )")]
+    [DataRow("tan(rad(grad(90)))", "tan(((pi / 200) * (90)))")]
+    [DataRow("rad(30) + rad(45)", "(30) + (45)")]
+    [DataRow("rad(30) * grad(90)", "(30) * (pi / 200) * (90)")]
+    [DataRow("rad(30)/rad(45)", "(30)/(45)")]
+    public void ExpandTrigConversions_Radians(string input, string expectedResult)
+    {
+        // Call ExpandTrigConversions in radians mode
+        var result = CalculateHelper.ExpandTrigConversions(input, CalculateEngine.TrigMode.Radians);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("rad(30)", "(200 / pi) * (30)")]
+    [DataRow("rad( 30 )", "(200 / pi) * ( 30 )")]
+    [DataRow("deg(30)", "(10 / 9) * (30)")]
+    [DataRow("grad(30)", "(30)")]
+    [DataRow("rad(  30)", "(200 / pi) * (  30)")]
+    [DataRow("rad(30  )", "(200 / pi) * (30  )")]
+    [DataRow("rad(  30  )", "(200 / pi) * (  30  )")]
+    [DataRow("rad(deg(30))", "(200 / pi) * ((10 / 9) * (30))")]
+    [DataRow("deg(rad(30))", "(10 / 9) * ((200 / pi) * (30))")]
+    [DataRow("grad(rad(30))", "((200 / pi) * (30))")]
+    [DataRow("rad(grad(30))", "(200 / pi) * ((30))")]
+    [DataRow("rad(30) + deg(45)", "(200 / pi) * (30) + (10 / 9) * (45)")]
+    [DataRow("sin(rad(30))", "sin((200 / pi) * (30))")]
+    [DataRow("cos( rad( 45 ) )", "cos( (200 / pi) * ( 45 ) )")]
+    [DataRow("tan(rad(grad(90)))", "tan((200 / pi) * ((90)))")]
+    [DataRow("rad(30) + rad(45)", "(200 / pi) * (30) + (200 / pi) * (45)")]
+    [DataRow("rad(30) * grad(90)", "(200 / pi) * (30) * (90)")]
+    [DataRow("rad(30)/rad(45)", "(200 / pi) * (30)/(200 / pi) * (45)")]
+    public void ExpandTrigConversions_Gradians(string input, string expectedResult)
+    {
+        // Call ExpandTrigConversions in gradians mode
+        var result = CalculateHelper.ExpandTrigConversions(input, CalculateEngine.TrigMode.Gradians);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Calc.UnitTests/Microsoft.CmdPal.Ext.Calc.UnitTests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<IsPackable>false</IsPackable>
+		<RootNamespace>Microsoft.CmdPal.Ext.Calc.UnitTests</RootNamespace>
+		<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Moq" />
+		<PackageReference Include="MSTest" />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Calc\Microsoft.CmdPal.Ext.Calc.csproj" />
+	</ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Calc.UnitTests/NumberTranslatorTests.cs

@@ -0,0 +1,185 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Globalization;
+using Microsoft.CmdPal.Ext.Calc.Helper;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Calc.UnitTests;
+
+[TestClass]
+public class NumberTranslatorTests
+{
+    [DataTestMethod]
+    [DataRow(null, "en-US")]
+    [DataRow("de-DE", null)]
+    public void Create_ThrowError_WhenCalledNullOrEmpty(string sourceCultureName, string targetCultureName)
+    {
+        // Arrange
+        CultureInfo sourceCulture = sourceCultureName != null ? new CultureInfo(sourceCultureName) : null;
+        CultureInfo targetCulture = targetCultureName != null ? new CultureInfo(targetCultureName) : null;
+
+        // Act
+        Assert.ThrowsException<ArgumentNullException>(() => NumberTranslator.Create(sourceCulture, targetCulture));
+    }
+
+    [DataTestMethod]
+    [DataRow("en-US", "en-US")]
+    [DataRow("en-EN", "en-US")]
+    [DataRow("de-DE", "en-US")]
+    public void Create_WhenCalled(string sourceCultureName, string targetCultureName)
+    {
+        // Arrange
+        CultureInfo sourceCulture = new CultureInfo(sourceCultureName);
+        CultureInfo targetCulture = new CultureInfo(targetCultureName);
+
+        // Act
+        var translator = NumberTranslator.Create(sourceCulture, targetCulture);
+
+        // Assert
+        Assert.IsNotNull(translator);
+    }
+
+    [DataTestMethod]
+    [DataRow(null)]
+    public void Translate_ThrowError_WhenCalledNull(string input)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo("de-DE", false), new CultureInfo("en-US", false));
+
+        // Act
+        Assert.ThrowsException<ArgumentNullException>(() => translator.Translate(input));
+    }
+
+    [DataTestMethod]
+    [DataRow("")]
+    [DataRow(" ")]
+    public void Translate_WhenCalledEmpty(string input)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo("de-DE", false), new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.Translate(input);
+
+        // Assert
+        Assert.AreEqual(input, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("2,0 * 2", "2.0 * 2")]
+    [DataRow("4 * 3,6 + 9", "4 * 3.6 + 9")]
+    [DataRow("5,2+6", "5.2+6")]
+    [DataRow("round(2,5)", "round(2.5)")]
+    [DataRow("3,3333", "3.3333")]
+    [DataRow("max(2;3)", "max(2,3)")]
+    public void Translate_NoErrors_WhenCalled(string input, string expectedResult)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo("de-DE", false), new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.Translate(input);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("2.0 * 2", "2,0 * 2")]
+    [DataRow("4 * 3.6 + 9", "4 * 3,6 + 9")]
+    [DataRow("5.2+6", "5,2+6")]
+    [DataRow("round(2.5)", "round(2,5)")]
+    [DataRow("3.3333", "3,3333")]
+    public void TranslateBack_NoErrors_WhenCalled(string input, string expectedResult)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo("de-DE", false), new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.TranslateBack(input);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow(".", ",", "2,000,000", "2000000")]
+    [DataRow(".", ",", "2,000,000.6", "2000000.6")]
+    [DataRow(",", ".", "2.000.000", "2000000")]
+    [DataRow(",", ".", "2.000.000,6", "2000000.6")]
+    public void Translate_RemoveNumberGroupSeparator_WhenCalled(string decimalSeparator, string groupSeparator, string input, string expectedResult)
+    {
+        // Arrange
+        var sourceCulture = new CultureInfo("en-US", false)
+        {
+            NumberFormat =
+            {
+                NumberDecimalSeparator = decimalSeparator,
+                NumberGroupSeparator = groupSeparator,
+            },
+        };
+        var translator = NumberTranslator.Create(sourceCulture, new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.Translate(input);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("de-DE", "12,0004", "12.0004")]
+    [DataRow("de-DE", "0xF000", "61440")]
+    [DataRow("de-DE", "0", "0")]
+    [DataRow("de-DE", "00", "0")]
+    [DataRow("de-DE", "12.004", "12004")] // . is the group separator in de-DE
+    [DataRow("de-DE", "12.04", "1204")]
+    [DataRow("de-DE", "12.4", "124")]
+    [DataRow("de-DE", "3.004.044.444,05", "3004044444.05")]
+    [DataRow("de-DE", "123.01 + 52.30", "12301 + 5230")]
+    [DataRow("de-DE", "123.001 + 52.30", "123001 + 5230")]
+    [DataRow("fr-FR", "0", "0")]
+    [DataRow("fr-FR", "00", "0")]
+    [DataRow("fr-FR", "12.004", "12.004")] // . is not decimal or group separator in fr-FR
+    [DataRow("fr-FR", "12.04", "12.04")]
+    [DataRow("fr-FR", "12.4", "12.4")]
+    [DataRow("fr-FR", "12.0004", "12.0004")]
+
+    // [DataRow("fr-FR", "123.01 + 52.30", "123.01 + 52.30")]
+    // [DataRow("fr-FR", "123.001 + 52.30", "123.001 + 52.30")] passed locally, failed in CI
+    public void Translate_NoRemovalOfLeadingZeroesOnEdgeCases(string sourceCultureName, string input, string expectedResult)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo(sourceCultureName, false), new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.Translate(input);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+
+    [DataTestMethod]
+    [DataRow("en-US", "0xF000", "61440")]
+    [DataRow("en-US", "0xf4572220", "4099351072")]
+    [DataRow("en-US", "0x12345678", "305419896")]
+    public void Translate_LargeHexadecimalNumbersToDecimal(string sourceCultureName, string input, string expectedResult)
+    {
+        // Arrange
+        var translator = NumberTranslator.Create(new CultureInfo(sourceCultureName, false), new CultureInfo("en-US", false));
+
+        // Act
+        var result = translator.Translate(input);
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.AreEqual(expectedResult, result);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Helper/CalculateEngine.cs

@@ -108,7 +108,7 @@ public static class CalculateEngine
     ///   100000.9999999999 → "100001"
     ///   1234567890123.45  → "1234567890123.45"
     /// </summary>
-    private static decimal FormatMax15Digits(decimal value, CultureInfo cultureInfo)
+    public static decimal FormatMax15Digits(decimal value, CultureInfo cultureInfo)
     {
         var absValue = Math.Abs(value);
         var integerDigits = absValue >= 1 ? (int)Math.Floor(Math.Log10((double)absValue)) + 1 : 1;

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Registry/Microsoft.CmdPal.Ext.Registry.csproj

@@ -11,12 +11,6 @@
     <ProjectPriFileName>Microsoft.CmdPal.Ext.Registry.pri</ProjectPriFileName>
   </PropertyGroup>
 
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.Registry.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="System.ServiceProcess.ServiceController" />
   </ItemGroup>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Registry/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.CmdPal.Ext.Registry.UnitTests")]

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/FallbackExecuteItem.cs

@@ -15,10 +15,11 @@ namespace Microsoft.CmdPal.Ext.Shell;
 
 internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDisposable
 {
+    private readonly Action<string>? _addToHistory;
     private CancellationTokenSource? _cancellationTokenSource;
     private Task? _currentUpdateTask;
 
-    public FallbackExecuteItem(SettingsManager settings)
+    public FallbackExecuteItem(SettingsManager settings, Action<string>? addToHistory)
         : base(
             new NoOpCommand() { Id = "com.microsoft.run.fallback" },
             Resources.shell_command_display_title)
@@ -26,6 +27,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         Title = string.Empty;
         Subtitle = Properties.Resources.generic_run_command;
         Icon = Icons.RunV2Icon; // Defined in Icons.cs and contains the execute command icon.
+        _addToHistory = addToHistory;
     }
 
     public override void UpdateQuery(string query)
@@ -142,7 +144,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         if (exeExists)
         {
             // TODO we need to probably get rid of the settings for this provider entirely
-            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath);
+            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath, _addToHistory);
             Title = exeItem.Title;
             Subtitle = exeItem.Subtitle;
             Icon = exeItem.Icon;
@@ -151,7 +153,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         }
         else if (pathIsDir)
         {
-            var pathItem = new PathListItem(exe, query);
+            var pathItem = new PathListItem(exe, query, _addToHistory);
             Title = pathItem.Title;
             Subtitle = pathItem.Subtitle;
             Icon = pathItem.Icon;
@@ -160,7 +162,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         }
         else if (System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
         {
-            Command = new OpenUrlCommand(searchText) { Result = CommandResult.Dismiss() };
+            Command = new OpenUrlWithHistoryCommand(searchText, _addToHistory) { Result = CommandResult.Dismiss() };
             Title = searchText;
         }
         else

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Helpers/ShellListPageHelpers.cs

@@ -7,7 +7,9 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CmdPal.Ext.Shell.Commands;
+using Microsoft.CmdPal.Ext.Shell.Pages;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Ext.Shell.Helpers;
@@ -94,4 +96,80 @@ public class ShellListPageHelpers
             }
         }
     }
+
+    internal static ListItem? ListItemForCommandString(string query, Action<string>? addToHistory)
+    {
+        var li = new ListItem();
+
+        var searchText = query.Trim();
+        var expanded = Environment.ExpandEnvironmentVariables(searchText);
+        searchText = expanded;
+        if (string.IsNullOrEmpty(searchText) || string.IsNullOrWhiteSpace(searchText))
+        {
+            return null;
+        }
+
+        ShellListPage.ParseExecutableAndArgs(searchText, out var exe, out var args);
+
+        var exeExists = false;
+        var pathIsDir = false;
+        var fullExePath = string.Empty;
+
+        try
+        {
+            using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+
+            // Use Task.Run with timeout - this will actually timeout even if the sync operations don't respond to cancellation
+            var pathResolutionTask = Task.Run(
+                () =>
+            {
+                // Don't check cancellation token here - let the Task timeout handle it
+                exeExists = ShellListPageHelpers.FileExistInPath(exe, out fullExePath);
+                pathIsDir = Directory.Exists(expanded);
+            },
+                CancellationToken.None); // Use None here since we're handling timeout differently
+
+            // Wait for either completion or timeout
+            pathResolutionTask.Wait(cts.Token);
+        }
+        catch (OperationCanceledException)
+        {
+        }
+
+        if (exeExists)
+        {
+            // TODO we need to probably get rid of the settings for this provider entirely
+            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath, addToHistory);
+            li.Command = exeItem.Command;
+            li.Title = exeItem.Title;
+            li.Subtitle = exeItem.Subtitle;
+            li.Icon = exeItem.Icon;
+            li.MoreCommands = exeItem.MoreCommands;
+        }
+        else if (pathIsDir)
+        {
+            var pathItem = new PathListItem(exe, query, addToHistory);
+            li.Command = pathItem.Command;
+            li.Title = pathItem.Title;
+            li.Subtitle = pathItem.Subtitle;
+            li.Icon = pathItem.Icon;
+            li.MoreCommands = pathItem.MoreCommands;
+        }
+        else if (System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
+        {
+            li.Command = new OpenUrlWithHistoryCommand(searchText) { Result = CommandResult.Dismiss() };
+            li.Title = searchText;
+        }
+        else
+        {
+            return null;
+        }
+
+        if (li != null)
+        {
+            li.TextToSuggest = searchText;
+        }
+
+        return li;
+    }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Microsoft.CmdPal.Ext.Shell.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+    <ProjectReference Include="..\..\Microsoft.CmdPal.Common\Microsoft.CmdPal.Common.csproj" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="System.CommandLine" />

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/OpenUrlWithHistoryCommand.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Shell;
+
+internal sealed partial class OpenUrlWithHistoryCommand : OpenUrlCommand
+{
+    private readonly Action<string>? _addToHistory;
+    private readonly string _url;
+
+    public OpenUrlWithHistoryCommand(string url, Action<string>? addToHistory = null)
+        : base(url)
+    {
+        _addToHistory = addToHistory;
+        _url = url;
+    }
+
+    public override CommandResult Invoke()
+    {
+        _addToHistory?.Invoke(_url);
+        var result = base.Invoke();
+        return result;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/RunExeItem.cs

@@ -13,6 +13,7 @@ namespace Microsoft.CmdPal.Ext.Shell.Pages;
 internal sealed partial class RunExeItem : ListItem
 {
     private readonly Lazy<IconInfo> _icon;
+    private readonly Action<string>? _addToHistory;
 
     public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
 
@@ -22,7 +23,9 @@ internal sealed partial class RunExeItem : ListItem
 
     private string _args = string.Empty;
 
-    public RunExeItem(string exe, string args, string fullExePath)
+    private string FullString => string.IsNullOrEmpty(_args) ? Exe : $"{Exe} {_args}";
+
+    public RunExeItem(string exe, string args, string fullExePath, Action<string>? addToHistory)
     {
         FullExePath = fullExePath;
         Exe = exe;
@@ -41,6 +44,8 @@ internal sealed partial class RunExeItem : ListItem
             return t.Result;
         });
 
+        _addToHistory = addToHistory;
+
         UpdateArgs(args);
 
         MoreCommands = [
@@ -89,16 +94,22 @@ internal sealed partial class RunExeItem : ListItem
 
     public void Run()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args);
     }
 
     public void RunAsAdmin()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.Administrator);
     }
 
     public void RunAsOther()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.OtherUser);
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/ShellListPage.cs

@@ -8,6 +8,7 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
 using Microsoft.CmdPal.Ext.Shell.Properties;
 using Microsoft.CommandPalette.Extensions;
@@ -20,7 +21,11 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
     private readonly ShellListPageHelpers _helper;
 
     private readonly List<ListItem> _topLevelItems = [];
-    private readonly List<ListItem> _historyItems = [];
+    private readonly Dictionary<string, ListItem> _historyItems = [];
+    private readonly List<ListItem> _currentHistoryItems = [];
+
+    private readonly IRunHistoryService _historyService;
+
     private RunExeItem? _exeItem;
     private List<ListItem> _pathItems = [];
     private ListItem? _uriItem;
@@ -28,13 +33,16 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
     private CancellationTokenSource? _cancellationTokenSource;
     private Task? _currentSearchTask;
 
-    public ShellListPage(SettingsManager settingsManager, bool addBuiltins = false)
+    private bool _loadedInitialHistory;
+
+    public ShellListPage(SettingsManager settingsManager, IRunHistoryService runHistoryService, bool addBuiltins = false)
     {
         Icon = Icons.RunV2Icon;
         Id = "com.microsoft.cmdpal.shell";
         Name = Resources.cmd_plugin_name;
         PlaceholderText = Resources.list_placeholder_text;
         _helper = new(settingsManager);
+        _historyService = runHistoryService;
 
         EmptyContent = new CommandItem()
         {
@@ -68,8 +76,6 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         _cancellationTokenSource = new CancellationTokenSource();
         var cancellationToken = _cancellationTokenSource.Token;
 
-        IsLoading = true;
-
         try
         {
             // Save the latest search task
@@ -139,6 +145,10 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             _pathItems.Clear();
             _exeItem = null;
             _uriItem = null;
+
+            _currentHistoryItems.Clear();
+            _currentHistoryItems.AddRange(_historyItems.Values);
+
             return;
         }
 
@@ -206,6 +216,7 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             && (!exeExists || pathIsDir)
             && couldResolvePath)
         {
+            IsLoading = true;
             await CreatePathItemsAsync(expanded, searchText, cancellationToken);
         }
 
@@ -231,18 +242,53 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             _uriItem = null;
         }
 
+        var histItemsNotInSearch =
+            _historyItems
+                .Where(kv => !kv.Key.Equals(newSearch, StringComparison.OrdinalIgnoreCase));
+        if (_exeItem != null)
+        {
+            // If we have an exe item, we want to remove it from the history items
+            histItemsNotInSearch = histItemsNotInSearch
+                .Where(kv => !kv.Value.Title.Equals(_exeItem.Title, StringComparison.OrdinalIgnoreCase));
+        }
+
+        if (_uriItem != null)
+        {
+            // If we have an uri item, we want to remove it from the history items
+            histItemsNotInSearch = histItemsNotInSearch
+                .Where(kv => !kv.Value.Title.Equals(_uriItem.Title, StringComparison.OrdinalIgnoreCase));
+        }
+
+        // Filter the history items based on the search text
+        var filterHistory = (string query, KeyValuePair<string, ListItem> pair) =>
+        {
+            // Fuzzy search on the key (command string)
+            var score = StringMatcher.FuzzySearch(query, pair.Key).Score;
+            return score;
+        };
+
+        var filteredHistory =
+            ListHelpers.FilterList<KeyValuePair<string, ListItem>>(
+                histItemsNotInSearch,
+                searchText,
+                filterHistory)
+            .Select(p => p.Value);
+
+        _currentHistoryItems.Clear();
+        _currentHistoryItems.AddRange(filteredHistory);
+
         // Final cancellation check
         cancellationToken.ThrowIfCancellationRequested();
     }
 
-    private static ListItem PathToListItem(string path, string originalPath, string args = "")
+    private static ListItem PathToListItem(string path, string originalPath, string args = "", Action<string>? addToHistory = null)
     {
-        var pathItem = new PathListItem(path, originalPath);
+        var pathItem = new PathListItem(path, originalPath, addToHistory);
 
         // Is this path an executable? If so, then make a RunExeItem
         if (IsExecutable(path))
         {
-            var exeItem = new RunExeItem(Path.GetFileName(path), args, path);
+            var exeItem = new RunExeItem(Path.GetFileName(path), args, path, addToHistory);
 
             exeItem.MoreCommands = [
             .. exeItem.MoreCommands,
@@ -255,24 +301,30 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
 
     public override IListItem[] GetItems()
     {
+        if (!_loadedInitialHistory)
+        {
+            LoadInitialHistory();
+        }
+
         var filteredTopLevel = ListHelpers.FilterList(_topLevelItems, SearchText);
         List<ListItem> uriItems = _uriItem != null ? [_uriItem] : [];
         List<ListItem> exeItems = _exeItem != null ? [_exeItem] : [];
+
         return
             exeItems
             .Concat(filteredTopLevel)
-            .Concat(_historyItems)
+            .Concat(_currentHistoryItems)
             .Concat(_pathItems)
             .Concat(uriItems)
             .ToArray();
     }
 
-    internal static RunExeItem CreateExeItem(string exe, string args, string fullExePath)
+    internal static RunExeItem CreateExeItem(string exe, string args, string fullExePath, Action<string>? addToHistory)
     {
         // PathToListItem will return a RunExeItem if it can find a executable.
         // It will ALSO add the file search commands to the RunExeItem.
-        return PathToListItem(fullExePath, exe, args) as RunExeItem ??
-               new RunExeItem(exe, args, fullExePath);
+        return PathToListItem(fullExePath, exe, args, addToHistory) as RunExeItem ??
+               new RunExeItem(exe, args, fullExePath, addToHistory);
     }
 
     private void CreateAndAddExeItems(string exe, string args, string fullExePath)
@@ -284,7 +336,7 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         }
         else
         {
-            _exeItem = CreateExeItem(exe, args, fullExePath);
+            _exeItem = CreateExeItem(exe, args, fullExePath, AddToHistory);
         }
     }
 
@@ -442,6 +494,40 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         };
     }
 
+    private void LoadInitialHistory()
+    {
+        var hist = _historyService.GetRunHistory();
+        var histItems = hist
+            .Select(h => (h, ShellListPageHelpers.ListItemForCommandString(h, AddToHistory)))
+            .Where(tuple => tuple.Item2 != null)
+            .Select(tuple => (tuple.h, tuple.Item2!))
+            .ToList();
+        _historyItems.Clear();
+
+        // Add all the history items to the _historyItems dictionary
+        foreach (var (h, item) in histItems)
+        {
+            _historyItems[h] = item;
+        }
+
+        _currentHistoryItems.Clear();
+        _currentHistoryItems.AddRange(histItems.Select(tuple => tuple.Item2));
+
+        _loadedInitialHistory = true;
+    }
+
+    internal void AddToHistory(string commandString)
+    {
+        if (string.IsNullOrWhiteSpace(commandString))
+        {
+            return; // Do not add empty or whitespace items
+        }
+
+        _historyService.AddRunHistoryItem(commandString);
+        LoadInitialHistory();
+        DoUpdateSearchText(SearchText);
+    }
+
     public void Dispose()
     {
         _cancellationTokenSource?.Cancel();

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/PathListItem.cs

@@ -16,8 +16,8 @@ internal sealed partial class PathListItem : ListItem
 
     public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
 
-    public PathListItem(string path, string originalDir)
-        : base(new OpenUrlCommand(path))
+    public PathListItem(string path, string originalDir, Action<string>? addToHistory)
+        : base(new OpenUrlWithHistoryCommand(path, addToHistory))
     {
         var fileName = Path.GetFileName(path);
         _isDirectory = Directory.Exists(path);
@@ -50,6 +50,7 @@ internal sealed partial class PathListItem : ListItem
             new CommandContextItem(new CopyTextCommand(path) { Name = Properties.Resources.copy_path_command_name }) { }
         ];
 
+        // TODO: Follow-up during 0.4. Add the indexer commands here.
         // MoreCommands = [
         //    new CommandContextItem(new OpenWithCommand(indexerItem)),
         //    new CommandContextItem(new ShowFileInFolderCommand(indexerItem.FullPath) { Name = Resources.Indexer_Command_ShowInFolder }),

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/ShellCommandsProvider.cs

@@ -2,6 +2,7 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
 using Microsoft.CmdPal.Ext.Shell.Pages;
 using Microsoft.CmdPal.Ext.Shell.Properties;
@@ -15,18 +16,24 @@ public partial class ShellCommandsProvider : CommandProvider
     private readonly CommandItem _shellPageItem;
 
     private readonly SettingsManager _settingsManager = new();
+    private readonly ShellListPage _shellListPage;
     private readonly FallbackCommandItem _fallbackItem;
+    private readonly IRunHistoryService _historyService;
 
-    public ShellCommandsProvider()
+    public ShellCommandsProvider(IRunHistoryService runHistoryService)
     {
+        _historyService = runHistoryService;
+
         Id = "Run";
         DisplayName = Resources.cmd_plugin_name;
         Icon = Icons.RunV2Icon;
         Settings = _settingsManager.Settings;
 
-        _fallbackItem = new FallbackExecuteItem(_settingsManager);
+        _shellListPage = new ShellListPage(_settingsManager, _historyService);
 
-        _shellPageItem = new CommandItem(new ShellListPage(_settingsManager))
+        _fallbackItem = new FallbackExecuteItem(_settingsManager, _shellListPage.AddToHistory);
+
+        _shellPageItem = new CommandItem(_shellListPage)
         {
             Icon = Icons.RunV2Icon,
             Title = Resources.shell_command_name,

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.System/Microsoft.CmdPal.Ext.System.csproj

@@ -33,9 +33,4 @@
       <CustomToolNamespace>Microsoft.CmdPal.Ext.System</CustomToolNamespace>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.System.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
 </Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.System/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.CmdPal.Ext.System.UnitTests")]

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Microsoft.CmdPal.Ext.TimeDate.csproj

@@ -11,12 +11,6 @@
     <ProjectPriFileName>Microsoft.CmdPal.Ext.TimeDate.pri</ProjectPriFileName>
   </PropertyGroup>
 
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.TimeDate.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
   <ItemGroup>
     <EmbeddedResource Update="Properties\Resources.resx">
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.CmdPal.Ext.TimeDate.UnitTests")]

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowWalker/Microsoft.CmdPal.Ext.WindowWalker.csproj

@@ -46,9 +46,4 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.WindowWalker.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
 </Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowWalker/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.CmdPal.Ext.WindowWalker.UnitTests")]

src/modules/cmdpal/extensionsdk/Microsoft.CommandPalette.Extensions.Toolkit/ListHelpers.cs

@@ -43,7 +43,6 @@ public partial class ListHelpers
     }
 
     public static IEnumerable<T> FilterList<T>(IEnumerable<T> items, string query, Func<string, T, int> scoreFunction)
-        where T : class
     {
         var scores = items
             .Select(li => new Scored<T>() { Item = li, Score = scoreFunction(query, li) })

src/modules/cmdpal/extensionsdk/Microsoft.CommandPalette.Extensions.Toolkit/OpenUrlCommand.cs

@@ -4,7 +4,7 @@
 
 namespace Microsoft.CommandPalette.Extensions.Toolkit;
 
-public sealed partial class OpenUrlCommand : InvokableCommand
+public partial class OpenUrlCommand : InvokableCommand
 {
     private readonly string _target;
 

src/modules/colorPicker/UITest-ColorPicker/ColorPickerUITest.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.PowerToys.UITest;
+
+namespace Microsoft.ColorPicker.UITests
+{
+    public class ColorPickerUITest : UITestBase
+    {
+        public ColorPickerUITest()
+            : base(PowerToysModule.Runner)
+        {
+        }
+    }
+}

src/modules/colorPicker/UITest-ColorPicker/ColorPickerUITest.md

@@ -0,0 +1,16 @@
+## Color Picker
+* Enable the Color Picker in settings and ensure that the hotkey brings up Color Picker
+  - [] when PowerToys is running unelevated on start-up
+  - [] when PowerToys is running as admin on start-up
+  - [] when PowerToys is restarted as admin, by clicking the restart as admin button in the settings
+- [] Change `Activate Color Picker shortcut` and check the new shortcut is working
+- [] Try all three `Activation behavior`s(`Color Picker with editor mode enabled`, `Editor`, `Color Picker only`)
+- [] Change `Color format for clipboard` and check if the correct format is copied from the Color picker
+- [] Try to copy color formats to the clipboard from the Editor
+- [] Check `Show color name` and verify if color name is shown in the Color picker
+- [] Enable one new format, disable one existing format, reorder enabled formats and check if settings are populated to the Editor
+- [] Select a color from the history in the Editor
+- [] Remove color from the history in the Editor
+- [] Open the Color Picker from the Editor
+- [] Open Adjust color from the Editor
+- [] Check Color Picker logs for errors

src/modules/colorPicker/UITest-ColorPicker/UITest-ColorPicker.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{6880CE86-5B71-4440-9795-79A325F95747}</ProjectGuid>
+		<RootNamespace>Microsoft.ColorPicker.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\..\$(Platform)\$(Configuration)\tests\UITests-ColorPicker\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+</Project>

src/modules/powerrename/testapp/PowerRenameTest.vcxproj

@@ -32,7 +32,7 @@
       <PreprocessorDefinitions>WIN32;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>$(OutDir)\..\..\WinUI3Apps\PowerRenameLib.lib;Pathcch.lib;comctl32.lib;shlwapi.lib;shcore.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>Pathcch.lib;comctl32.lib;shlwapi.lib;shcore.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -60,6 +60,9 @@
     <ProjectReference Include="..\..\..\common\Themes\Themes.vcxproj">
       <Project>{98537082-0fdb-40de-abd8-0dc5a4269bab}</Project>
     </ProjectReference>
+    <ProjectReference Include="..\lib\PowerRenameLib.vcxproj">
+      <Project>{51920f1f-c28c-4adf-8660-4238766796c2}</Project>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

src/settings-ui/UITest-Settings/OOBEUITests.cs

@@ -0,0 +1,236 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.Settings.UITests
+{
+    [TestClass]
+    public class OOBEUITests : UITestBase
+    {
+        // Constants for file paths and identifiers
+        private const string LocalAppDataFolderPath = "%localappdata%\\Microsoft\\PowerToys";
+        private const string LastVersionFilePath = "%localappdata%\\Microsoft\\PowerToys\\last_version.txt";
+
+        public OOBEUITests()
+            : base(PowerToysModule.PowerToysSettings)
+        {
+        }
+
+        [TestMethod("OOBE.Basic.FirstStartTest")]
+        [TestCategory("OOBE test #1")]
+        public void TestOOBEFirstStart()
+        {
+            // Clean up previous PowerToys data to simulate first start
+            // CleanPowerToysData();
+
+            // Start PowerToys and verify OOBE opens
+            // StartPowerToysAndVerifyOOBEOpens();
+
+            // Navigate through all OOBE sections
+            NavigateThroughOOBESections();
+
+            // Close OOBE
+            CloseOOBE();
+
+            // Verify OOBE can be opened from Settings
+            // OpenOOBEFromSettings();
+        }
+
+        /*
+
+        [TestMethod("OOBE.WhatsNew.Test")]
+        [TestCategory("OOBE test #2")]
+        public void TestOOBEWhatsNew()
+        {
+            // Modify version file to trigger What's New
+            ModifyLastVersionFile();
+
+            // Start PowerToys and verify OOBE opens in What's New page
+            StartPowerToysAndVerifyWhatsNewOpens();
+
+            // Close OOBE
+            CloseOOBE();
+        }
+        */
+
+        private void CleanPowerToysData()
+        {
+            this.ExitScopeExe();
+
+            // Exit PowerToys if it's running
+            try
+            {
+                foreach (Process process in Process.GetProcessesByName("PowerToys"))
+                {
+                    process.Kill();
+                    process.WaitForExit();
+                }
+
+                // Delete PowerToys folder in LocalAppData
+                string powerToysFolder = Environment.ExpandEnvironmentVariables(LocalAppDataFolderPath);
+                if (Directory.Exists(powerToysFolder))
+                {
+                    Directory.Delete(powerToysFolder, true);
+                }
+
+                // Wait to ensure deletion is complete
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Inconclusive($"Could not clean PowerToys data: {ex.Message}");
+            }
+        }
+
+        private void StartPowerToysAndVerifyOOBEOpens()
+        {
+            try
+            {
+                // Start PowerToys
+                this.RestartScopeExe();
+
+                // Wait for OOBE window to appear
+                Task.Delay(5000).Wait();
+
+                // Verify OOBE window opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE window should open with 'Welcome to PowerToys' title");
+
+                // Verify we're on the Overview page
+                Assert.IsTrue(this.Has("Overview"), "OOBE should start on Overview page");
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to start PowerToys and verify OOBE: {ex.Message}");
+            }
+        }
+
+        private void NavigateThroughOOBESections()
+        {
+            // List of modules to test
+            string[] modules = new string[]
+            {
+                "What's new",
+                "Advanced Paste",
+            };
+
+            this.Find<NavigationViewItem>("Welcome to PowerToys").Click();
+
+            foreach (string module in modules)
+            {
+                TestModule(module);
+            }
+        }
+
+        private void TestModule(string moduleName)
+        {
+            var oobeWindow = this.Find<Window>("Welcome to PowerToys");
+            Assert.IsNotNull(oobeWindow);
+
+            /*
+                - [] open the Settings for that module
+                - [] verify the Settings work as expected (toggle some controls on/off etc.)
+                - [] close the Settings
+                - [] if it's available, test the `Launch module name` button
+                */
+            oobeWindow.Find<Button>(By.Name("Open Settings")).Click();
+
+            // Find<NavigationViewItem>("What's new").Click();
+            Task.Delay(1000).Wait();
+        }
+
+        private void CloseOOBE()
+        {
+            try
+            {
+                // Find the close button and click it
+                this.Session.CloseMainWindow();
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to close OOBE: {ex.Message}");
+            }
+        }
+
+        private void OpenOOBEFromSettings()
+        {
+            try
+            {
+                // Open PowerToys Settings
+                this.Session.Attach(PowerToysModule.PowerToysSettings);
+
+                // Navigate to General page
+                this.Find<NavigationViewItem>("General").Click();
+                Task.Delay(1000).Wait();
+
+                // Click on "Welcome to PowerToys" link
+                this.Find<HyperlinkButton>("Welcome to PowerToys").Click();
+                Task.Delay(2000).Wait();
+
+                // Verify OOBE opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE should open when clicking the link in Settings");
+
+                // Close OOBE
+                this.Session.CloseMainWindow();
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to open OOBE from Settings: {ex.Message}");
+            }
+        }
+
+        private void ModifyLastVersionFile()
+        {
+            try
+            {
+                // Create PowerToys folder if it doesn't exist
+                string powerToysFolder = Environment.ExpandEnvironmentVariables(LocalAppDataFolderPath);
+                if (!Directory.Exists(powerToysFolder))
+                {
+                    Directory.CreateDirectory(powerToysFolder);
+                }
+
+                // Write a different version to trigger What's New
+                string versionFilePath = Environment.ExpandEnvironmentVariables(LastVersionFilePath);
+                File.WriteAllText(versionFilePath, "0.0.1");
+
+                // Wait to ensure file is written
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Inconclusive($"Could not modify version file: {ex.Message}");
+            }
+        }
+
+        private void StartPowerToysAndVerifyWhatsNewOpens()
+        {
+            try
+            {
+                // Start PowerToys
+                this.RestartScopeExe();
+
+                // Wait for OOBE window to appear
+                Task.Delay(5000).Wait();
+
+                // Verify OOBE window opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE window should open");
+
+                // Verify we're on the What's New page
+                Assert.IsTrue(this.Has("What's new"), "OOBE should open on What's New page after version change");
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to verify What's New page: {ex.Message}");
+            }
+        }
+    }
+}

src/settings-ui/UITest-Settings/SettingsTests.cs

@@ -0,0 +1,149 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Windows.Devices.PointOfService.Provider;
+
+namespace Microsoft.Settings.UITests
+{
+    [TestClass]
+    public class SettingsTests : UITestBase
+    {
+        private readonly string[] dashboardModuleList =
+        {
+            "Advanced Paste",
+            "Always On Top",
+            "Awake",
+            "Color Picker",
+            "Command Palette",
+            "Environment Variables",
+            "FancyZones",
+            "File Locksmith",
+            "Find My Mouse",
+            "Hosts File Editor",
+            "Image Resizer",
+            "Keyboard Manager",
+            "Mouse Highlighter",
+            "Mouse Jump",
+            "Mouse Pointer Crosshairs",
+            "Mouse Without Borders",
+            "New+",
+            "Peek",
+            "PowerRename",
+            "PowerToys Run",
+            "Quick Accent",
+            "Registry Preview",
+            "Screen Ruler",
+            "Shortcut Guide",
+            "Text Extractor",
+            "Workspaces",
+            "ZoomIt",
+
+            // "Crop And Lock", // this module cannot be found, why?
+        };
+
+        private readonly string[] moduleProcess =
+        {
+            "PowerToys.AdvancedPaste",
+            "PowerToys.Run",
+            "PowerToys.AlwaysOnTop",
+            "PowerToys.Awake",
+            "PowerToys.ColorPickerUI",
+            "PowerToys.Peek.UI",
+        };
+
+        public SettingsTests()
+            : base(PowerToysModule.PowerToysSettings, size: WindowSize.Large)
+        {
+        }
+
+        [TestMethod("PowerToys.Settings.ModulesOnAndOffTest")]
+        [TestCategory("Settings Test #1")]
+        public void TestAllmoduleOnAndOff()
+        {
+            DisableAllModules();
+            Task.Delay(2000).Wait();
+
+            // module process won't be killed in debug mode settings UI!
+            // Assert.IsTrue(CheckModulesDisabled(), "Some modules are not disabled.");
+            EnableAllModules();
+            Task.Delay(2000).Wait();
+
+            // Assert.IsTrue(CheckModulesEnabled(), "Some modules are not Enabled.");
+        }
+
+        private void DisableAllModules()
+        {
+            Find<NavigationViewItem>("Dashboard").Click();
+
+            foreach (var moduleName in dashboardModuleList)
+            {
+                var moduleButton = Find<Button>(moduleName);
+                Assert.IsNotNull(moduleButton);
+                var toggle = moduleButton.Find<ToggleSwitch>("Enable module");
+                Assert.IsNotNull(toggle);
+                if (toggle.IsOn)
+                {
+                    toggle.Click();
+                }
+            }
+        }
+
+        private void EnableAllModules()
+        {
+            Find<NavigationViewItem>("Dashboard").Click();
+
+            foreach (var moduleName in dashboardModuleList)
+            {
+                // Scroll(direction: "Down");
+                var moduleButton = Find<Button>(moduleName);
+                Assert.IsNotNull(moduleButton);
+                var toggle = moduleButton.Find<ToggleSwitch>("Enable module");
+                Assert.IsNotNull(toggle);
+                if (!toggle.IsOn)
+                {
+                    toggle.Click();
+                }
+            }
+        }
+
+        private bool CheckModulesDisabled()
+        {
+            Process[] runningProcesses = Process.GetProcesses();
+
+            foreach (var process in moduleProcess)
+            {
+                if (runningProcesses.Any(p => p.ProcessName.Equals(process, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private bool CheckModulesEnabled()
+        {
+            Process[] runningProcesses = Process.GetProcesses();
+
+            foreach (var process in moduleProcess)
+            {
+                if (!runningProcesses.Any(p => p.ProcessName.Equals(process, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

src/settings-ui/UITest-Settings/SettingsTests.md

@@ -0,0 +1,41 @@
+## [General Settings](tests-checklist-template-settings-section.md)
+
+**Admin mode:**
+ - [] restart PT and verify it runs as user
+ - [] restart as admin and set "Always run as admin"
+ - [] restart PT and verify it  runs as admin
+ * if it's not on, turn on "Run at startup"
+ - [] reboot the machine and verify PT runs as admin (it should not prompt the UAC dialog)
+ * turn Always run as admin" off
+ - [] reboot the machine and verify it now runs as user
+
+**Modules on/off:**
+ - [x] turn off all the modules and verify all module are off
+ - [] restart PT and verify that all module are still off in the settings page and they are actually inactive
+ - [x] turn on all the module, all module are now working
+ - [] restart PT and verify that all module are still on in the settings page and they are actually working
+
+**Quick access tray icon flyout:**
+ - [] Use left click on the system tray icon and verify the flyout appears.
+ - [] Try to launch a module from the launch screen in the flyout.
+ - [] Try disabling a module in the all apps screen in the flyout, make it a module that's launchable from the launch screen. Verify that the module is disabled and that it also disappeared from the launch screen in the flyout.
+ - [] Open the main settings screen on a module page. Verify that when you disable/enable the module on the flyout, that the Settings page is updated too.
+
+**Settings backup/restore:**
+ - [] In the General tab, create a backup of the settings.
+ - [] Change some settings in some PowerToys.
+ - [] Restore the settings in the General tab and verify the Settings you've applied were reset.
+
+## OOBE
+ * Quit PowerToys
+ * Delete %localappdata%\Microsoft\PowerToys
+ - [] Start PowerToys and verify OOBE opens
+ * Change version saved on `%localappdata%\Microsoft\PowerToys\last_version.txt`
+ - [] Start PowerToys and verify OOBE opens in the "What's New" page
+ * Visit each OOBE section and for each section:
+   - [] open the Settings for that module
+   - [] verify the Settings work as expected (toggle some controls on/off etc.)
+   - [] close the Settings
+   - [] if it's available, test the `Launch module name` button
+ * Close OOBE
+ - [x] Open the Settings and from the General page open OOBE using the `Welcome to PowerToys` link

src/settings-ui/UITest-Settings/UITest-Settings.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{29B91A80-0590-4B1F-89B8-4F8812A7F116}</ProjectGuid>
+		<RootNamespace>Microsoft.Settings.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\$(Platform)\$(Configuration)\tests\UITests-Settings\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+</Project>

tools/build/build-installer.ps1

@@ -81,7 +81,7 @@ function RunMSBuild {
 
     $base = @(
         $Solution
-        "/p:Platform=`"$Platform`""
+        "/p:Platform=$Platform"
         "/p:Configuration=$Configuration"
         "/p:CIBuild=true"
         '/verbosity:normal'
@@ -158,4 +158,4 @@ RunMSBuild 'installer\PowerToysSetup.sln' "/m /t:PowerToysInstaller /p:PerUser=$
 
 RunMSBuild 'installer\PowerToysSetup.sln' "/m /t:PowerToysBootstrapper /p:PerUser=$PerUser"
 
-Write-Host '[PIPELINE] Completed'
+Write-Host '[PIPELINE] Completed'