Rename the [Ee]xts dir to ext (#38852)

**WARNING:** This PR will probably blow up all in-flight PRs

at some point in the early days of CmdPal, two of us created seperate
`Exts` and `exts` dirs. Depending on what the casing was on the branch
that you checked one of those out from, it'd get stuck like that on your
PC forever.

Windows didn't care, so we never noticed.

But GitHub does care, and now browsing the source on GitHub is basically
impossible.

Closes #38081

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AllAppsCommandProvider.cs

@@ -0,0 +1,63 @@
+// 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.Linq;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+public partial class AllAppsCommandProvider : CommandProvider
+{
+    public static readonly AllAppsPage Page = new();
+
+    private readonly CommandItem _listItem;
+
+    public AllAppsCommandProvider()
+    {
+        Id = "AllApps";
+        DisplayName = Resources.installed_apps;
+        Icon = IconHelpers.FromRelativePath("Assets\\AllApps.svg");
+        Settings = AllAppsSettings.Instance.Settings;
+
+        _listItem = new(Page)
+        {
+            Subtitle = Resources.search_installed_apps,
+            MoreCommands = [new CommandContextItem(AllAppsSettings.Instance.Settings.SettingsPage)],
+        };
+    }
+
+    public override ICommandItem[] TopLevelCommands() => [_listItem];
+
+    public ICommandItem? LookupApp(string displayName)
+    {
+        var items = Page.GetItems();
+
+        // We're going to do this search in two directions:
+        // First, is this name a substring of any app...
+        var nameMatches = items.Where(i => i.Title.Contains(displayName));
+
+        // ... Then, does any app have this name as a substring ...
+        // Only get one of these - "Terminal Preview" contains both "Terminal" and "Terminal Preview", so just take the best one
+        var appMatches = items.Where(i => displayName.Contains(i.Title)).OrderByDescending(i => i.Title.Length).Take(1);
+
+        // ... Now, combine those two
+        var both = nameMatches.Concat(appMatches);
+
+        if (both.Count() == 1)
+        {
+            return both.First();
+        }
+        else if (nameMatches.Count() == 1 && appMatches.Count() == 1)
+        {
+            if (nameMatches.First() == appMatches.First())
+            {
+                return nameMatches.First();
+            }
+        }
+
+        return null;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AllAppsPage.cs

@@ -0,0 +1,119 @@
+// 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;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ManagedCommon;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+public sealed partial class AllAppsPage : ListPage
+{
+    private readonly Lock _listLock = new();
+    private AppListItem[] allAppsSection = [];
+
+    public AllAppsPage()
+    {
+        this.Name = Resources.all_apps;
+        this.Icon = IconHelpers.FromRelativePath("Assets\\AllApps.svg");
+        this.ShowDetails = true;
+        this.IsLoading = true;
+        this.PlaceholderText = Resources.search_installed_apps_placeholder;
+
+        Task.Run(() =>
+        {
+            lock (_listLock)
+            {
+                BuildListItems();
+            }
+        });
+    }
+
+    public override IListItem[] GetItems()
+    {
+        if (allAppsSection.Length == 0 || AppCache.Instance.Value.ShouldReload())
+        {
+            lock (_listLock)
+            {
+                BuildListItems();
+            }
+        }
+
+        return allAppsSection;
+    }
+
+    private void BuildListItems()
+    {
+        this.IsLoading = true;
+
+        Stopwatch stopwatch = new();
+        stopwatch.Start();
+
+        List<AppItem> apps = GetPrograms();
+
+        this.allAppsSection = apps
+                        .Select((app) => new AppListItem(app, true))
+                        .ToArray();
+
+        this.IsLoading = false;
+
+        AppCache.Instance.Value.ResetReloadFlag();
+
+        stopwatch.Stop();
+        Logger.LogTrace($"{nameof(AllAppsPage)}.{nameof(BuildListItems)} took: {stopwatch.ElapsedMilliseconds} ms");
+    }
+
+    internal List<AppItem> GetPrograms()
+    {
+        IEnumerable<AppItem> uwpResults = AppCache.Instance.Value.UWPs
+            .Where((application) => application.Enabled)
+            .Select(app =>
+                new AppItem()
+                {
+                    Name = app.Name,
+                    Subtitle = app.Description,
+                    Type = UWPApplication.Type(),
+                    IcoPath = app.LogoType != LogoType.Error ? app.LogoPath : string.Empty,
+                    DirPath = app.Location,
+                    UserModelId = app.UserModelId,
+                    IsPackaged = true,
+                    Commands = app.GetCommands(),
+                });
+
+        IEnumerable<AppItem> win32Results = AppCache.Instance.Value.Win32s
+            .Where((application) => application.Enabled && application.Valid)
+            .Select(app =>
+            {
+                string icoPath = string.IsNullOrEmpty(app.IcoPath) ?
+                    (app.AppType == Win32Program.ApplicationType.InternetShortcutApplication ?
+                        app.IcoPath :
+                        app.FullPath) :
+                    app.IcoPath;
+
+                // icoPath = icoPath.EndsWith(".lnk", System.StringComparison.InvariantCultureIgnoreCase) ? (icoPath + ",0") : icoPath;
+                icoPath = icoPath.EndsWith(".lnk", System.StringComparison.InvariantCultureIgnoreCase) ?
+                    app.FullPath :
+                    icoPath;
+                return new AppItem()
+                {
+                    Name = app.Name,
+                    Subtitle = app.Description,
+                    Type = app.Type(),
+                    IcoPath = icoPath,
+                    ExePath = !string.IsNullOrEmpty(app.LnkFilePath) ? app.LnkFilePath : app.FullPath,
+                    DirPath = app.Location,
+                    Commands = app.GetCommands(),
+                };
+            });
+
+        return uwpResults.Concat(win32Results).OrderBy(app => app.Name).ToList();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AllAppsSettings.cs

@@ -0,0 +1,95 @@
+// 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.IO;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+public class AllAppsSettings : JsonSettingsManager
+{
+    private static readonly string _namespace = "apps";
+
+    private static string Namespaced(string propertyName) => $"{_namespace}.{propertyName}";
+
+    private static string Experimental(string propertyName) => $"{_namespace}.experimental.{propertyName}";
+
+#pragma warning disable SA1401 // Fields should be private
+    internal static AllAppsSettings Instance = new();
+#pragma warning restore SA1401 // Fields should be private
+
+    public DateTime LastIndexTime { get; set; }
+
+    public List<ProgramSource> ProgramSources { get; set; } = [];
+
+    public List<DisabledProgramSource> DisabledProgramSources { get; set; } = [];
+
+    public List<string> ProgramSuffixes { get; set; } = ["bat", "appref-ms", "exe", "lnk", "url"];
+
+    public List<string> RunCommandSuffixes { get; set; } = ["bat", "appref-ms", "exe", "lnk", "url", "cpl", "msc"];
+
+    public bool EnableStartMenuSource => _enableStartMenuSource.Value;
+
+    public bool EnableDesktopSource => _enableDesktopSource.Value;
+
+    public bool EnableRegistrySource => _enableRegistrySource.Value;
+
+    public bool EnablePathEnvironmentVariableSource => _enablePathEnvironmentVariableSource.Value;
+
+    private readonly ToggleSetting _enableStartMenuSource = new(
+        Namespaced(nameof(EnableStartMenuSource)),
+        Resources.enable_start_menu_source,
+        Resources.enable_start_menu_source,
+        true);
+
+    private readonly ToggleSetting _enableDesktopSource = new(
+        Namespaced(nameof(EnableDesktopSource)),
+        Resources.enable_desktop_source,
+        Resources.enable_desktop_source,
+        true);
+
+    private readonly ToggleSetting _enableRegistrySource = new(
+        Namespaced(nameof(EnableRegistrySource)),
+        Resources.enable_registry_source,
+        Resources.enable_registry_source,
+        false); // This one is very noisy
+
+    private readonly ToggleSetting _enablePathEnvironmentVariableSource = new(
+        Namespaced(nameof(EnablePathEnvironmentVariableSource)),
+        Resources.enable_path_environment_variable_source,
+        Resources.enable_path_environment_variable_source,
+        false); // this one is very VERY noisy
+
+    public double MinScoreThreshold { get; set; } = 0.75;
+
+    internal const char SuffixSeparator = ';';
+
+    internal static string SettingsJsonPath()
+    {
+        string directory = Utilities.BaseSettingsPath("Microsoft.CmdPal");
+        Directory.CreateDirectory(directory);
+
+        // now, the state is just next to the exe
+        return Path.Combine(directory, "settings.json");
+    }
+
+    public AllAppsSettings()
+    {
+        FilePath = SettingsJsonPath();
+
+        Settings.Add(_enableStartMenuSource);
+        Settings.Add(_enableDesktopSource);
+        Settings.Add(_enableRegistrySource);
+        Settings.Add(_enablePathEnvironmentVariableSource);
+
+        // Load settings from file upon initialization
+        LoadSettings();
+
+        Settings.SettingsChanged += (s, a) => this.SaveSettings();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AppCache.cs

@@ -0,0 +1,90 @@
+// 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.Linq;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Storage;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+public sealed class AppCache : IDisposable
+{
+    private Win32ProgramFileSystemWatchers _win32ProgramRepositoryHelper;
+
+    private PackageRepository _packageRepository;
+
+    private Win32ProgramRepository _win32ProgramRepository;
+
+    private bool _disposed;
+
+    public IList<Win32Program> Win32s => _win32ProgramRepository.Items;
+
+    public IList<UWPApplication> UWPs => _packageRepository.Items;
+
+    public static readonly Lazy<AppCache> Instance = new(() => new());
+
+    public AppCache()
+    {
+        _win32ProgramRepositoryHelper = new Win32ProgramFileSystemWatchers();
+        _win32ProgramRepository = new Win32ProgramRepository(_win32ProgramRepositoryHelper.FileSystemWatchers.Cast<IFileSystemWatcherWrapper>().ToList(), AllAppsSettings.Instance, _win32ProgramRepositoryHelper.PathsToWatch);
+
+        _packageRepository = new PackageRepository(new PackageCatalogWrapper());
+
+        var a = Task.Run(() =>
+        {
+            _win32ProgramRepository.IndexPrograms();
+        });
+
+        var b = Task.Run(() =>
+        {
+            _packageRepository.IndexPrograms();
+            UpdateUWPIconPath(ThemeHelper.GetCurrentTheme());
+        });
+
+        Task.WaitAll(a, b);
+
+        AllAppsSettings.Instance.LastIndexTime = DateTime.Today;
+    }
+
+    private void UpdateUWPIconPath(Theme theme)
+    {
+        if (_packageRepository != null)
+        {
+            foreach (UWPApplication app in _packageRepository)
+            {
+                app.UpdateLogoPath(theme);
+            }
+        }
+    }
+
+    public bool ShouldReload() => _packageRepository.ShouldReload() || _win32ProgramRepository.ShouldReload();
+
+    public void ResetReloadFlag()
+    {
+        _packageRepository.ResetReloadFlag();
+        _win32ProgramRepository.ResetReloadFlag();
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            if (disposing)
+            {
+                _win32ProgramRepositoryHelper?.Dispose();
+                _disposed = true;
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AppCommand.cs

@@ -0,0 +1,78 @@
+// 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.Diagnostics;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using WyHash;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+internal sealed partial class AppCommand : InvokableCommand
+{
+    private readonly AppItem _app;
+
+    internal AppCommand(AppItem app)
+    {
+        _app = app;
+
+        Name = Resources.run_command_action;
+        Id = GenerateId();
+    }
+
+    internal static async Task StartApp(string aumid)
+    {
+        var appManager = new ApplicationActivationManager();
+        const ActivateOptions noFlags = ActivateOptions.None;
+        await Task.Run(() =>
+        {
+            try
+            {
+                appManager.ActivateApplication(aumid, /*queryArguments*/ string.Empty, noFlags, out var unusedPid);
+            }
+            catch (System.Exception)
+            {
+            }
+        }).ConfigureAwait(false);
+    }
+
+    internal static async Task StartExe(string path)
+    {
+        var appManager = new ApplicationActivationManager();
+
+        // const ActivateOptions noFlags = ActivateOptions.None;
+        await Task.Run(() =>
+        {
+            Process.Start(new ProcessStartInfo(path) { UseShellExecute = true });
+        });
+    }
+
+    internal async Task Launch()
+    {
+        if (_app.IsPackaged)
+        {
+            await StartApp(_app.UserModelId);
+        }
+        else
+        {
+            await StartExe(_app.ExePath);
+        }
+    }
+
+    public override CommandResult Invoke()
+    {
+        _ = Launch();
+        return CommandResult.Dismiss();
+    }
+
+    private string GenerateId()
+    {
+        // Use WyHash64 to generate stable ID hashes.
+        // manually seeding with 0, so that the hash is stable across launches
+        var result = WyHash64.ComputeHash64(_app.Name + _app.Subtitle + _app.ExePath, seed: 0);
+        return $"{_app.Name}_{result}";
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AppItem.cs

@@ -0,0 +1,34 @@
+// 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;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps;
+
+internal sealed class AppItem
+{
+    public string Name { get; set; } = string.Empty;
+
+    public string Subtitle { get; set; } = string.Empty;
+
+    public string Type { get; set; } = string.Empty;
+
+    public string IcoPath { get; set; } = string.Empty;
+
+    public string ExePath { get; set; } = string.Empty;
+
+    public string DirPath { get; set; } = string.Empty;
+
+    public string UserModelId { get; set; } = string.Empty;
+
+    public bool IsPackaged { get; set; }
+
+    public List<CommandContextItem>? Commands { get; set; }
+
+    public AppItem()
+    {
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AppListItem.cs

@@ -0,0 +1,104 @@
+// 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.Threading.Tasks;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+internal sealed partial class AppListItem : ListItem
+{
+    private readonly AppItem _app;
+    private static readonly Tag _appTag = new("App");
+
+    private readonly Lazy<Details> _details;
+    private readonly Lazy<IconInfo> _icon;
+
+    public override IDetails? Details { get => _details.Value; set => base.Details = value; }
+
+    public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
+
+    public AppListItem(AppItem app, bool useThumbnails)
+        : base(new AppCommand(app))
+    {
+        _app = app;
+        Title = app.Name;
+        Subtitle = app.Subtitle;
+        Tags = [_appTag];
+        MoreCommands = _app.Commands!.ToArray();
+
+        _details = new Lazy<Details>(() => BuildDetails());
+        _icon = new Lazy<IconInfo>(() =>
+        {
+            var t = FetchIcon(useThumbnails);
+            t.Wait();
+            return t.Result;
+        });
+    }
+
+    private Details BuildDetails()
+    {
+        var metadata = new List<DetailsElement>();
+        metadata.Add(new DetailsElement() { Key = "Type", Data = new DetailsTags() { Tags = [new Tag(_app.Type)] } });
+        if (!_app.IsPackaged)
+        {
+            metadata.Add(new DetailsElement() { Key = "Path", Data = new DetailsLink() { Text = _app.ExePath } });
+        }
+
+        return new Details()
+        {
+            Title = this.Title,
+            HeroImage = this.Icon ?? new IconInfo(string.Empty),
+            Metadata = metadata.ToArray(),
+        };
+    }
+
+    public async Task<IconInfo> FetchIcon(bool useThumbnails)
+    {
+        IconInfo? icon = null;
+        if (_app.IsPackaged)
+        {
+            icon = new IconInfo(_app.IcoPath);
+            if (_details.IsValueCreated)
+            {
+                _details.Value.HeroImage = icon;
+            }
+
+            return icon;
+        }
+
+        if (useThumbnails)
+        {
+            try
+            {
+                var stream = await ThumbnailHelper.GetThumbnail(_app.ExePath);
+                if (stream != null)
+                {
+                    var data = new IconData(RandomAccessStreamReference.CreateFromStream(stream));
+                    icon = new IconInfo(data, data);
+                }
+            }
+            catch
+            {
+            }
+
+            icon = icon ?? new IconInfo(_app.IcoPath);
+        }
+        else
+        {
+            icon = new IconInfo(_app.IcoPath);
+        }
+
+        if (_details.IsValueCreated)
+        {
+            _details.Value.HeroImage = icon;
+        }
+
+        return icon;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Assets/AllApps.svg

@@ -0,0 +1,29 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1825_17772)">
+<path d="M7.2002 8H12.8002C13.242 8 13.6002 8.35817 13.6002 8.8V13.6C13.6002 14.0418 13.242 14.4 12.8002 14.4H7.2002V8Z" fill="url(#paint0_linear_1825_17772)"/>
+<path d="M0.799805 8H7.1998V14.4H1.59981C1.15798 14.4 0.799805 14.0418 0.799805 13.6V8Z" fill="url(#paint1_linear_1825_17772)"/>
+<path d="M0.799805 2.39961C0.799805 1.95778 1.15798 1.59961 1.5998 1.59961H6.3998C6.84163 1.59961 7.1998 1.95778 7.1998 2.39961V7.99961H0.799805V2.39961Z" fill="url(#paint2_linear_1825_17772)"/>
+<rect width="6.4" height="6.4" rx="0.8" transform="matrix(0.701061 0.713102 -0.701061 0.713102 10.7998 0)" fill="url(#paint3_linear_1825_17772)"/>
+</g>
+<defs>
+<linearGradient id="paint0_linear_1825_17772" x1="12.5686" y1="15.0983" x2="7.57856" y2="7.74389" gradientUnits="userSpaceOnUse">
+<stop stop-color="#5C6166"/>
+<stop offset="1" stop-color="#8A9299"/>
+</linearGradient>
+<linearGradient id="paint1_linear_1825_17772" x1="6.36596" y1="14.8714" x2="1.98416" y2="7.32118" gradientUnits="userSpaceOnUse">
+<stop stop-color="#2E3133"/>
+<stop offset="1" stop-color="#5C6166"/>
+</linearGradient>
+<linearGradient id="paint2_linear_1825_17772" x1="6.17254" y1="8.59747" x2="2.16557" y2="1.7111" gradientUnits="userSpaceOnUse">
+<stop stop-color="#8A9299"/>
+<stop offset="1" stop-color="#A1AAB3"/>
+</linearGradient>
+<linearGradient id="paint3_linear_1825_17772" x1="6.75524" y1="3.90242" x2="-0.056471" y2="3.62557" gradientUnits="userSpaceOnUse">
+<stop stop-color="#0078D4"/>
+<stop offset="1" stop-color="#3CCBF4"/>
+</linearGradient>
+<clipPath id="clip0_1825_17772">
+<rect width="16" height="16" fill="white"/>
+</clipPath>
+</defs>
+</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Commands/OpenInConsoleCommand.cs

@@ -0,0 +1,54 @@
+// 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.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps.Commands;
+
+internal sealed partial class OpenInConsoleCommand : InvokableCommand
+{
+    private static readonly IconInfo TheIcon = new("\ue838");
+
+    private readonly string _target;
+
+    public OpenInConsoleCommand(string target)
+    {
+        Name = Resources.open_path_in_console;
+        Icon = TheIcon;
+
+        _target = target;
+    }
+
+    internal static async Task LaunchTarget(string t)
+    {
+        await Task.Run(() =>
+        {
+            try
+            {
+                var processStartInfo = new ProcessStartInfo
+                {
+                    WorkingDirectory = t,
+                    FileName = "cmd.exe",
+                };
+
+                Process.Start(processStartInfo);
+            }
+            catch (Exception)
+            {
+                // Log.Exception($"Failed to open {Name} in console, {e.Message}", e, GetType());
+            }
+        });
+    }
+
+    public override CommandResult Invoke()
+    {
+        _ = LaunchTarget(_target).ConfigureAwait(false);
+
+        return CommandResult.Dismiss();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Commands/OpenPathCommand.cs

@@ -0,0 +1,40 @@
+// 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.Diagnostics;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps.Commands;
+
+internal sealed partial class OpenPathCommand : InvokableCommand
+{
+    private static readonly IconInfo TheIcon = new("\ue838");
+
+    private readonly string _target;
+
+    public OpenPathCommand(string target)
+    {
+        Name = Resources.open_location;
+        Icon = TheIcon;
+
+        _target = target;
+    }
+
+    internal static async Task LaunchTarget(string t)
+    {
+        await Task.Run(() =>
+        {
+            Process.Start(new ProcessStartInfo(t) { UseShellExecute = true });
+        });
+    }
+
+    public override CommandResult Invoke()
+    {
+        _ = LaunchTarget(_target).ConfigureAwait(false);
+
+        return CommandResult.Dismiss();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Commands/RunAsAdminCommand.cs

@@ -0,0 +1,61 @@
+// 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.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps.Commands;
+
+internal sealed partial class RunAsAdminCommand : InvokableCommand
+{
+    private static readonly IconInfo TheIcon = new("\uE7EF");
+
+    private readonly string _target;
+    private readonly string _parentDir;
+    private readonly bool _packaged;
+
+    public RunAsAdminCommand(string target, string parentDir, bool packaged)
+    {
+        Name = Resources.run_as_administrator;
+        Icon = TheIcon;
+
+        _target = target;
+        _parentDir = parentDir;
+        _packaged = packaged;
+    }
+
+    internal static async Task RunAsAdmin(string target, string parentDir, bool packaged)
+    {
+        await Task.Run(() =>
+        {
+            if (packaged)
+            {
+                var command = "shell:AppsFolder\\" + target;
+                command = Environment.ExpandEnvironmentVariables(command.Trim());
+
+                var info = ShellCommand.SetProcessStartInfo(command, verb: "runas");
+                info.UseShellExecute = true;
+                info.Arguments = string.Empty;
+                Process.Start(info);
+            }
+            else
+            {
+                var info = ShellCommand.GetProcessStartInfo(target, parentDir, string.Empty, ShellCommand.RunAsType.Administrator);
+
+                Process.Start(info);
+            }
+        });
+    }
+
+    public override CommandResult Invoke()
+    {
+        _ = RunAsAdmin(_target, _parentDir, _packaged).ConfigureAwait(false);
+
+        return CommandResult.Dismiss();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Commands/RunAsUserCommand.cs

@@ -0,0 +1,46 @@
+// 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.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Apps.Commands;
+
+internal sealed partial class RunAsUserCommand : InvokableCommand
+{
+    private static readonly IconInfo TheIcon = new("\uE7EE");
+
+    private readonly string _target;
+    private readonly string _parentDir;
+
+    public RunAsUserCommand(string target, string parentDir)
+    {
+        Name = Resources.run_as_different_user;
+        Icon = TheIcon;
+
+        _target = target;
+        _parentDir = parentDir;
+    }
+
+    internal static async Task RunAsAdmin(string target, string parentDir)
+    {
+        await Task.Run(() =>
+        {
+            var info = ShellCommand.GetProcessStartInfo(target, parentDir, string.Empty, ShellCommand.RunAsType.OtherUser);
+
+            Process.Start(info);
+        });
+    }
+
+    public override CommandResult Invoke()
+    {
+        _ = RunAsAdmin(_target, _parentDir).ConfigureAwait(false);
+
+        return CommandResult.Dismiss();
+    }
+}

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

@@ -0,0 +1,52 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <PropertyGroup>
+    <RootNamespace>Microsoft.CmdPal.Ext.Apps</RootNamespace>
+    <Nullable>enable</Nullable>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.IO.Abstractions" />
+    <PackageReference Include="Microsoft.Windows.CsWin32">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+
+    <PackageReference Include="WyHash" />
+
+    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Properties\Resources.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+	  <None Remove="Assets\AllApps.png" />
+    <None Remove="Assets\AllApps.svg" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Update="Assets\AllApps.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Update="Assets\AllApps.svg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Update="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+</Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/NativeMethods.txt

@@ -0,0 +1,19 @@
+GetPhysicallyInstalledSystemMemory
+GlobalMemoryStatusEx
+GetSystemInfo
+CoCreateInstance
+SetForegroundWindow
+IsIconic
+RegisterHotKey
+SetWindowLongPtr
+CallWindowProc
+ShowWindow
+SetForegroundWindow
+SetFocus
+SetActiveWindow
+MonitorFromWindow
+GetMonitorInfo
+SHCreateStreamOnFileEx
+CoAllowSetForegroundWindow
+SHCreateStreamOnFileEx
+SHLoadIndirectString

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/AppxFactory.cs

@@ -0,0 +1,14 @@
+// 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.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+// Reference : https://stackoverflow.com/questions/32122679/getting-icon-of-modern-windows-app-from-a-desktop-application
+[Guid("5842a140-ff9f-4166-8f5c-62f5b7b0c781")]
+[ComImport]
+public class AppxFactory
+{
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/AppxPackageHelper.cs

@@ -0,0 +1,45 @@
+// 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;
+using System.Runtime.InteropServices;
+using Windows.Win32.System.Com;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+public static class AppxPackageHelper
+{
+    private static readonly IAppxFactory AppxFactory = (IAppxFactory)new AppxFactory();
+
+    // This function returns a list of attributes of applications
+    internal static IEnumerable<IAppxManifestApplication> GetAppsFromManifest(IStream stream)
+    {
+        var reader = AppxFactory.CreateManifestReader(stream);
+        var manifestApps = reader.GetApplications();
+
+        while (manifestApps.GetHasCurrent())
+        {
+            var manifestApp = manifestApps.GetCurrent();
+            var hr = manifestApp.GetStringValue("AppListEntry", out var appListEntry);
+            _ = CheckHRAndReturnOrThrow(hr, appListEntry);
+            if (appListEntry != "none")
+            {
+                yield return manifestApp;
+            }
+
+            manifestApps.MoveNext();
+        }
+    }
+
+    internal static T CheckHRAndReturnOrThrow<T>(HRESULT hr, T result)
+    {
+        if (hr != HRESULT.S_OK)
+        {
+            Marshal.ThrowExceptionForHR((int)hr);
+        }
+
+        return result;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/DisabledProgramSource.cs

@@ -0,0 +1,9 @@
+// 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.CmdPal.Ext.Apps.Programs;
+
+public class DisabledProgramSource : ProgramSource
+{
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IApplicationActivationManager.cs

@@ -0,0 +1,47 @@
+// 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.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+// Reference : https://github.com/MicrosoftEdge/edge-launcher/blob/108e63df0b4cb5cd9d5e45aa7a264690851ec51d/MIcrosoftEdgeLauncherCsharp/Program.cs
+[Flags]
+public enum ActivateOptions
+{
+    None = 0x00000000,
+    DesignMode = 0x00000001,
+    NoErrorUI = 0x00000002,
+    NoSplashScreen = 0x00000004,
+}
+
+// ApplicationActivationManager
+[ComImport]
+[Guid("2e941141-7f97-4756-ba1d-9decde894a3d")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IApplicationActivationManager
+{
+    IntPtr ActivateApplication([In] string appUserModelId, [In] string arguments, [In] ActivateOptions options, [Out] out uint processId);
+
+    IntPtr ActivateForFile([In] string appUserModelId, [In] IntPtr /*IShellItemArray* */ itemArray, [In] string verb, [Out] out uint processId);
+
+    IntPtr ActivateForProtocol([In] string appUserModelId, [In] IntPtr /* IShellItemArray* */itemArray, [Out] out uint processId);
+}
+
+// Application Activation Manager Class
+[ComImport]
+[Guid("45BA127D-10A8-46EA-8AB7-56EA9078943C")]
+public class ApplicationActivationManager : IApplicationActivationManager
+{
+    [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)/*, PreserveSig*/]
+    public extern IntPtr ActivateApplication([In] string appUserModelId, [In] string arguments, [In] ActivateOptions options, [Out] out uint processId);
+
+    [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+    public extern IntPtr ActivateForFile([In] string appUserModelId, [In] IntPtr /*IShellItemArray* */ itemArray, [In] string verb, [Out] out uint processId);
+
+    [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+    public extern IntPtr ActivateForProtocol([In] string appUserModelId, [In] IntPtr /* IShellItemArray* */itemArray, [Out] out uint processId);
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IAppxFactory.cs

@@ -0,0 +1,20 @@
+// 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.InteropServices;
+using Windows.Win32.System.Com;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Guid("BEB94909-E451-438B-B5A7-D79E767B75D8")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IAppxFactory
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1300:Element should begin with upper-case letter", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Implements COM Interface")]
+    void _VtblGap0_2(); // skip 2 methods
+
+    internal IAppxManifestReader CreateManifestReader(IStream inputStream);
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IAppxManifestApplication.cs

@@ -0,0 +1,19 @@
+// 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.InteropServices;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Guid("5DA89BF4-3773-46BE-B650-7E744863B7E8")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IAppxManifestApplication
+{
+    [PreserveSig]
+    HRESULT GetStringValue([MarshalAs(UnmanagedType.LPWStr)] string name, [MarshalAs(UnmanagedType.LPWStr)] out string value);
+
+    [PreserveSig]
+    HRESULT GetAppUserModelId([MarshalAs(UnmanagedType.LPWStr)] out string value);
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IAppxManifestApplicationsEnumerator.cs

@@ -0,0 +1,19 @@
+// 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.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Guid("9EB8A55A-F04B-4D0D-808D-686185D4847A")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IAppxManifestApplicationsEnumerator
+{
+    IAppxManifestApplication GetCurrent();
+
+    bool GetHasCurrent();
+
+    bool MoveNext();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IAppxManifestProperties.cs

@@ -0,0 +1,19 @@
+// 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.InteropServices;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Guid("03FAF64D-F26F-4B2C-AAF7-8FE7789B8BCA")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IAppxManifestProperties
+{
+    [PreserveSig]
+    HRESULT GetBoolValue([MarshalAs(UnmanagedType.LPWStr)] string name, out bool value);
+
+    [PreserveSig]
+    HRESULT GetStringValue([MarshalAs(UnmanagedType.LPWStr)] string name, [MarshalAs(UnmanagedType.LPWStr)] out string value);
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IAppxManifestReader.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;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Guid("4E1BD148-55A0-4480-A3D1-15544710637C")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IAppxManifestReader
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1300:Element should begin with upper-case letter", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Implements COM Interface")]
+    void _VtblGap0_1(); // skip 1 method
+
+    IAppxManifestProperties GetProperties();
+
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1300:Element should begin with upper-case letter", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Implements COM Interface")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Implements COM Interface")]
+    void _VtblGap1_5(); // skip 5 methods
+
+    IAppxManifestApplicationsEnumerator GetApplications();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IFileVersionInfoWrapper.cs

@@ -0,0 +1,44 @@
+// 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.Diagnostics;
+using System.IO.Abstractions;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+public interface IFileVersionInfoWrapper
+{
+    FileVersionInfo? GetVersionInfo(string path);
+
+    string FileDescription { get; set; }
+}
+
+public class FileVersionInfoWrapper : IFileVersionInfoWrapper
+{
+    private readonly IFile _file;
+
+    public FileVersionInfoWrapper()
+        : this(new FileSystem().File)
+    {
+    }
+
+    public FileVersionInfoWrapper(IFile file)
+    {
+        _file = file;
+    }
+
+    public FileVersionInfo? GetVersionInfo(string path)
+    {
+        if (_file.Exists(path))
+        {
+            return FileVersionInfo.GetVersionInfo(path);
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    public string FileDescription { get; set; } = string.Empty;
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IPackage.cs

@@ -0,0 +1,20 @@
+// 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.CmdPal.Ext.Apps.Programs;
+
+public interface IPackage
+{
+    string Name { get; }
+
+    string FullName { get; }
+
+    string FamilyName { get; }
+
+    bool IsFramework { get; }
+
+    bool IsDevelopmentMode { get; }
+
+    string InstalledLocation { get; }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IPackageCatalog.cs

@@ -0,0 +1,17 @@
+// 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 Windows.ApplicationModel;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+internal interface IPackageCatalog
+{
+    event TypedEventHandler<PackageCatalog, PackageInstallingEventArgs> PackageInstalling;
+
+    event TypedEventHandler<PackageCatalog, PackageUninstallingEventArgs> PackageUninstalling;
+
+    event TypedEventHandler<PackageCatalog, PackageUpdatingEventArgs> PackageUpdating;
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IPackageManager.cs

@@ -0,0 +1,12 @@
+// 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.Ext.Apps.Programs;
+
+public interface IPackageManager
+{
+    IEnumerable<IPackage> FindPackagesForCurrentUser();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/IProgram.cs

@@ -0,0 +1,18 @@
+// 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.CmdPal.Ext.Apps.Programs;
+
+public interface IProgram
+{
+    string UniqueIdentifier { get; set; }
+
+    string Name { get; }
+
+    string Description { get; set; }
+
+    string Location { get; }
+
+    bool Enabled { get; set; }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/LogoType.cs

@@ -0,0 +1,12 @@
+// 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.CmdPal.Ext.Apps.Programs;
+
+public enum LogoType
+{
+    Error,
+    Colored,
+    HighContrast,
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/PackageCatalogWrapper.cs

@@ -0,0 +1,61 @@
+// 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 Windows.ApplicationModel;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+internal sealed class PackageCatalogWrapper : IPackageCatalog
+{
+    private PackageCatalog _packageCatalog;
+
+    public PackageCatalogWrapper()
+    {
+        // Opens the catalog of packages that is available for the current user.
+        _packageCatalog = PackageCatalog.OpenForCurrentUser();
+    }
+
+    // Summary: Indicates that an app package is installing.
+    public event TypedEventHandler<PackageCatalog, PackageInstallingEventArgs> PackageInstalling
+    {
+        add
+        {
+            _packageCatalog.PackageInstalling += value;
+        }
+
+        remove
+        {
+            _packageCatalog.PackageInstalling -= value;
+        }
+    }
+
+    // Summary: Indicates that an app package is uninstalling.
+    public event TypedEventHandler<PackageCatalog, PackageUninstallingEventArgs> PackageUninstalling
+    {
+        add
+        {
+            _packageCatalog.PackageUninstalling += value;
+        }
+
+        remove
+        {
+            _packageCatalog.PackageUninstalling -= value;
+        }
+    }
+
+    // Summary: Indicates that an app package is updating.
+    public event TypedEventHandler<PackageCatalog, PackageUpdatingEventArgs> PackageUpdating
+    {
+        add
+        {
+            _packageCatalog.PackageUpdating += value;
+        }
+
+        remove
+        {
+            _packageCatalog.PackageUpdating -= value;
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/PackageManagerWrapper.cs

@@ -0,0 +1,34 @@
+// 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;
+using System.Linq;
+using System.Security.Principal;
+using Windows.Management.Deployment;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+public class PackageManagerWrapper : IPackageManager
+{
+    private readonly PackageManager _packageManager;
+
+    public PackageManagerWrapper()
+    {
+        _packageManager = new PackageManager();
+    }
+
+    public IEnumerable<IPackage> FindPackagesForCurrentUser()
+    {
+        var user = WindowsIdentity.GetCurrent().User;
+
+        if (user != null)
+        {
+            var pkgs = _packageManager.FindPackagesForUser(user.Value);
+
+            return pkgs.Select(PackageWrapper.GetWrapperFromPackage).Where(package => package != null);
+        }
+
+        return Enumerable.Empty<IPackage>();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/PackageWrapper.cs

@@ -0,0 +1,75 @@
+// 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 Windows.Foundation.Metadata;
+using Package = Windows.ApplicationModel.Package;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+public class PackageWrapper : IPackage
+{
+    public string Name { get; } = string.Empty;
+
+    public string FullName { get; } = string.Empty;
+
+    public string FamilyName { get; } = string.Empty;
+
+    public bool IsFramework { get; }
+
+    public bool IsDevelopmentMode { get; }
+
+    public string InstalledLocation { get; } = string.Empty;
+
+    public PackageWrapper()
+    {
+    }
+
+    public PackageWrapper(string name, string fullName, string familyName, bool isFramework, bool isDevelopmentMode, string installedLocation)
+    {
+        Name = name;
+        FullName = fullName;
+        FamilyName = familyName;
+        IsFramework = isFramework;
+        IsDevelopmentMode = isDevelopmentMode;
+        InstalledLocation = installedLocation;
+    }
+
+    private static readonly Lazy<bool> IsPackageDotInstallationPathAvailable = new(() =>
+        ApiInformation.IsPropertyPresent(typeof(Package).FullName, nameof(Package.InstalledLocation.Path)));
+
+    public static PackageWrapper GetWrapperFromPackage(Package package)
+    {
+        ArgumentNullException.ThrowIfNull(package);
+
+        string path;
+        try
+        {
+            path = IsPackageDotInstallationPathAvailable.Value ? GetInstalledPath(package) : package.InstalledLocation.Path;
+        }
+        catch (Exception e) when (e is ArgumentException || e is FileNotFoundException || e is DirectoryNotFoundException)
+        {
+            return new PackageWrapper(
+                package.Id.Name,
+                package.Id.FullName,
+                package.Id.FamilyName,
+                package.IsFramework,
+                package.IsDevelopmentMode,
+                string.Empty);
+        }
+
+        return new PackageWrapper(
+                package.Id.Name,
+                package.Id.FullName,
+                package.Id.FamilyName,
+                package.IsFramework,
+                package.IsDevelopmentMode,
+                path);
+    }
+
+    // This is a separate method so the reference to .InstalledPath won't be loaded in API versions which do not support this API (e.g. older then Build 19041)
+    private static string GetInstalledPath(Package package)
+        => package.InstalledLocation.Path;
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/ProgramSource.cs

@@ -0,0 +1,24 @@
+// 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.CmdPal.Ext.Apps.Programs;
+
+/// <summary>
+/// Contains user added folder location contents as well as all user disabled applications
+/// </summary>
+/// <remarks>
+/// <para>Win32 class applications set UniqueIdentifier using their full file path</para>
+/// <para>UWP class applications set UniqueIdentifier using their Application User Model ID</para>
+/// <para>Custom user added program sources set UniqueIdentifier using their location</para>
+/// </remarks>
+public class ProgramSource
+{
+    public string Location { get; set; } = string.Empty;
+
+    public string Name { get; set; } = string.Empty;
+
+    public bool Enabled { get; set; } = true;
+
+    public string UniqueIdentifier { get; set; } = string.Empty;
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/ReparsePoint.cs

@@ -0,0 +1,397 @@
+// 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.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+using Microsoft.Win32.SafeHandles;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+/// <summary>
+/// Provides access to NTFS reparse points in .Net.
+/// </summary>
+public static class ReparsePoint
+{
+#pragma warning disable SA1310 // Field names should not contain underscore
+
+    private const int ERROR_NOT_A_REPARSE_POINT = 4390;
+
+    private const int ERROR_INSUFFICIENT_BUFFER = 122;
+
+    private const int ERROR_MORE_DATA = 234;
+
+    private const int FSCTL_GET_REPARSE_POINT = 0x000900A8;
+
+    private const uint IO_REPARSE_TAG_APPEXECLINK = 0x8000001B;
+
+    private const int MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16 * 1024;
+
+    private const int E_INVALID_PROTOCOL_FORMAT = unchecked((int)0x83760002);
+#pragma warning restore SA1310 // Field names should not contain underscore
+
+    [Flags]
+    private enum FileAccessType : uint
+    {
+        DELETE = 0x00010000,
+        READ_CONTROL = 0x00020000,
+        WRITE_DAC = 0x00040000,
+        WRITE_OWNER = 0x00080000,
+        SYNCHRONIZE = 0x00100000,
+
+        STANDARD_RIGHTS_REQUIRED = 0x000F0000,
+
+        STANDARD_RIGHTS_READ = READ_CONTROL,
+        STANDARD_RIGHTS_WRITE = READ_CONTROL,
+        STANDARD_RIGHTS_EXECUTE = READ_CONTROL,
+
+        STANDARD_RIGHTS_ALL = 0x001F0000,
+
+        SPECIFIC_RIGHTS_ALL = 0x0000FFFF,
+
+        ACCESS_SYSTEM_SECURITY = 0x01000000,
+
+        MAXIMUM_ALLOWED = 0x02000000,
+
+        GENERIC_READ = 0x80000000,
+        GENERIC_WRITE = 0x40000000,
+        GENERIC_EXECUTE = 0x20000000,
+        GENERIC_ALL = 0x10000000,
+
+        FILE_READ_DATA = 0x0001,
+        FILE_WRITE_DATA = 0x0002,
+        FILE_APPEND_DATA = 0x0004,
+        FILE_READ_EA = 0x0008,
+        FILE_WRITE_EA = 0x0010,
+        FILE_EXECUTE = 0x0020,
+        FILE_READ_ATTRIBUTES = 0x0080,
+        FILE_WRITE_ATTRIBUTES = 0x0100,
+
+        FILE_ALL_ACCESS =
+            STANDARD_RIGHTS_REQUIRED |
+            SYNCHRONIZE
+            | 0x1FF,
+
+        FILE_GENERIC_READ =
+            STANDARD_RIGHTS_READ |
+            FILE_READ_DATA |
+            FILE_READ_ATTRIBUTES |
+            FILE_READ_EA |
+            SYNCHRONIZE,
+
+        FILE_GENERIC_WRITE =
+            STANDARD_RIGHTS_WRITE |
+            FILE_WRITE_DATA |
+            FILE_WRITE_ATTRIBUTES |
+            FILE_WRITE_EA |
+            FILE_APPEND_DATA |
+            SYNCHRONIZE,
+
+        FILE_GENERIC_EXECUTE =
+            STANDARD_RIGHTS_EXECUTE |
+            FILE_READ_ATTRIBUTES |
+            FILE_EXECUTE |
+            SYNCHRONIZE,
+    }
+
+    [Flags]
+    private enum FileShareType : uint
+    {
+        None = 0x00000000,
+        Read = 0x00000001,
+        Write = 0x00000002,
+        Delete = 0x00000004,
+    }
+
+    private enum CreationDisposition : uint
+    {
+        New = 1,
+        CreateAlways = 2,
+        OpenExisting = 3,
+        OpenAlways = 4,
+        TruncateExisting = 5,
+    }
+
+    [Flags]
+    private enum FileAttributes : uint
+    {
+        Readonly = 0x00000001,
+        Hidden = 0x00000002,
+        System = 0x00000004,
+        Directory = 0x00000010,
+        Archive = 0x00000020,
+        Device = 0x00000040,
+        Normal = 0x00000080,
+        Temporary = 0x00000100,
+        SparseFile = 0x00000200,
+        ReparsePoint = 0x00000400,
+        Compressed = 0x00000800,
+        Offline = 0x00001000,
+        NotContentIndexed = 0x00002000,
+        Encrypted = 0x00004000,
+        Write_Through = 0x80000000,
+        Overlapped = 0x40000000,
+        NoBuffering = 0x20000000,
+        RandomAccess = 0x10000000,
+        SequentialScan = 0x08000000,
+        DeleteOnClose = 0x04000000,
+        BackupSemantics = 0x02000000,
+        PosixSemantics = 0x01000000,
+        OpenReparsePoint = 0x00200000,
+        OpenNoRecall = 0x00100000,
+        FirstPipeInstance = 0x00080000,
+    }
+
+    private enum AppExecutionAliasReparseTagBufferLayoutVersion : uint
+    {
+        Invalid = 0,
+
+        /// <summary>
+        /// Initial version used package full name, aumid, exe path
+        /// </summary>
+        Initial = 1,
+
+        /// <summary>
+        /// This version replaces package full name with family name, to allow
+        /// optional packages to reference their main package across versions.
+        /// </summary>
+        PackageFamilyName = 2,
+
+        /// <summary>
+        /// This version appends a flag to the family Name version to differentiate
+        /// between UWP and Centennial
+        /// </summary>
+        MultiAppTypeSupport = 3,
+
+        /// <summary>
+        /// Used to check version validity, where valid is (Invalid, UpperBound)
+        /// </summary>
+        UpperBound,
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct AppExecutionAliasReparseTagHeader
+    {
+        /// <summary>
+        /// Reparse point tag.
+        /// </summary>
+        public uint ReparseTag;
+
+        /// <summary>
+        /// Size, in bytes, of the data after the Reserved member.
+        /// </summary>
+        public ushort ReparseDataLength;
+
+        /// <summary>
+        /// Reserved; do not use.
+        /// </summary>
+        public ushort Reserved;
+
+        public AppExecutionAliasReparseTagBufferLayoutVersion Version;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern bool DeviceIoControl(
+        IntPtr hDevice,
+        uint dwIoControlCode,
+        IntPtr inBuffer,
+        int nInBufferSize,
+        IntPtr outBuffer,
+        int nOutBufferSize,
+        out int pBytesReturned,
+        IntPtr lpOverlapped);
+
+    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    private static extern IntPtr CreateFile(
+        string lpFileName,
+        FileAccessType dwDesiredAccess,
+        FileShareType dwShareMode,
+        IntPtr lpSecurityAttributes,
+        CreationDisposition dwCreationDisposition,
+        FileAttributes dwFlagsAndAttributes,
+        IntPtr hTemplateFile);
+
+    /// <summary>
+    /// Gets the target of the specified reparse point.
+    /// </summary>
+    /// <param name="reparsePoint">The path of the reparse point.</param>
+    /// <returns>
+    /// The target of the reparse point.
+    /// </returns>
+    /// <exception cref="IOException">
+    /// Thrown when the reparse point specified is not a reparse point or is invalid.
+    /// </exception>
+    public static string? GetTarget(string reparsePoint)
+    {
+        using (SafeFileHandle reparsePointHandle = new SafeFileHandle(
+            CreateFile(
+                reparsePoint,
+                FileAccessType.FILE_READ_ATTRIBUTES | FileAccessType.FILE_READ_EA,
+                FileShareType.Delete | FileShareType.Read | FileShareType.Write,
+                IntPtr.Zero,
+                CreationDisposition.OpenExisting,
+                FileAttributes.OpenReparsePoint,
+                IntPtr.Zero),
+            true))
+        {
+            if (Marshal.GetLastWin32Error() != 0)
+            {
+                ThrowLastWin32Error("Unable to open reparse point.");
+            }
+
+            var outBufferSize = 512;
+            var outBuffer = Marshal.AllocHGlobal(outBufferSize);
+
+            try
+            {
+                // For-loop allows an attempt with 512-bytes buffer, before retrying with a 'MAXIMUM_REPARSE_DATA_BUFFER_SIZE' bytes buffer.
+                for (var i = 0; i < 2; ++i)
+                {
+                    int bytesReturned;
+                    var result = DeviceIoControl(
+                        reparsePointHandle.DangerousGetHandle(),
+                        FSCTL_GET_REPARSE_POINT,
+                        IntPtr.Zero,
+                        0,
+                        outBuffer,
+                        outBufferSize,
+                        out bytesReturned,
+                        IntPtr.Zero);
+
+                    if (!result)
+                    {
+                        var error = Marshal.GetLastWin32Error();
+                        if (error == ERROR_NOT_A_REPARSE_POINT)
+                        {
+                            return null;
+                        }
+
+                        if ((error == ERROR_INSUFFICIENT_BUFFER) || (error == ERROR_MORE_DATA))
+                        {
+                            Marshal.FreeHGlobal(outBuffer);
+                            outBuffer = IntPtr.Zero;
+
+                            outBufferSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
+                            outBuffer = Marshal.AllocHGlobal(outBufferSize);
+                            continue;
+                        }
+
+                        ThrowLastWin32Error("Unable to get information about reparse point.");
+                    }
+
+                    AppExecutionAliasReparseTagHeader aliasReparseHeader = Marshal.PtrToStructure<AppExecutionAliasReparseTagHeader>(outBuffer);
+
+                    if (aliasReparseHeader.ReparseTag == IO_REPARSE_TAG_APPEXECLINK)
+                    {
+                        var metadata = AppExecutionAliasMetadata.FromPersistedRepresentationIntPtr(
+                            outBuffer,
+                            aliasReparseHeader.Version);
+
+                        return metadata.ExePath;
+                    }
+
+                    return null;
+                }
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(outBuffer);
+            }
+        }
+
+        return null;
+    }
+
+    private sealed class AppExecutionAliasMetadata
+    {
+        public string PackageFullName { get; init; } = string.Empty;
+
+        public string PackageFamilyName { get; init; } = string.Empty;
+
+        public string Aumid { get; init; } = string.Empty;
+
+        public string ExePath { get; init; } = string.Empty;
+
+        public static AppExecutionAliasMetadata FromPersistedRepresentationIntPtr(IntPtr reparseDataBufferPtr, AppExecutionAliasReparseTagBufferLayoutVersion version)
+        {
+            var dataOffset = Marshal.SizeOf(typeof(AppExecutionAliasReparseTagHeader));
+            var dataBufferPtr = reparseDataBufferPtr + dataOffset;
+
+            string? packageFullName = null;
+            string? packageFamilyName = null;
+            string? aumid = null;
+            string? exePath = null;
+
+            VerifyVersion(version);
+
+            switch (version)
+            {
+                case AppExecutionAliasReparseTagBufferLayoutVersion.Initial:
+                    packageFullName = Marshal.PtrToStringUni(dataBufferPtr);
+                    if (packageFullName is not null)
+                    {
+                        dataBufferPtr += Encoding.Unicode.GetByteCount(packageFullName) + Encoding.Unicode.GetByteCount("\0");
+                        aumid = Marshal.PtrToStringUni(dataBufferPtr);
+
+                        if (aumid is not null)
+                        {
+                            dataBufferPtr += Encoding.Unicode.GetByteCount(aumid) + Encoding.Unicode.GetByteCount("\0");
+                            exePath = Marshal.PtrToStringUni(dataBufferPtr);
+                        }
+                    }
+
+                    break;
+
+                case AppExecutionAliasReparseTagBufferLayoutVersion.PackageFamilyName:
+                case AppExecutionAliasReparseTagBufferLayoutVersion.MultiAppTypeSupport:
+                    packageFamilyName = Marshal.PtrToStringUni(dataBufferPtr);
+
+                    if (packageFamilyName is not null)
+                    {
+                        dataBufferPtr += Encoding.Unicode.GetByteCount(packageFamilyName) + Encoding.Unicode.GetByteCount("\0");
+                        aumid = Marshal.PtrToStringUni(dataBufferPtr);
+
+                        if (aumid is not null)
+                        {
+                            dataBufferPtr += Encoding.Unicode.GetByteCount(aumid) + Encoding.Unicode.GetByteCount("\0");
+
+                            exePath = Marshal.PtrToStringUni(dataBufferPtr);
+                        }
+                    }
+
+                    break;
+            }
+
+            return new AppExecutionAliasMetadata
+            {
+                PackageFullName = packageFullName ?? string.Empty,
+                PackageFamilyName = packageFamilyName ?? string.Empty,
+                Aumid = aumid ?? string.Empty,
+                ExePath = exePath ?? string.Empty,
+            };
+        }
+
+        private static void VerifyVersion(AppExecutionAliasReparseTagBufferLayoutVersion version)
+        {
+            var uintVersion = (uint)version;
+
+            if (uintVersion > (uint)AppExecutionAliasReparseTagBufferLayoutVersion.Invalid &&
+                uintVersion < (uint)AppExecutionAliasReparseTagBufferLayoutVersion.UpperBound)
+            {
+                return;
+            }
+
+            throw new IOException("Invalid app execution alias reparse version.", E_INVALID_PROTOCOL_FORMAT);
+        }
+    }
+
+    private static void ThrowLastWin32Error(string message)
+    {
+        throw new IOException(message, Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()));
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/UWP.cs

@@ -0,0 +1,203 @@
+// 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.IO.Abstractions;
+using System.Linq;
+using System.Xml.Linq;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.System.Com;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Serializable]
+public partial class UWP
+{
+    private static readonly IPath Path = new FileSystem().Path;
+
+    private static readonly Dictionary<string, PackageVersion> _versionFromNamespace = new()
+    {
+        { "http://schemas.microsoft.com/appx/manifest/foundation/windows10", PackageVersion.Windows10 },
+        { "http://schemas.microsoft.com/appx/2013/manifest", PackageVersion.Windows81 },
+        { "http://schemas.microsoft.com/appx/2010/manifest", PackageVersion.Windows8 },
+    };
+
+    public string Name { get; }
+
+    public string FullName { get; }
+
+    public string FamilyName { get; }
+
+    public string Location { get; set; } = string.Empty;
+
+    // Localized path based on windows display language
+    public string LocationLocalized { get; set; } = string.Empty;
+
+    public IList<UWPApplication> Apps { get; private set; } = new List<UWPApplication>();
+
+    public PackageVersion Version { get; set; }
+
+    public static IPackageManager PackageManagerWrapper { get; set; } = new PackageManagerWrapper();
+
+    public UWP(IPackage package)
+    {
+        ArgumentNullException.ThrowIfNull(package);
+
+        Name = package.Name;
+        FullName = package.FullName;
+        FamilyName = package.FamilyName;
+    }
+
+    public void InitializeAppInfo(string installedLocation)
+    {
+        Location = installedLocation;
+        LocationLocalized = ShellLocalization.Instance.GetLocalizedPath(installedLocation);
+        var path = Path.Combine(installedLocation, "AppxManifest.xml");
+
+        var namespaces = XmlNamespaces(path);
+        InitPackageVersion(namespaces);
+
+        const uint noAttribute = 0x80;
+
+        var access = (uint)STGM.READ;
+        var hResult = PInvoke.SHCreateStreamOnFileEx(path, access, noAttribute, false, null, out IStream stream);
+
+        // S_OK
+        if (hResult == 0)
+        {
+            Apps = AppxPackageHelper.GetAppsFromManifest(stream).Select(appInManifest => new UWPApplication(appInManifest, this)).Where(a =>
+            {
+                var valid =
+                !string.IsNullOrEmpty(a.UserModelId) &&
+                !string.IsNullOrEmpty(a.DisplayName) &&
+                a.AppListEntry != "none";
+
+                return valid;
+            }).ToList();
+        }
+        else
+        {
+            Apps = Array.Empty<UWPApplication>();
+        }
+    }
+
+    // http://www.hanselman.com/blog/GetNamespacesFromAnXMLDocumentWithXPathDocumentAndLINQToXML.aspx
+    private static string[] XmlNamespaces(string path)
+    {
+        var z = XDocument.Load(path);
+        if (z.Root != null)
+        {
+            var namespaces = z.Root.Attributes().
+                Where(a => a.IsNamespaceDeclaration).
+                GroupBy(
+                    a => a.Name.Namespace == XNamespace.None ? string.Empty : a.Name.LocalName,
+                    a => XNamespace.Get(a.Value)).Select(
+                    g => g.First().ToString()).ToArray();
+            return namespaces;
+        }
+        else
+        {
+            return Array.Empty<string>();
+        }
+    }
+
+    private void InitPackageVersion(string[] namespaces)
+    {
+        foreach (var n in _versionFromNamespace.Keys.Where(namespaces.Contains))
+        {
+            Version = _versionFromNamespace[n];
+            return;
+        }
+
+        Version = PackageVersion.Unknown;
+    }
+
+    public static UWPApplication[] All()
+    {
+        var windows10 = new Version(10, 0);
+        var support = Environment.OSVersion.Version.Major >= windows10.Major;
+        if (support)
+        {
+            var applications = CurrentUserPackages().AsParallel().SelectMany(p =>
+            {
+                UWP u;
+                try
+                {
+                    u = new UWP(p);
+                    u.InitializeAppInfo(p.InstalledLocation);
+                }
+                catch (Exception )
+                {
+                    return Array.Empty<UWPApplication>();
+                }
+
+                return u.Apps;
+            });
+
+            var updatedListWithoutDisabledApps = applications
+            .Where(t1 => AllAppsSettings.Instance.DisabledProgramSources.All(x => x.UniqueIdentifier != t1.UniqueIdentifier))
+            .Select(x => x);
+
+            return updatedListWithoutDisabledApps.ToArray();
+        }
+        else
+        {
+            return Array.Empty<UWPApplication>();
+        }
+    }
+
+    private static IEnumerable<IPackage> CurrentUserPackages()
+    {
+        return PackageManagerWrapper.FindPackagesForCurrentUser().Where(p =>
+        {
+            try
+            {
+                var f = p.IsFramework;
+                var path = p.InstalledLocation;
+                return !f && !string.IsNullOrEmpty(path);
+            }
+            catch (Exception )
+            {
+                return false;
+            }
+        });
+    }
+
+    public override string ToString()
+    {
+        return FamilyName;
+    }
+
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1309:Use ordinal string comparison", Justification = "Using CurrentCultureIgnoreCase since this is used with FamilyName")]
+    public override bool Equals(object? obj)
+    {
+        if (obj is UWP uwp)
+        {
+            // Using CurrentCultureIgnoreCase since this is used with FamilyName
+            return FamilyName.Equals(uwp.FamilyName, StringComparison.CurrentCultureIgnoreCase);
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public override int GetHashCode()
+    {
+        // Using CurrentCultureIgnoreCase since this is used with FamilyName
+        return FamilyName.GetHashCode(StringComparison.CurrentCultureIgnoreCase);
+    }
+
+    public enum PackageVersion
+    {
+        Windows10,
+        Windows81,
+        Windows8,
+        Unknown,
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/UWPApplication.cs

@@ -0,0 +1,608 @@
+// 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.IO.Abstractions;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Xml;
+using Microsoft.CmdPal.Ext.Apps.Commands;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+using PackageVersion = Microsoft.CmdPal.Ext.Apps.Programs.UWP.PackageVersion;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Serializable]
+public class UWPApplication : IProgram
+{
+    private static readonly IFileSystem FileSystem = new FileSystem();
+    private static readonly IPath Path = FileSystem.Path;
+    private static readonly IFile File = FileSystem.File;
+
+    public string AppListEntry { get; set; } = string.Empty;
+
+    public string UniqueIdentifier { get; set; }
+
+    public string DisplayName { get; set; }
+
+    public string Description { get; set; }
+
+    public string UserModelId { get; set; }
+
+    public string BackgroundColor { get; set; }
+
+    public string EntryPoint { get; set; }
+
+    public string Name => DisplayName;
+
+    public string Location => Package.Location;
+
+    // Localized path based on windows display language
+    public string LocationLocalized => Package.LocationLocalized;
+
+    public bool Enabled { get; set; }
+
+    public bool CanRunElevated { get; set; }
+
+    public string LogoPath { get; set; } = string.Empty;
+
+    public LogoType LogoType { get; set; }
+
+    public UWP Package { get; set; }
+
+    private string logoUri;
+
+    private const string ContrastWhite = "contrast-white";
+
+    private const string ContrastBlack = "contrast-black";
+
+    // Function to set the subtitle based on the Type of application
+    public static string Type()
+    {
+        return Resources.packaged_application;
+    }
+
+    public List<CommandContextItem> GetCommands()
+    {
+        List<CommandContextItem> commands = new List<CommandContextItem>();
+
+        if (CanRunElevated)
+        {
+            commands.Add(
+                new CommandContextItem(
+                    new RunAsAdminCommand(UniqueIdentifier, string.Empty, true)));
+
+            // We don't add context menu to 'run as different user', because UWP applications normally installed per user and not for all users.
+        }
+
+        commands.Add(
+            new CommandContextItem(
+                new OpenPathCommand(Location)
+                {
+                    Name = Resources.open_containing_folder,
+                    Icon = new("\ue838"),
+                }));
+
+        commands.Add(
+        new CommandContextItem(
+            new OpenInConsoleCommand(Package.Location)));
+
+        return commands;
+    }
+
+    public UWPApplication(IAppxManifestApplication manifestApp, UWP package)
+    {
+        ArgumentNullException.ThrowIfNull(manifestApp);
+
+        var hr = manifestApp.GetAppUserModelId(out var tmpUserModelId);
+        UserModelId = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpUserModelId);
+
+        hr = manifestApp.GetAppUserModelId(out var tmpUniqueIdentifier);
+        UniqueIdentifier = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpUniqueIdentifier);
+
+        hr = manifestApp.GetStringValue("DisplayName", out var tmpDisplayName);
+        DisplayName = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpDisplayName);
+
+        hr = manifestApp.GetStringValue("Description", out var tmpDescription);
+        Description = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpDescription);
+
+        hr = manifestApp.GetStringValue("BackgroundColor", out var tmpBackgroundColor);
+        BackgroundColor = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpBackgroundColor);
+
+        hr = manifestApp.GetStringValue("EntryPoint", out var tmpEntryPoint);
+        EntryPoint = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, tmpEntryPoint);
+
+        Package = package ?? throw new ArgumentNullException(nameof(package));
+
+        DisplayName = ResourceFromPri(package.FullName, DisplayName);
+        Description = ResourceFromPri(package.FullName, Description);
+        logoUri = LogoUriFromManifest(manifestApp);
+
+        Enabled = true;
+        CanRunElevated = IfApplicationCanRunElevated();
+    }
+
+    private bool IfApplicationCanRunElevated()
+    {
+        if (EntryPoint == "Windows.FullTrustApplication")
+        {
+            return true;
+        }
+        else
+        {
+            var manifest = Package.Location + "\\AppxManifest.xml";
+            if (File.Exists(manifest))
+            {
+                try
+                {
+                    // Check the manifest to verify if the Trust Level for the application is "mediumIL"
+                    var file = File.ReadAllText(manifest);
+                    var xmlDoc = new XmlDocument();
+                    xmlDoc.LoadXml(file);
+                    var xmlRoot = xmlDoc.DocumentElement;
+                    var namespaceManager = new XmlNamespaceManager(xmlDoc.NameTable);
+                    namespaceManager.AddNamespace("uap10", "http://schemas.microsoft.com/appx/manifest/uap/windows10/10");
+                    var trustLevelNode = xmlRoot?.SelectSingleNode("//*[local-name()='Application' and @uap10:TrustLevel]", namespaceManager); // According to https://learn.microsoft.com/windows/apps/desktop/modernize/grant-identity-to-nonpackaged-apps#create-a-package-manifest-for-the-sparse-package and https://learn.microsoft.com/uwp/schemas/appxpackage/uapmanifestschema/element-application#attributes
+
+                    if (trustLevelNode?.Attributes?["uap10:TrustLevel"]?.Value == "mediumIL")
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception)
+                {
+                }
+            }
+        }
+
+        return false;
+    }
+
+    internal string ResourceFromPri(string packageFullName, string resourceReference)
+    {
+        const string prefix = "ms-resource:";
+
+        // Using OrdinalIgnoreCase since this is used internally
+        if (!string.IsNullOrWhiteSpace(resourceReference) && resourceReference.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+        {
+            // magic comes from @talynone
+            // https://github.com/talynone/Wox.Plugin.WindowsUniversalAppLauncher/blob/master/StoreAppLauncher/Helpers/NativeApiHelper.cs#L139-L153
+            var key = resourceReference.Substring(prefix.Length);
+            string parsed;
+            var parsedFallback = string.Empty;
+
+            // Using Ordinal/OrdinalIgnoreCase since these are used internally
+            if (key.StartsWith("//", StringComparison.Ordinal))
+            {
+                parsed = prefix + key;
+            }
+            else if (key.StartsWith('/'))
+            {
+                parsed = prefix + "//" + key;
+            }
+            else if (key.Contains("resources", StringComparison.OrdinalIgnoreCase))
+            {
+                parsed = prefix + key;
+            }
+            else
+            {
+                parsed = prefix + "///resources/" + key;
+
+                // e.g. for Windows Terminal version >= 1.12 DisplayName and Description resources are not in the 'resources' subtree
+                parsedFallback = prefix + "///" + key;
+            }
+
+            var outBuffer = new StringBuilder(128);
+            var source = $"@{{{packageFullName}? {parsed}}}";
+            var capacity = (uint)outBuffer.Capacity;
+            var hResult = SHLoadIndirectString(source, outBuffer, capacity, IntPtr.Zero);
+            if (hResult != HRESULT.S_OK)
+            {
+                if (!string.IsNullOrEmpty(parsedFallback))
+                {
+                    var sourceFallback = $"@{{{packageFullName}? {parsedFallback}}}";
+                    hResult = SHLoadIndirectString(sourceFallback, outBuffer, capacity, IntPtr.Zero);
+                    if (hResult == HRESULT.S_OK)
+                    {
+                        var loaded = outBuffer.ToString();
+                        if (!string.IsNullOrEmpty(loaded))
+                        {
+                            return loaded;
+                        }
+                        else
+                        {
+                            return string.Empty;
+                        }
+                    }
+                }
+
+                // https://github.com/Wox-launcher/Wox/issues/964
+                // known hresult 2147942522:
+                // 'Microsoft Corporation' violates pattern constraint of '\bms-resource:.{1,256}'.
+                // for
+                // Microsoft.MicrosoftOfficeHub_17.7608.23501.0_x64__8wekyb3d8bbwe: ms-resource://Microsoft.MicrosoftOfficeHub/officehubintl/AppManifest_GetOffice_Description
+                // Microsoft.BingFoodAndDrink_3.0.4.336_x64__8wekyb3d8bbwe: ms-resource:AppDescription
+                return string.Empty;
+            }
+            else
+            {
+                var loaded = outBuffer.ToString();
+                if (!string.IsNullOrEmpty(loaded))
+                {
+                    return loaded;
+                }
+                else
+                {
+                    return string.Empty;
+                }
+            }
+        }
+        else
+        {
+            return resourceReference;
+        }
+    }
+
+    private static readonly Dictionary<PackageVersion, string> _logoKeyFromVersion = new Dictionary<PackageVersion, string>
+        {
+            { PackageVersion.Windows10, "Square44x44Logo" },
+            { PackageVersion.Windows81, "Square30x30Logo" },
+            { PackageVersion.Windows8, "SmallLogo" },
+        };
+
+    internal string LogoUriFromManifest(IAppxManifestApplication app)
+    {
+        if (_logoKeyFromVersion.TryGetValue(Package.Version, out var key))
+        {
+            var hr = app.GetStringValue(key, out var logoUriFromApp);
+            _ = AppxPackageHelper.CheckHRAndReturnOrThrow(hr, logoUriFromApp);
+            return logoUriFromApp;
+        }
+        else
+        {
+            return string.Empty;
+        }
+    }
+
+    public void UpdateLogoPath(Theme theme)
+    {
+        LogoPathFromUri(logoUri, theme);
+    }
+
+    // scale factors on win10: https://learn.microsoft.com/windows/uwp/controls-and-patterns/tiles-and-notifications-app-assets#asset-size-tables,
+    private static readonly Dictionary<PackageVersion, List<int>> _scaleFactors = new Dictionary<PackageVersion, List<int>>
+        {
+            { PackageVersion.Windows10, new List<int> { 100, 125, 150, 200, 400 } },
+            { PackageVersion.Windows81, new List<int> { 100, 120, 140, 160, 180 } },
+            { PackageVersion.Windows8, new List<int> { 100 } },
+        };
+
+    private bool SetScaleIcons(string path, string colorscheme, bool highContrast = false)
+    {
+        var extension = Path.GetExtension(path);
+        if (extension != null)
+        {
+            var end = path.Length - extension.Length;
+            var prefix = path.Substring(0, end);
+            var paths = new List<string> { };
+
+            if (!highContrast)
+            {
+                paths.Add(path);
+            }
+
+            if (_scaleFactors.TryGetValue(Package.Version, out var factors))
+            {
+                foreach (var factor in factors)
+                {
+                    if (highContrast)
+                    {
+                        paths.Add($"{prefix}.scale-{factor}_{colorscheme}{extension}");
+                        paths.Add($"{prefix}.{colorscheme}_scale-{factor}{extension}");
+                    }
+                    else
+                    {
+                        paths.Add($"{prefix}.scale-{factor}{extension}");
+                    }
+                }
+            }
+
+            var selectedIconPath = paths.FirstOrDefault(File.Exists);
+            if (!string.IsNullOrEmpty(selectedIconPath))
+            {
+                LogoPath = selectedIconPath;
+                if (highContrast)
+                {
+                    LogoType = LogoType.HighContrast;
+                }
+                else
+                {
+                    LogoType = LogoType.Colored;
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private bool SetTargetSizeIcon(string path, string colorscheme, bool highContrast = false)
+    {
+        var extension = Path.GetExtension(path);
+        if (extension != null)
+        {
+            var end = path.Length - extension.Length;
+            var prefix = path.Substring(0, end);
+            var paths = new List<string> { };
+            const int appIconSize = 36;
+            var targetSizes = new List<int> { 16, 24, 30, 36, 44, 60, 72, 96, 128, 180, 256 }.AsParallel();
+            var pathFactorPairs = new Dictionary<string, int>();
+
+            foreach (var factor in targetSizes)
+            {
+                if (highContrast)
+                {
+                    var suffixThemePath = $"{prefix}.targetsize-{factor}_{colorscheme}{extension}";
+                    var prefixThemePath = $"{prefix}.{colorscheme}_targetsize-{factor}{extension}";
+                    paths.Add(suffixThemePath);
+                    paths.Add(prefixThemePath);
+                    pathFactorPairs.Add(suffixThemePath, factor);
+                    pathFactorPairs.Add(prefixThemePath, factor);
+                }
+                else
+                {
+                    var simplePath = $"{prefix}.targetsize-{factor}{extension}";
+                    var altformUnPlatedPath = $"{prefix}.targetsize-{factor}_altform-unplated{extension}";
+                    paths.Add(simplePath);
+                    paths.Add(altformUnPlatedPath);
+                    pathFactorPairs.Add(simplePath, factor);
+                    pathFactorPairs.Add(altformUnPlatedPath, factor);
+                }
+            }
+
+            var selectedIconPath = paths.OrderBy(x => Math.Abs(pathFactorPairs.GetValueOrDefault(x) - appIconSize)).FirstOrDefault(File.Exists);
+            if (!string.IsNullOrEmpty(selectedIconPath))
+            {
+                LogoPath = selectedIconPath;
+                if (highContrast)
+                {
+                    LogoType = LogoType.HighContrast;
+                }
+                else
+                {
+                    LogoType = LogoType.Colored;
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private bool SetColoredIcon(string path, string colorscheme)
+    {
+        var isSetColoredScaleIcon = SetScaleIcons(path, colorscheme);
+        if (isSetColoredScaleIcon)
+        {
+            return true;
+        }
+
+        var isSetColoredTargetIcon = SetTargetSizeIcon(path, colorscheme);
+        if (isSetColoredTargetIcon)
+        {
+            return true;
+        }
+
+        var isSetHighContrastScaleIcon = SetScaleIcons(path, colorscheme, true);
+        if (isSetHighContrastScaleIcon)
+        {
+            return true;
+        }
+
+        var isSetHighContrastTargetIcon = SetTargetSizeIcon(path, colorscheme, true);
+        if (isSetHighContrastTargetIcon)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    private bool SetHighContrastIcon(string path, string colorscheme)
+    {
+        var isSetHighContrastScaleIcon = SetScaleIcons(path, colorscheme, true);
+        if (isSetHighContrastScaleIcon)
+        {
+            return true;
+        }
+
+        var isSetHighContrastTargetIcon = SetTargetSizeIcon(path, colorscheme, true);
+        if (isSetHighContrastTargetIcon)
+        {
+            return true;
+        }
+
+        var isSetColoredScaleIcon = SetScaleIcons(path, colorscheme);
+        if (isSetColoredScaleIcon)
+        {
+            return true;
+        }
+
+        var isSetColoredTargetIcon = SetTargetSizeIcon(path, colorscheme);
+        if (isSetColoredTargetIcon)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    internal void LogoPathFromUri(string uri, Theme theme)
+    {
+        // all https://learn.microsoft.com/windows/uwp/controls-and-patterns/tiles-and-notifications-app-assets
+        // windows 10 https://msdn.microsoft.com/library/windows/apps/dn934817.aspx
+        // windows 8.1 https://msdn.microsoft.com/library/windows/apps/hh965372.aspx#target_size
+        // windows 8 https://msdn.microsoft.com/library/windows/apps/br211475.aspx
+        string path;
+        bool isLogoUriSet;
+
+        // Using Ordinal since this is used internally with uri
+        if (uri.Contains('\\', StringComparison.Ordinal))
+        {
+            path = Path.Combine(Package.Location, uri);
+        }
+        else
+        {
+            // for C:\Windows\MiracastView etc
+            path = Path.Combine(Package.Location, "Assets", uri);
+        }
+
+        switch (theme)
+        {
+            case Theme.HighContrastBlack:
+            case Theme.HighContrastOne:
+            case Theme.HighContrastTwo:
+                isLogoUriSet = SetHighContrastIcon(path, ContrastBlack);
+                break;
+            case Theme.HighContrastWhite:
+                isLogoUriSet = SetHighContrastIcon(path, ContrastWhite);
+                break;
+            case Theme.Light:
+                isLogoUriSet = SetColoredIcon(path, ContrastWhite);
+                break;
+            default:
+                isLogoUriSet = SetColoredIcon(path, ContrastBlack);
+                break;
+        }
+
+        if (!isLogoUriSet)
+        {
+            LogoPath = string.Empty;
+            LogoType = LogoType.Error;
+        }
+    }
+
+    /*
+    public ImageSource Logo()
+    {
+        if (LogoType == LogoType.Colored)
+        {
+            var logo = ImageFromPath(LogoPath);
+            var platedImage = PlatedImage(logo);
+            return platedImage;
+        }
+        else
+        {
+            return ImageFromPath(LogoPath);
+        }
+    }
+
+    private const int _dpiScale100 = 96;
+
+    private ImageSource PlatedImage(BitmapImage image)
+    {
+        if (!string.IsNullOrEmpty(BackgroundColor))
+        {
+            string currentBackgroundColor;
+            if (BackgroundColor == "transparent")
+            {
+                // Using InvariantCulture since this is internal
+                currentBackgroundColor = SystemParameters.WindowGlassBrush.ToString(CultureInfo.InvariantCulture);
+            }
+            else
+            {
+                currentBackgroundColor = BackgroundColor;
+            }
+
+            var padding = 8;
+            var width = image.Width + (2 * padding);
+            var height = image.Height + (2 * padding);
+            var x = 0;
+            var y = 0;
+
+            var group = new DrawingGroup();
+            var converted = ColorConverter.ConvertFromString(currentBackgroundColor);
+            if (converted != null)
+            {
+                var color = (Color)converted;
+                var brush = new SolidColorBrush(color);
+                var pen = new Pen(brush, 1);
+                var backgroundArea = new Rect(0, 0, width, height);
+                var rectangleGeometry = new RectangleGeometry(backgroundArea, 8, 8);
+                var rectDrawing = new GeometryDrawing(brush, pen, rectangleGeometry);
+                group.Children.Add(rectDrawing);
+
+                var imageArea = new Rect(x + padding, y + padding, image.Width, image.Height);
+                var imageDrawing = new ImageDrawing(image, imageArea);
+                group.Children.Add(imageDrawing);
+
+                // http://stackoverflow.com/questions/6676072/get-system-drawing-bitmap-of-a-wpf-area-using-visualbrush
+                var visual = new DrawingVisual();
+                var context = visual.RenderOpen();
+                context.DrawDrawing(group);
+                context.Close();
+
+                var bitmap = new RenderTargetBitmap(
+                    Convert.ToInt32(width),
+                    Convert.ToInt32(height),
+                    _dpiScale100,
+                    _dpiScale100,
+                    PixelFormats.Pbgra32);
+
+                bitmap.Render(visual);
+
+                return bitmap;
+            }
+            else
+            {
+                ProgramLogger.Exception($"Unable to convert background string {BackgroundColor} to color for {Package.Location}", new InvalidOperationException(), GetType(), Package.Location);
+
+                return new BitmapImage(new Uri(Constant.ErrorIcon));
+            }
+        }
+        else
+        {
+            // todo use windows theme as background
+            return image;
+        }
+    }
+
+    private BitmapImage ImageFromPath(string path)
+    {
+        if (File.Exists(path))
+        {
+            var memoryStream = new MemoryStream();
+            using (var fileStream = File.OpenRead(path))
+            {
+                fileStream.CopyTo(memoryStream);
+                memoryStream.Position = 0;
+
+                var image = new BitmapImage();
+                image.BeginInit();
+                image.StreamSource = memoryStream;
+                image.EndInit();
+                return image;
+            }
+        }
+        else
+        {
+            // ProgramLogger.Exception($"Unable to get logo for {UserModelId} from {path} and located in {Package.Location}", new FileNotFoundException(), GetType(), path);
+            return new BitmapImage(new Uri(ImageLoader.ErrorIconPath));
+        }
+    }
+    */
+
+    public override string ToString()
+    {
+        return $"{DisplayName}: {Description}";
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/Win32Program.cs

@@ -0,0 +1,847 @@
+// 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.ComponentModel.Design;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Reflection;
+using System.Security;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using Microsoft.CmdPal.Ext.Apps.Commands;
+using Microsoft.CmdPal.Ext.Apps.Properties;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.Win32;
+
+namespace Microsoft.CmdPal.Ext.Apps.Programs;
+
+[Serializable]
+public class Win32Program : IProgram
+{
+    public static readonly Win32Program InvalidProgram = new Win32Program { Valid = false, Enabled = false };
+
+    private static readonly IFileSystem FileSystem = new FileSystem();
+    private static readonly IPath Path = FileSystem.Path;
+    private static readonly IFile File = FileSystem.File;
+    private static readonly IDirectory Directory = FileSystem.Directory;
+
+    public string Name { get; set; } = string.Empty;
+
+    // Localized name based on windows display language
+    public string NameLocalized { get; set; } = string.Empty;
+
+    public string UniqueIdentifier { get; set; } = string.Empty;
+
+    public string IcoPath { get; set; } = string.Empty;
+
+    public string Description { get; set; } = string.Empty;
+
+    // Path of app executable or lnk target executable
+    public string FullPath { get; set; } = string.Empty;
+
+    // Localized path based on windows display language
+    public string FullPathLocalized { get; set; } = string.Empty;
+
+    public string ParentDirectory { get; set; } = string.Empty;
+
+    public string ExecutableName { get; set; } = string.Empty;
+
+    // Localized executable name based on windows display language
+    public string ExecutableNameLocalized { get; set; } = string.Empty;
+
+    // Path to the lnk file on LnkProgram
+    public string LnkFilePath { get; set; } = string.Empty;
+
+    public string LnkResolvedExecutableName { get; set; } = string.Empty;
+
+    // Localized path based on windows display language
+    public string LnkResolvedExecutableNameLocalized { get; set; } = string.Empty;
+
+    public bool Valid { get; set; }
+
+    public bool Enabled { get; set; }
+
+    public bool HasArguments => !string.IsNullOrEmpty(Arguments);
+
+    public string Arguments { get; set; } = string.Empty;
+
+    public string Location => ParentDirectory;
+
+    public ApplicationType AppType { get; set; }
+
+    // Wrappers for File Operations
+    public static IFileVersionInfoWrapper FileVersionInfoWrapper { get; set; } = new FileVersionInfoWrapper();
+
+    public static IFile FileWrapper { get; set; } = new FileSystem().File;
+
+    private const string ShortcutExtension = "lnk";
+    private const string ApplicationReferenceExtension = "appref-ms";
+    private const string InternetShortcutExtension = "url";
+    private static readonly HashSet<string> ExecutableApplicationExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "exe", "bat", "bin", "com", "cpl", "msc", "msi", "cmd", "ps1", "job", "msp", "mst", "sct", "ws", "wsh", "wsf" };
+
+    private const string ProxyWebApp = "_proxy.exe";
+    private const string AppIdArgument = "--app-id";
+
+    public enum ApplicationType
+    {
+        WebApplication = 0,
+        InternetShortcutApplication = 1,
+        Win32Application = 2,
+        ShortcutApplication = 3,
+        ApprefApplication = 4,
+        RunCommand = 5,
+        Folder = 6,
+        GenericFile = 7,
+    }
+
+    public bool IsWebApplication()
+    {
+        // To Filter PWAs when the user searches for the main application
+        // All Chromium based applications contain the --app-id argument
+        // Reference : https://codereview.chromium.org/399045
+        // Using Ordinal IgnoreCase since this is used internally
+        return !string.IsNullOrEmpty(FullPath) &&
+                !string.IsNullOrEmpty(Arguments) &&
+                FullPath.Contains(ProxyWebApp, StringComparison.OrdinalIgnoreCase) &&
+                Arguments.Contains(AppIdArgument, StringComparison.OrdinalIgnoreCase);
+    }
+
+    // Condition to Filter pinned Web Applications or PWAs when searching for the main application
+    public bool FilterWebApplication(string query)
+    {
+        // If the app is not a web application, then do not filter it
+        if (!IsWebApplication())
+        {
+            return false;
+        }
+
+        var subqueries = query?.Split() ?? Array.Empty<string>();
+        var nameContainsQuery = false;
+        var pathContainsQuery = false;
+
+        // check if any space separated query is a part of the app name or path name
+        foreach (var subquery in subqueries)
+        {
+            // Using OrdinalIgnoreCase since these are used internally
+            if (FullPath.Contains(subquery, StringComparison.OrdinalIgnoreCase))
+            {
+                pathContainsQuery = true;
+            }
+
+            if (Name.Contains(subquery, StringComparison.OrdinalIgnoreCase))
+            {
+                nameContainsQuery = true;
+            }
+        }
+
+        return pathContainsQuery && !nameContainsQuery;
+    }
+
+    // Function to set the subtitle based on the Type of application
+    public string Type()
+    {
+        switch (AppType)
+        {
+            case ApplicationType.Win32Application:
+            case ApplicationType.ShortcutApplication:
+            case ApplicationType.ApprefApplication:
+                return Resources.application;
+            case ApplicationType.InternetShortcutApplication:
+                return Resources.internet_shortcut_application;
+            case ApplicationType.WebApplication:
+                return Resources.web_application;
+            case ApplicationType.RunCommand:
+                return Resources.run_command;
+            case ApplicationType.Folder:
+                return Resources.folder;
+            case ApplicationType.GenericFile:
+                return Resources.file;
+            default:
+                return string.Empty;
+        }
+    }
+
+    public bool QueryEqualsNameForRunCommands(string query)
+    {
+        if (query != null && AppType == ApplicationType.RunCommand)
+        {
+            // Using OrdinalIgnoreCase since this is used internally
+            if (!query.Equals(Name, StringComparison.OrdinalIgnoreCase) && !query.Equals(ExecutableName, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public List<CommandContextItem> GetCommands()
+    {
+        List<CommandContextItem> commands = new List<CommandContextItem>();
+
+        if (AppType != ApplicationType.InternetShortcutApplication && AppType != ApplicationType.Folder && AppType != ApplicationType.GenericFile)
+        {
+            commands.Add(new CommandContextItem(
+                    new RunAsAdminCommand(!string.IsNullOrEmpty(LnkFilePath) ? LnkFilePath : FullPath, ParentDirectory, false)));
+
+            commands.Add(new CommandContextItem(
+                    new RunAsUserCommand(!string.IsNullOrEmpty(LnkFilePath) ? LnkFilePath : FullPath, ParentDirectory)));
+        }
+
+        commands.Add(new CommandContextItem(
+                    new OpenPathCommand(ParentDirectory)));
+
+        commands.Add(new CommandContextItem(
+                    new OpenInConsoleCommand(ParentDirectory)));
+
+        return commands;
+    }
+
+    public override string ToString()
+    {
+        return ExecutableName;
+    }
+
+    private static Win32Program CreateWin32Program(string path)
+    {
+        try
+        {
+            var parentDir = Directory.GetParent(path);
+
+            return new Win32Program
+            {
+                Name = Path.GetFileNameWithoutExtension(path),
+                ExecutableName = Path.GetFileName(path),
+                IcoPath = path,
+
+                // Using InvariantCulture since this is user facing
+                FullPath = path,
+                UniqueIdentifier = path,
+                ParentDirectory = parentDir is null ? string.Empty : parentDir.FullName,
+                Description = string.Empty,
+                Valid = true,
+                Enabled = true,
+                AppType = ApplicationType.Win32Application,
+
+                // Localized name, path and executable based on windows display language
+                NameLocalized = ShellLocalization.Instance.GetLocalizedName(path),
+                FullPathLocalized = ShellLocalization.Instance.GetLocalizedPath(path),
+                ExecutableNameLocalized = Path.GetFileName(ShellLocalization.Instance.GetLocalizedPath(path)),
+            };
+        }
+        catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+        {
+            return InvalidProgram;
+        }
+        catch (Exception)
+        {
+            return InvalidProgram;
+        }
+    }
+
+    private static readonly Regex InternetShortcutURLPrefixes = new Regex(@"^steam:\/\/(rungameid|run|open)\/|^com\.epicgames\.launcher:\/\/apps\/", RegexOptions.Compiled);
+
+    // This function filters Internet Shortcut programs
+    private static Win32Program InternetShortcutProgram(string path)
+    {
+        try
+        {
+            // We don't want to read the whole file if we don't need to
+            var lines = FileWrapper.ReadLines(path);
+            var iconPath = string.Empty;
+            var urlPath = string.Empty;
+            var validApp = false;
+
+            const string urlPrefix = "URL=";
+            const string iconFilePrefix = "IconFile=";
+
+            foreach (var line in lines)
+            {
+                // Using OrdinalIgnoreCase since this is used internally
+                if (line.StartsWith(urlPrefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    urlPath = line.Substring(urlPrefix.Length);
+
+                    if (!Uri.TryCreate(urlPath, UriKind.RelativeOrAbsolute, out var _))
+                    {
+                        return InvalidProgram;
+                    }
+
+                    // To filter out only those steam shortcuts which have 'run' or 'rungameid' as the hostname
+                    if (InternetShortcutURLPrefixes.Match(urlPath).Success)
+                    {
+                        validApp = true;
+                    }
+                }
+                else if (line.StartsWith(iconFilePrefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    iconPath = line.Substring(iconFilePrefix.Length);
+                }
+
+                // If we resolved an urlPath & and an iconPath quit reading the file
+                if (!string.IsNullOrEmpty(urlPath) && !string.IsNullOrEmpty(iconPath))
+                {
+                    break;
+                }
+            }
+
+            if (!validApp)
+            {
+                return InvalidProgram;
+            }
+
+            try
+            {
+                var parentDir = Directory.GetParent(path);
+
+                return new Win32Program
+                {
+                    Name = Path.GetFileNameWithoutExtension(path),
+                    ExecutableName = Path.GetFileName(path),
+                    IcoPath = iconPath,
+                    FullPath = urlPath,
+                    UniqueIdentifier = path,
+                    ParentDirectory = parentDir is null ? string.Empty : parentDir.FullName,
+                    Valid = true,
+                    Enabled = true,
+                    AppType = ApplicationType.InternetShortcutApplication,
+                };
+            }
+            catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+            {
+                return InvalidProgram;
+            }
+        }
+        catch (Exception)
+        {
+            return InvalidProgram;
+        }
+    }
+
+    private static Win32Program LnkProgram(string path)
+    {
+        try
+        {
+            var program = CreateWin32Program(path);
+            var shellLinkHelper = new ShellLinkHelper();
+            var target = shellLinkHelper.RetrieveTargetPath(path);
+
+            if (!string.IsNullOrEmpty(target))
+            {
+                if (!(File.Exists(target) || Directory.Exists(target)))
+                {
+                    // If the link points nowhere, consider it invalid.
+                    return InvalidProgram;
+                }
+
+                program.LnkFilePath = program.FullPath;
+                program.LnkResolvedExecutableName = Path.GetFileName(target);
+                program.LnkResolvedExecutableNameLocalized = Path.GetFileName(ShellLocalization.Instance.GetLocalizedPath(target));
+
+                // Using CurrentCulture since this is user facing
+                program.FullPath = Path.GetFullPath(target);
+                program.FullPathLocalized = ShellLocalization.Instance.GetLocalizedPath(target);
+
+                program.Arguments = shellLinkHelper.Arguments;
+
+                // A .lnk could be a (Chrome) PWA, set correct AppType
+                program.AppType = program.IsWebApplication()
+                    ? ApplicationType.WebApplication
+                    : GetAppTypeFromPath(target);
+
+                var description = shellLinkHelper.Description;
+                if (!string.IsNullOrEmpty(description))
+                {
+                    program.Description = description;
+                }
+                else
+                {
+                    var info = FileVersionInfoWrapper.GetVersionInfo(target);
+                    if (!string.IsNullOrEmpty(info?.FileDescription))
+                    {
+                        program.Description = info.FileDescription;
+                    }
+                }
+            }
+
+            return program;
+        }
+        catch (System.IO.FileLoadException)
+        {
+            return InvalidProgram;
+        }
+
+        // Only do a catch all in production. This is so make developer aware of any unhandled exception and add the exception handling in.
+        // Error caused likely due to trying to get the description of the program
+        catch (Exception)
+        {
+            return InvalidProgram;
+        }
+    }
+
+    private static Win32Program ExeProgram(string path)
+    {
+        try
+        {
+            var program = CreateWin32Program(path);
+            var info = FileVersionInfoWrapper.GetVersionInfo(path);
+            if (!string.IsNullOrEmpty(info?.FileDescription))
+            {
+                program.Description = info.FileDescription;
+            }
+
+            return program;
+        }
+        catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+        {
+            return InvalidProgram;
+        }
+        catch (FileNotFoundException)
+        {
+            return InvalidProgram;
+        }
+        catch (Exception)
+        {
+            return InvalidProgram;
+        }
+    }
+
+    // Function to get the application type, given the path to the application
+    public static ApplicationType GetAppTypeFromPath(string path)
+    {
+        ArgumentNullException.ThrowIfNull(path);
+
+        var extension = Extension(path);
+
+        // Using OrdinalIgnoreCase since these are used internally with paths
+        if (ExecutableApplicationExtensions.Contains(extension))
+        {
+            return ApplicationType.Win32Application;
+        }
+        else if (extension.Equals(ShortcutExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            return ApplicationType.ShortcutApplication;
+        }
+        else if (extension.Equals(ApplicationReferenceExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            return ApplicationType.ApprefApplication;
+        }
+        else if (extension.Equals(InternetShortcutExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            return ApplicationType.InternetShortcutApplication;
+        }
+        else if (string.IsNullOrEmpty(extension) && System.IO.Directory.Exists(path))
+        {
+            return ApplicationType.Folder;
+        }
+
+        return ApplicationType.GenericFile;
+    }
+
+    // Function to get the Win32 application, given the path to the application
+    public static Win32Program? GetAppFromPath(string path)
+    {
+        ArgumentNullException.ThrowIfNull(path);
+
+        Win32Program? app;
+        switch (GetAppTypeFromPath(path))
+        {
+            case ApplicationType.Win32Application:
+                app = ExeProgram(path);
+                break;
+            case ApplicationType.ShortcutApplication:
+                app = LnkProgram(path);
+                break;
+            case ApplicationType.ApprefApplication:
+                app = CreateWin32Program(path);
+                app.AppType = ApplicationType.ApprefApplication;
+                break;
+            case ApplicationType.InternetShortcutApplication:
+                app = InternetShortcutProgram(path);
+                break;
+            case ApplicationType.WebApplication:
+            case ApplicationType.RunCommand:
+            case ApplicationType.Folder:
+            case ApplicationType.GenericFile:
+            default:
+                app = null;
+                break;
+        }
+
+        // if the app is valid, only then return the application, else return null
+        return app?.Valid == true
+            ? app
+            : null;
+    }
+
+    private static IEnumerable<string> ProgramPaths(string directory, IList<string> suffixes, bool recursiveSearch = true)
+    {
+        if (!Directory.Exists(directory))
+        {
+            return Array.Empty<string>();
+        }
+
+        var files = new List<string>();
+        var folderQueue = new Queue<string>();
+        folderQueue.Enqueue(directory);
+
+        // Keep track of already visited directories to avoid cycles.
+        var alreadyVisited = new HashSet<string>();
+
+        do
+        {
+            var currentDirectory = folderQueue.Dequeue();
+
+            if (alreadyVisited.Contains(currentDirectory))
+            {
+                continue;
+            }
+
+            alreadyVisited.Add(currentDirectory);
+
+            try
+            {
+                foreach (var suffix in suffixes)
+                {
+                    try
+                    {
+                        files.AddRange(Directory.EnumerateFiles(currentDirectory, $"*.{suffix}", SearchOption.TopDirectoryOnly));
+                    }
+                    catch (DirectoryNotFoundException)
+                    {
+                    }
+                }
+            }
+            catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+            {
+            }
+            catch (Exception)
+            {
+            }
+
+            try
+            {
+                // If the search is set to be non-recursive, then do not enqueue the child directories.
+                if (!recursiveSearch)
+                {
+                    continue;
+                }
+
+                foreach (var childDirectory in Directory.EnumerateDirectories(currentDirectory, "*", new EnumerationOptions()
+                {
+                    // https://learn.microsoft.com/dotnet/api/system.io.enumerationoptions?view=net-6.0
+                    // Exclude directories with the Reparse Point file attribute, to avoid loops due to symbolic links / directory junction / mount points.
+                    AttributesToSkip = FileAttributes.Hidden | FileAttributes.System | FileAttributes.ReparsePoint,
+                    RecurseSubdirectories = false,
+                }))
+                {
+                    folderQueue.Enqueue(childDirectory);
+                }
+            }
+            catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+            {
+            }
+            catch (Exception)
+            {
+            }
+        }
+        while (folderQueue.Count > 0);
+
+        return files;
+    }
+
+    private static string Extension(string path)
+    {
+        // Using InvariantCulture since this is user facing
+        var extension = Path.GetExtension(path)?.ToLowerInvariant();
+
+        return !string.IsNullOrEmpty(extension)
+            ? extension.Substring(1)
+            : string.Empty;
+    }
+
+    private static IEnumerable<string> CustomProgramPaths(IEnumerable<ProgramSource> sources, IList<string> suffixes)
+        => sources?.Where(programSource => Directory.Exists(programSource.Location) && programSource.Enabled)
+            .SelectMany(programSource => ProgramPaths(programSource.Location, suffixes))
+            .ToList() ?? Enumerable.Empty<string>();
+
+    // Function to obtain the list of applications, the locations of which have been added to the env variable PATH
+    private static List<string> PathEnvironmentProgramPaths(IList<string> suffixes)
+    {
+        // To get all the locations stored in the PATH env variable
+        var pathEnvVariable = Environment.GetEnvironmentVariable("PATH");
+        var searchPaths = pathEnvVariable?.Split(Path.PathSeparator);
+        var toFilterAllPaths = new List<string>();
+        var isRecursiveSearch = true;
+
+        if (searchPaths is not null)
+        {
+            foreach (var path in searchPaths)
+            {
+                if (path.Length > 0)
+                {
+                    // to expand any environment variables present in the path
+                    var directory = Environment.ExpandEnvironmentVariables(path);
+                    var paths = ProgramPaths(directory, suffixes, !isRecursiveSearch);
+                    toFilterAllPaths.AddRange(paths);
+                }
+            }
+        }
+
+        return toFilterAllPaths;
+    }
+
+    private static List<string> IndexPath(IList<string> suffixes, List<string> indexLocations)
+            => indexLocations
+            .SelectMany(indexLocation => ProgramPaths(indexLocation, suffixes))
+            .ToList();
+
+    private static List<string> StartMenuProgramPaths(IList<string> suffixes)
+    {
+        var directory1 = Environment.GetFolderPath(Environment.SpecialFolder.StartMenu);
+        var directory2 = Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu);
+        var indexLocation = new List<string>() { directory1, directory2 };
+
+        return IndexPath(suffixes, indexLocation);
+    }
+
+    private static List<string> DesktopProgramPaths(IList<string> suffixes)
+    {
+        var directory1 = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
+        var directory2 = Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory);
+
+        var indexLocation = new List<string>() { directory1, directory2 };
+
+        return IndexPath(suffixes, indexLocation);
+    }
+
+    private static List<string> RegistryAppProgramPaths(IList<string> suffixes)
+    {
+        // https://msdn.microsoft.com/library/windows/desktop/ee872121
+        const string appPaths = @"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths";
+        var paths = new List<string>();
+        using (var root = Registry.LocalMachine.OpenSubKey(appPaths))
+        {
+            if (root != null)
+            {
+                paths.AddRange(GetPathsFromRegistry(root));
+            }
+        }
+
+        using (var root = Registry.CurrentUser.OpenSubKey(appPaths))
+        {
+            if (root != null)
+            {
+                paths.AddRange(GetPathsFromRegistry(root));
+            }
+        }
+
+        return paths
+            .Where(path => suffixes.Any(suffix => path.EndsWith(suffix, StringComparison.InvariantCultureIgnoreCase)))
+            .Select(ExpandEnvironmentVariables)
+            .Where(path => path is not null)
+            .ToList();
+    }
+
+    private static IEnumerable<string> GetPathsFromRegistry(RegistryKey root)
+        => root
+            .GetSubKeyNames()
+            .Select(x => GetPathFromRegistrySubkey(root, x));
+
+    private static string GetPathFromRegistrySubkey(RegistryKey root, string subkey)
+    {
+        var path = string.Empty;
+        try
+        {
+            using (var key = root.OpenSubKey(subkey))
+            {
+                if (key == null)
+                {
+                    return string.Empty;
+                }
+
+                var defaultValue = string.Empty;
+                path = key.GetValue(defaultValue) as string;
+            }
+
+            if (string.IsNullOrEmpty(path))
+            {
+                return string.Empty;
+            }
+
+            // fix path like this: ""\"C:\\folder\\executable.exe\""
+            return path = path.Trim('"', ' ');
+        }
+        catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+        {
+            return string.Empty;
+        }
+    }
+
+    private static string ExpandEnvironmentVariables(string path) =>
+        !string.IsNullOrEmpty(path)
+            ? Environment.ExpandEnvironmentVariables(path)
+            : string.Empty;
+
+    // Overriding the object.GetHashCode() function to aid in removing duplicates while adding and removing apps from the concurrent dictionary storage
+    public override int GetHashCode()
+        => Win32ProgramEqualityComparer.Default.GetHashCode(this);
+
+    public override bool Equals(object? obj)
+        => obj is Win32Program win32Program && Win32ProgramEqualityComparer.Default.Equals(this, win32Program);
+
+    private sealed class Win32ProgramEqualityComparer : IEqualityComparer<Win32Program>
+    {
+        public static readonly Win32ProgramEqualityComparer Default = new Win32ProgramEqualityComparer();
+
+        public bool Equals(Win32Program? app1, Win32Program? app2)
+        {
+            if (app1 == null && app2 == null)
+            {
+                return true;
+            }
+
+            return app1 != null
+                    && app2 != null
+                    && (app1.Name?.ToUpperInvariant(), app1.ExecutableName?.ToUpperInvariant(), app1.FullPath?.ToUpperInvariant())
+                    .Equals((app2.Name?.ToUpperInvariant(), app2.ExecutableName?.ToUpperInvariant(), app2.FullPath?.ToUpperInvariant()));
+        }
+
+        public int GetHashCode(Win32Program obj)
+            => (obj.Name?.ToUpperInvariant(), obj.ExecutableName?.ToUpperInvariant(), obj.FullPath?.ToUpperInvariant()).GetHashCode();
+    }
+
+    public static List<Win32Program> DeduplicatePrograms(IEnumerable<Win32Program> programs)
+        => new HashSet<Win32Program>(programs, Win32ProgramEqualityComparer.Default).ToList();
+
+    private static Win32Program GetProgramFromPath(string path)
+    {
+        var extension = Extension(path);
+        if (ExecutableApplicationExtensions.Contains(extension))
+        {
+            return ExeProgram(path);
+        }
+
+        switch (extension)
+        {
+            case ShortcutExtension:
+                return LnkProgram(path);
+            case ApplicationReferenceExtension:
+                return CreateWin32Program(path);
+            case InternetShortcutExtension:
+                return InternetShortcutProgram(path);
+            default:
+                return InvalidProgram;
+        }
+    }
+
+    private static bool TryGetIcoPathForRunCommandProgram(Win32Program program, out string? icoPath)
+    {
+        icoPath = null;
+
+        if (program.AppType != ApplicationType.RunCommand)
+        {
+            return false;
+        }
+
+        if (string.IsNullOrEmpty(program.FullPath))
+        {
+            return false;
+        }
+
+        // https://msdn.microsoft.com/library/windows/desktop/ee872121
+        try
+        {
+            var redirectionPath = ReparsePoint.GetTarget(program.FullPath);
+            if (string.IsNullOrEmpty(redirectionPath))
+            {
+                return false;
+            }
+
+            icoPath = ExpandEnvironmentVariables(redirectionPath);
+            return true;
+        }
+        catch (IOException)
+        {
+        }
+
+        icoPath = null;
+        return false;
+    }
+
+    private static Win32Program GetRunCommandProgramFromPath(string path)
+    {
+        var program = GetProgramFromPath(path);
+        if (program.Valid)
+        {
+            program.AppType = ApplicationType.RunCommand;
+
+            if (TryGetIcoPathForRunCommandProgram(program, out var icoPath))
+            {
+                program.IcoPath = icoPath ?? string.Empty;
+            }
+        }
+
+        return program;
+    }
+
+    public static IList<Win32Program> All(AllAppsSettings settings)
+    {
+        ArgumentNullException.ThrowIfNull(settings);
+
+        try
+        {
+            // Set an initial size to an expected size to prevent multiple hashSet resizes
+            const int defaultHashsetSize = 1000;
+
+            // Multiple paths could have the same programPaths and we don't want to resolve / lookup them multiple times
+            var paths = new HashSet<string>(defaultHashsetSize);
+            var runCommandPaths = new HashSet<string>(defaultHashsetSize);
+
+            // Parallelize multiple sources, and priority based on paths which most likely contain .lnks which are formatted
+            var sources = new (bool IsEnabled, Func<IEnumerable<string>> GetPaths)[]
+            {
+                (true, () => CustomProgramPaths(settings.ProgramSources, settings.ProgramSuffixes)),
+                (settings.EnableStartMenuSource, () => StartMenuProgramPaths(settings.ProgramSuffixes)),
+                (settings.EnableDesktopSource, () => DesktopProgramPaths(settings.ProgramSuffixes)),
+                (settings.EnableRegistrySource, () => RegistryAppProgramPaths(settings.ProgramSuffixes)),
+            };
+
+            // Run commands are always set as AppType "RunCommand"
+            var runCommandSources = new (bool IsEnabled, Func<IEnumerable<string>> GetPaths)[]
+            {
+                (settings.EnablePathEnvironmentVariableSource, () => PathEnvironmentProgramPaths(settings.RunCommandSuffixes)),
+            };
+
+            var disabledProgramsList = settings.DisabledProgramSources;
+
+            // Get all paths but exclude all normal .Executables
+            paths.UnionWith(sources
+                .AsParallel()
+                .SelectMany(source => source.IsEnabled ? source.GetPaths() : Enumerable.Empty<string>())
+                .Where(programPath => disabledProgramsList.All(x => x.UniqueIdentifier != programPath))
+                .Where(path => !ExecutableApplicationExtensions.Contains(Extension(path))));
+            runCommandPaths.UnionWith(runCommandSources
+                .AsParallel()
+                .SelectMany(source => source.IsEnabled ? source.GetPaths() : Enumerable.Empty<string>())
+                .Where(programPath => disabledProgramsList.All(x => x.UniqueIdentifier != programPath)));
+
+            var programs = paths.AsParallel().Select(source => GetProgramFromPath(source));
+            var runCommandPrograms = runCommandPaths.AsParallel().Select(source => GetRunCommandProgramFromPath(source));
+
+            return DeduplicatePrograms(programs.Concat(runCommandPrograms).Where(program => program?.Valid == true));
+        }
+        catch (Exception)
+        {
+            return Array.Empty<Win32Program>();
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Properties/Resources.Designer.cs

@@ -0,0 +1,270 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.CmdPal.Ext.Apps.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.CmdPal.Ext.Apps.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to All Apps.
+        /// </summary>
+        internal static string all_apps {
+            get {
+                return ResourceManager.GetString("all_apps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Application.
+        /// </summary>
+        internal static string application {
+            get {
+                return ResourceManager.GetString("application", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Include apps found on the desktop.
+        /// </summary>
+        internal static string enable_desktop_source {
+            get {
+                return ResourceManager.GetString("enable_desktop_source", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Include apps anywhere on the %PATH%.
+        /// </summary>
+        internal static string enable_path_environment_variable_source {
+            get {
+                return ResourceManager.GetString("enable_path_environment_variable_source", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Include apps registered in the Registry.
+        /// </summary>
+        internal static string enable_registry_source {
+            get {
+                return ResourceManager.GetString("enable_registry_source", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Include apps found in the Start Menu.
+        /// </summary>
+        internal static string enable_start_menu_source {
+            get {
+                return ResourceManager.GetString("enable_start_menu_source", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to File.
+        /// </summary>
+        internal static string file {
+            get {
+                return ResourceManager.GetString("file", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Folder.
+        /// </summary>
+        internal static string folder {
+            get {
+                return ResourceManager.GetString("folder", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Installed apps.
+        /// </summary>
+        internal static string installed_apps {
+            get {
+                return ResourceManager.GetString("installed_apps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Internet shortcut application.
+        /// </summary>
+        internal static string internet_shortcut_application {
+            get {
+                return ResourceManager.GetString("internet_shortcut_application", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Open containing folder.
+        /// </summary>
+        internal static string open_containing_folder {
+            get {
+                return ResourceManager.GetString("open_containing_folder", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Open location.
+        /// </summary>
+        internal static string open_location {
+            get {
+                return ResourceManager.GetString("open_location", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Open path in console.
+        /// </summary>
+        internal static string open_path_in_console {
+            get {
+                return ResourceManager.GetString("open_path_in_console", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Packaged application.
+        /// </summary>
+        internal static string packaged_application {
+            get {
+                return ResourceManager.GetString("packaged_application", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Run as administrator.
+        /// </summary>
+        internal static string run_as_administrator {
+            get {
+                return ResourceManager.GetString("run_as_administrator", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Run as different user.
+        /// </summary>
+        internal static string run_as_different_user {
+            get {
+                return ResourceManager.GetString("run_as_different_user", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Run command.
+        /// </summary>
+        internal static string run_command {
+            get {
+                return ResourceManager.GetString("run_command", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Run.
+        /// </summary>
+        internal static string run_command_action {
+            get {
+                return ResourceManager.GetString("run_command_action", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Search installed apps.
+        /// </summary>
+        internal static string search_installed_apps {
+            get {
+                return ResourceManager.GetString("search_installed_apps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Search installed apps....
+        /// </summary>
+        internal static string search_installed_apps_placeholder {
+            get {
+                return ResourceManager.GetString("search_installed_apps_placeholder", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Experimental: When enabled, Command Palette will load thumbnails from the Windows Shell. Using thumbnails may cause the app to crash on launch.
+        /// </summary>
+        internal static string use_thumbnails_setting_description {
+            get {
+                return ResourceManager.GetString("use_thumbnails_setting_description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Use thumbnails for apps.
+        /// </summary>
+        internal static string use_thumbnails_setting_label {
+            get {
+                return ResourceManager.GetString("use_thumbnails_setting_label", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Web application.
+        /// </summary>
+        internal static string web_application {
+            get {
+                return ResourceManager.GetString("web_application", resourceCulture);
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Properties/Resources.resx

@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="run_command_action" xml:space="preserve">
+    <value>Run</value>
+    <comment>As in "run command"</comment>
+  </data>
+  <data name="installed_apps" xml:space="preserve">
+    <value>Installed apps</value>
+  </data>
+  <data name="search_installed_apps" xml:space="preserve">
+    <value>Search installed apps</value>
+  </data>
+  <data name="all_apps" xml:space="preserve">
+    <value>All Apps</value>
+  </data>
+  <data name="search_installed_apps_placeholder" xml:space="preserve">
+    <value>Search installed apps...</value>
+  </data>
+  <data name="open_path_in_console" xml:space="preserve">
+    <value>Open path in console</value>
+  </data>
+  <data name="packaged_application" xml:space="preserve">
+    <value>Packaged application</value>
+  </data>
+  <data name="open_containing_folder" xml:space="preserve">
+    <value>Open containing folder</value>
+  </data>
+  <data name="application" xml:space="preserve">
+    <value>Application</value>
+  </data>
+  <data name="internet_shortcut_application" xml:space="preserve">
+    <value>Internet shortcut application</value>
+  </data>
+  <data name="web_application" xml:space="preserve">
+    <value>Web application</value>
+  </data>
+  <data name="run_command" xml:space="preserve">
+    <value>Run command</value>
+  </data>
+  <data name="folder" xml:space="preserve">
+    <value>Folder</value>
+  </data>
+  <data name="file" xml:space="preserve">
+    <value>File</value>
+  </data>
+  <data name="open_location" xml:space="preserve">
+    <value>Open location</value>
+  </data>
+  <data name="run_as_administrator" xml:space="preserve">
+    <value>Run as administrator</value>
+  </data>
+  <data name="run_as_different_user" xml:space="preserve">
+    <value>Run as different user</value>
+  </data>
+  <data name="enable_start_menu_source" xml:space="preserve">
+    <value>Include apps found in the Start Menu</value>
+  </data>
+  <data name="enable_desktop_source" xml:space="preserve">
+    <value>Include apps found on the desktop</value>
+  </data>
+  <data name="enable_registry_source" xml:space="preserve">
+    <value>Include apps registered in the Registry</value>
+  </data>
+  <data name="enable_path_environment_variable_source" xml:space="preserve">
+    <value>Include apps anywhere on the %PATH%</value>
+  </data>
+  <data name="use_thumbnails_setting_label" xml:space="preserve">
+    <value>Use thumbnails for apps</value>
+    <comment>when enabled, we'll display thumbnails from the windows shell for programs</comment>
+  </data>
+  <data name="use_thumbnails_setting_description" xml:space="preserve">
+    <value>Experimental: When enabled, Command Palette will load thumbnails from the Windows Shell. Using thumbnails may cause the app to crash on launch</value>
+    <comment>A description for "use_thumbnails_setting_label"</comment>
+  </data>
+</root>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/EventHandler.cs

@@ -0,0 +1,42 @@
+// 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.Concurrent;
+using System.Threading.Tasks;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+public static class EventHandler
+{
+    // To obtain the path of the app when multiple events are added to the Concurrent queue across multiple threads.
+    // On the first occurrence of a different file path, the existing app path is to be returned without removing any more elements from the queue.
+    public static async Task<string> GetAppPathFromQueueAsync(ConcurrentQueue<string> eventHandlingQueue, int dequeueDelay)
+    {
+        ArgumentNullException.ThrowIfNull(eventHandlingQueue);
+
+        var previousAppPath = string.Empty;
+
+        // To obtain the last event associated with a particular app.
+        while (eventHandlingQueue.TryPeek(out var currentAppPath))
+        {
+            // Using OrdinalIgnoreCase since this is used internally with paths
+            if (string.IsNullOrEmpty(previousAppPath) || previousAppPath.Equals(currentAppPath, StringComparison.OrdinalIgnoreCase))
+            {
+                // To dequeue a path only if it is the first one in the queue or if the path was the same as the previous one (to avoid trying to create apps on duplicate events)
+                previousAppPath = currentAppPath;
+                eventHandlingQueue.TryDequeue(out _);
+            }
+            else
+            {
+                break;
+            }
+
+            // This delay has been added to account for the delay in events being triggered during app installation.
+            await Task.Delay(dequeueDelay).ConfigureAwait(false);
+        }
+
+        return previousAppPath;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/FileSystemWatcherWrapper.cs

@@ -0,0 +1,31 @@
+// 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.ObjectModel;
+using System.IO;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+// File System Watcher Wrapper class which implements the IFileSystemWatcherWrapper interface
+public sealed class FileSystemWatcherWrapper : FileSystemWatcher, IFileSystemWatcherWrapper
+{
+    public FileSystemWatcherWrapper()
+    {
+    }
+
+    Collection<string> IFileSystemWatcherWrapper.Filters
+    {
+        get => this.Filters;
+        set
+        {
+            if (value != null)
+            {
+                foreach (var filter in value)
+                {
+                    this.Filters.Add(filter);
+                }
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/IFileSystemWatcherWrapper.cs

@@ -0,0 +1,31 @@
+// 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.ObjectModel;
+using System.IO;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+public interface IFileSystemWatcherWrapper
+{
+    // Events to watch out for
+    event FileSystemEventHandler Created;
+
+    event FileSystemEventHandler Deleted;
+
+    event FileSystemEventHandler Changed;
+
+    event RenamedEventHandler Renamed;
+
+    // Properties of File System watcher
+    Collection<string> Filters { get; set; }
+
+    bool EnableRaisingEvents { get; set; }
+
+    NotifyFilters NotifyFilter { get; set; }
+
+    string Path { get; set; }
+
+    bool IncludeSubdirectories { get; set; }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/IProgramRepository.cs

@@ -0,0 +1,10 @@
+// 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.CmdPal.Ext.Apps.Storage;
+
+internal interface IProgramRepository
+{
+    void IndexPrograms();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/IRepository`1.cs

@@ -0,0 +1,20 @@
+// 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.Ext.Apps.Storage;
+
+public interface IRepository<T>
+{
+    void Add(T insertedItem);
+
+    void Remove(T removedItem);
+
+    bool Contains(T item);
+
+    void SetList(IList<T> list);
+
+    bool Any();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/ListRepository`1.cs

@@ -0,0 +1,99 @@
+// 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;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+/// <summary>
+/// The intent of this class is to provide a basic subset of 'list' like operations, without exposing callers to the internal representation
+/// of the data structure.  Currently this is implemented as a list for it's simplicity.
+/// </summary>
+/// <typeparam name="T">typeof</typeparam>
+public class ListRepository<T> : IRepository<T>, IEnumerable<T>
+{
+    public IList<T> Items
+    {
+        get { return _items.Values.ToList(); }
+    }
+
+    private ConcurrentDictionary<int, T> _items = new ConcurrentDictionary<int, T>();
+
+    public ListRepository()
+    {
+    }
+
+    public void SetList(IList<T> list)
+    {
+        // enforce that internal representation
+        try
+        {
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+            _items = new ConcurrentDictionary<int, T>(list.ToDictionary(i => i.GetHashCode()));
+#pragma warning restore CS8602 // Dereference of a possibly null reference.
+        }
+        catch (ArgumentException)
+        {
+        }
+    }
+
+    public bool Any()
+    {
+        return !_items.IsEmpty;
+    }
+
+    public void Add(T insertedItem)
+    {
+        if (insertedItem is not null)
+        {
+            if (!_items.TryAdd(insertedItem.GetHashCode(), insertedItem))
+            {
+            }
+        }
+    }
+
+    public void Remove(T removedItem)
+    {
+        if (removedItem is not null)
+        {
+            if (!_items.TryRemove(removedItem.GetHashCode(), out _))
+            {
+            }
+        }
+    }
+
+    public ParallelQuery<T> AsParallel()
+    {
+        return _items.Values.AsParallel();
+    }
+
+    public bool Contains(T item)
+    {
+        if (item is not null)
+        {
+            return _items.ContainsKey(item.GetHashCode());
+        }
+
+        return false;
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        return _items.Values.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return _items.GetEnumerator();
+    }
+
+    public int Count()
+    {
+        return _items.Count;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/PackageRepository.cs

@@ -0,0 +1,124 @@
+// 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.Linq;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Microsoft.CmdPal.Ext.Apps.Storage;
+using Microsoft.CmdPal.Ext.Apps.Utils;
+using Windows.ApplicationModel;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+/// <summary>
+/// A repository for storing packaged applications such as UWP apps or appx packaged desktop apps.
+/// This repository will also monitor for changes to the PackageCatalog and update the repository accordingly
+/// </summary>
+internal sealed class PackageRepository : ListRepository<UWPApplication>, IProgramRepository
+{
+    private readonly IPackageCatalog _packageCatalog;
+
+    private bool _isDirty;
+
+    public bool ShouldReload()
+    {
+        return _isDirty;
+    }
+
+    public void ResetReloadFlag()
+    {
+        _isDirty = false;
+    }
+
+    // private readonly PluginInitContext _context;
+    public PackageRepository(IPackageCatalog packageCatalog)
+    {
+        _packageCatalog = packageCatalog ?? throw new ArgumentNullException(nameof(packageCatalog), "PackageRepository expects an interface to be able to subscribe to package events");
+
+        _packageCatalog.PackageInstalling += OnPackageInstalling;
+        _packageCatalog.PackageUninstalling += OnPackageUninstalling;
+        _packageCatalog.PackageUpdating += OnPackageUpdating;
+    }
+
+    public void OnPackageInstalling(PackageCatalog p, PackageInstallingEventArgs args)
+    {
+        if (args.IsComplete)
+        {
+            AddPackage(args.Package);
+        }
+    }
+
+    public void OnPackageUninstalling(PackageCatalog p, PackageUninstallingEventArgs args)
+    {
+        if (args.Progress == 0)
+        {
+            RemovePackage(args.Package);
+        }
+    }
+
+    public void OnPackageUpdating(PackageCatalog p, PackageUpdatingEventArgs args)
+    {
+        if (args.Progress == 0)
+        {
+            RemovePackage(args.SourcePackage);
+        }
+
+        if (args.IsComplete)
+        {
+            AddPackage(args.TargetPackage);
+        }
+    }
+
+    private void AddPackage(Package package)
+    {
+        var packageWrapper = PackageWrapper.GetWrapperFromPackage(package);
+        if (string.IsNullOrEmpty(packageWrapper.InstalledLocation))
+        {
+            return;
+        }
+
+        try
+        {
+            var uwp = new UWP(packageWrapper);
+            uwp.InitializeAppInfo(packageWrapper.InstalledLocation);
+            foreach (var app in uwp.Apps)
+            {
+                app.UpdateLogoPath(ThemeHelper.GetCurrentTheme());
+                Add(app);
+                _isDirty = true;
+            }
+        }
+
+        // InitializeAppInfo will throw if there is no AppxManifest.xml for the package.
+        // Note there are sometimes multiple packages per product and this doesn't necessarily mean that we haven't found the app.
+        // eg. "Could not find file 'C:\\Program Files\\WindowsApps\\Microsoft.WindowsTerminalPreview_2020.616.45.0_neutral_~_8wekyb3d8bbwe\\AppxManifest.xml'."
+        catch (System.IO.FileNotFoundException)
+        {
+        }
+    }
+
+    private void RemovePackage(Package package)
+    {
+        // find apps associated with this package.
+        var packageWrapper = PackageWrapper.GetWrapperFromPackage(package);
+        var uwp = new UWP(packageWrapper);
+        var apps = Items.Where(a => a.Package.Equals(uwp)).ToArray();
+
+        foreach (var app in apps)
+        {
+            Remove(app);
+            _isDirty = true;
+        }
+    }
+
+    public void IndexPrograms()
+    {
+        var windows10 = new Version(10, 0);
+        var support = Environment.OSVersion.Version.Major >= windows10.Major;
+
+        var applications = support ? Programs.UWP.All() : Array.Empty<UWPApplication>();
+
+        SetList(applications);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/Win32ProgramFileSystemWatchers.cs

@@ -0,0 +1,80 @@
+// 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.IO;
+using System.Linq;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+internal sealed class Win32ProgramFileSystemWatchers : IDisposable
+{
+    public string[] PathsToWatch { get; set; }
+
+    public List<FileSystemWatcherWrapper> FileSystemWatchers { get; set; }
+
+    private bool _disposed;
+
+    // This class contains the list of directories to watch and initializes the File System Watchers
+    public Win32ProgramFileSystemWatchers()
+    {
+        PathsToWatch = GetPathsToWatch();
+
+        FileSystemWatchers = new List<FileSystemWatcherWrapper>();
+        for (var index = 0; index < PathsToWatch.Length; index++)
+        {
+            FileSystemWatchers.Add(new FileSystemWatcherWrapper());
+        }
+    }
+
+    // Returns an array of paths to be watched
+    private static string[] GetPathsToWatch()
+    {
+        var paths = new string[]
+                        {
+                           Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),
+                           Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu),
+                           Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
+                           Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory),
+                        };
+
+        var invalidPaths = new List<string>();
+        foreach (var path in paths)
+        {
+            try
+            {
+                Directory.GetFiles(path);
+            }
+            catch (Exception)
+            {
+                invalidPaths.Add(path);
+            }
+        }
+
+        return paths.Except(invalidPaths).ToArray();
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            if (disposing)
+            {
+                for (var index = 0; index < PathsToWatch.Length; index++)
+                {
+                    FileSystemWatchers[index].Dispose();
+                }
+
+                _disposed = true;
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/Win32ProgramRepository.cs

@@ -0,0 +1,273 @@
+// 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.Concurrent;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.IO.Abstractions;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.Apps.Programs;
+using Win32Program = Microsoft.CmdPal.Ext.Apps.Programs.Win32Program;
+
+namespace Microsoft.CmdPal.Ext.Apps.Storage;
+
+internal sealed class Win32ProgramRepository : ListRepository<Programs.Win32Program>, IProgramRepository
+{
+    private static readonly IFileSystem FileSystem = new FileSystem();
+    private static readonly IPath Path = FileSystem.Path;
+
+    private const string LnkExtension = ".lnk";
+    private const string UrlExtension = ".url";
+
+    private AllAppsSettings _settings;
+    private IList<IFileSystemWatcherWrapper> _fileSystemWatcherHelpers;
+    private string[] _pathsToWatch;
+    private int _numberOfPathsToWatch;
+    private Collection<string> extensionsToWatch = new Collection<string> { "*.exe", $"*{LnkExtension}", "*.appref-ms", $"*{UrlExtension}" };
+
+    private bool _isDirty;
+
+    private static ConcurrentQueue<string> commonEventHandlingQueue = new ConcurrentQueue<string>();
+
+    public Win32ProgramRepository(IList<IFileSystemWatcherWrapper> fileSystemWatcherHelpers, AllAppsSettings settings, string[] pathsToWatch)
+    {
+        _fileSystemWatcherHelpers = fileSystemWatcherHelpers;
+        _settings = settings ?? throw new ArgumentNullException(nameof(settings), "Win32ProgramRepository requires an initialized settings object");
+        _pathsToWatch = pathsToWatch;
+        _numberOfPathsToWatch = pathsToWatch.Length;
+        InitializeFileSystemWatchers();
+
+        // This task would always run in the background trying to dequeue file paths from the queue at regular intervals.
+        _ = Task.Run(async () =>
+        {
+            while (true)
+            {
+                var dequeueDelay = 500;
+                var appPath = await EventHandler.GetAppPathFromQueueAsync(commonEventHandlingQueue, dequeueDelay).ConfigureAwait(false);
+
+                // To allow for the installation process to finish.
+                await Task.Delay(5000).ConfigureAwait(false);
+
+                if (!string.IsNullOrEmpty(appPath))
+                {
+                    Win32Program? app = Win32Program.GetAppFromPath(appPath);
+                    if (app != null)
+                    {
+                        Add(app);
+                        _isDirty = true;
+                    }
+                }
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public bool ShouldReload()
+    {
+        return _isDirty;
+    }
+
+    public void ResetReloadFlag()
+    {
+        _isDirty = false;
+    }
+
+    private void InitializeFileSystemWatchers()
+    {
+        for (var index = 0; index < _numberOfPathsToWatch; index++)
+        {
+            // To set the paths to monitor
+            _fileSystemWatcherHelpers[index].Path = _pathsToWatch[index];
+
+            // to be notified when there is a change to a file
+            _fileSystemWatcherHelpers[index].NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
+
+            // filtering the app types that we want to monitor
+            _fileSystemWatcherHelpers[index].Filters = extensionsToWatch;
+
+            // Registering the event handlers
+            _fileSystemWatcherHelpers[index].Created += OnAppCreated;
+            _fileSystemWatcherHelpers[index].Deleted += OnAppDeleted;
+            _fileSystemWatcherHelpers[index].Renamed += OnAppRenamed;
+            _fileSystemWatcherHelpers[index].Changed += OnAppChanged;
+
+            // Enable the file system watcher
+            _fileSystemWatcherHelpers[index].EnableRaisingEvents = true;
+
+            // Enable it to search in sub folders as well
+            _fileSystemWatcherHelpers[index].IncludeSubdirectories = true;
+        }
+    }
+
+    private async Task OnAppRenamedAsync(object sender, RenamedEventArgs e)
+    {
+        var oldPath = e.OldFullPath;
+        var newPath = e.FullPath;
+
+        // fix for https://github.com/microsoft/PowerToys/issues/34391
+        // the msi installer creates a shortcut, which is detected by the PT Run and ends up in calling this OnAppRenamed method
+        // the thread needs to be halted for a short time to avoid locking the new shortcut file as we read it, otherwise the lock causes
+        // in the issue scenario that a warning is popping up during the msi install process.
+        await Task.Delay(1000).ConfigureAwait(false);
+
+        var extension = Path.GetExtension(newPath);
+        Win32Program.ApplicationType oldAppType = Win32Program.GetAppTypeFromPath(oldPath);
+        Programs.Win32Program? newApp = Win32Program.GetAppFromPath(newPath);
+        Programs.Win32Program? oldApp = null;
+
+        // Once the shortcut application is renamed, the old app does not exist and therefore when we try to get the FullPath we get the lnk path instead of the exe path
+        // This changes the hashCode() of the old application.
+        // Therefore, instead of retrieving the old app using the GetAppFromPath(), we construct the application ourself
+        // This situation is not encountered for other application types because the fullPath is the path itself, instead of being computed by using the path to the app.
+        try
+        {
+            if (oldAppType == Win32Program.ApplicationType.ShortcutApplication || oldAppType == Win32Program.ApplicationType.InternetShortcutApplication)
+            {
+                oldApp = new Win32Program() { Name = Path.GetFileNameWithoutExtension(e.OldName) ?? string.Empty, ExecutableName = Path.GetFileName(e.OldName) ?? string.Empty, FullPath = newApp?.FullPath ?? oldPath };
+            }
+            else
+            {
+                oldApp = Win32Program.GetAppFromPath(oldPath);
+            }
+        }
+        catch (Exception)
+        {
+        }
+
+        // To remove the old app which has been renamed and to add the new application.
+        if (oldApp != null)
+        {
+            if (string.IsNullOrWhiteSpace(oldApp.Name) || string.IsNullOrWhiteSpace(oldApp.ExecutableName) || string.IsNullOrWhiteSpace(oldApp.FullPath))
+            {
+            }
+            else
+            {
+                Remove(oldApp);
+                _isDirty = true;
+            }
+        }
+
+        if (newApp != null)
+        {
+            Add(newApp);
+            _isDirty = true;
+        }
+    }
+
+    private void OnAppRenamed(object sender, RenamedEventArgs e)
+    {
+        Task.Run(async () =>
+        {
+            await OnAppRenamedAsync(sender, e).ConfigureAwait(false);
+        }).ConfigureAwait(false);
+    }
+
+    private void OnAppDeleted(object sender, FileSystemEventArgs e)
+    {
+        var path = e.FullPath;
+        var extension = Path.GetExtension(path);
+        Win32Program? app = null;
+
+        try
+        {
+            // To mitigate the issue of not having a FullPath for a shortcut app, we iterate through the items and find the app with the same hashcode.
+            // Using OrdinalIgnoreCase since this is used internally
+            if (extension.Equals(LnkExtension, StringComparison.OrdinalIgnoreCase))
+            {
+                app = GetAppWithSameLnkFilePath(path);
+                if (app == null)
+                {
+                    // Cancelled links won't have a resolved path.
+                    app = GetAppWithSameNameAndExecutable(Path.GetFileNameWithoutExtension(path), Path.GetFileName(path));
+                }
+            }
+            else if (extension.Equals(UrlExtension, StringComparison.OrdinalIgnoreCase))
+            {
+                app = GetAppWithSameNameAndExecutable(Path.GetFileNameWithoutExtension(path), Path.GetFileName(path));
+            }
+            else
+            {
+                app = Programs.Win32Program.GetAppFromPath(path);
+            }
+        }
+        catch (Exception)
+        {
+        }
+
+        if (app != null)
+        {
+            Remove(app);
+            _isDirty = true;
+        }
+    }
+
+    // When a URL application is deleted, we can no longer get the HashCode directly from the path because the FullPath a Url app is the URL obtained from reading the file
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1309:Use ordinal string comparison", Justification = "Using CurrentCultureIgnoreCase since application names could be dependent on currentculture See: https://github.com/microsoft/PowerToys/pull/5847/files#r468245190")]
+    private Win32Program? GetAppWithSameNameAndExecutable(string name, string executableName)
+    {
+        foreach (Win32Program app in Items)
+        {
+            // Using CurrentCultureIgnoreCase since application names could be dependent on currentculture See: https://github.com/microsoft/PowerToys/pull/5847/files#r468245190
+            if (name.Equals(app.Name, StringComparison.CurrentCultureIgnoreCase) && executableName.Equals(app.ExecutableName, StringComparison.CurrentCultureIgnoreCase))
+            {
+                return app;
+            }
+        }
+
+        return null;
+    }
+
+    // To mitigate the issue faced (as stated above) when a shortcut application is renamed, the Exe FullPath and executable name must be obtained.
+    // Unlike the rename event args, since we do not have a newPath, we iterate through all the programs and find the one with the same LnkResolved path.
+    private Programs.Win32Program? GetAppWithSameLnkFilePath(string lnkFilePath)
+    {
+        foreach (Programs.Win32Program app in Items)
+        {
+            // Using Invariant / OrdinalIgnoreCase since we're comparing paths
+            if (lnkFilePath.ToUpperInvariant().Equals(app.LnkFilePath, StringComparison.OrdinalIgnoreCase))
+            {
+                return app;
+            }
+        }
+
+        return null;
+    }
+
+    private void OnAppCreated(object sender, FileSystemEventArgs e)
+    {
+        var path = e.FullPath;
+
+        // Using OrdinalIgnoreCase since we're comparing extensions
+        if (!Path.GetExtension(path).Equals(UrlExtension, StringComparison.OrdinalIgnoreCase) && !Path.GetExtension(path).Equals(LnkExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            Programs.Win32Program? app = Programs.Win32Program.GetAppFromPath(path);
+            if (app != null)
+            {
+                Add(app);
+                _isDirty = true;
+            }
+        }
+    }
+
+    private void OnAppChanged(object sender, FileSystemEventArgs e)
+    {
+        var path = e.FullPath;
+
+        // Using OrdinalIgnoreCase since we're comparing extensions
+        if (Path.GetExtension(path).Equals(UrlExtension, StringComparison.OrdinalIgnoreCase) || Path.GetExtension(path).Equals(LnkExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            // When a url or lnk app is installed, multiple created and changed events are triggered.
+            // To prevent the code from acting on the first such event (which may still be during app installation), the events are added a common queue and dequeued by a background task at regular intervals - https://github.com/microsoft/PowerToys/issues/6429.
+            commonEventHandlingQueue.Enqueue(path);
+        }
+    }
+
+    public void IndexPrograms()
+    {
+        var applications = Programs.Win32Program.All(_settings);
+
+        SetList(applications);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/IShellLinkHelper.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.
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+public interface IShellLinkHelper
+{
+    string RetrieveTargetPath(string path);
+
+    string Description { get; set; }
+
+    string Arguments { get; set; }
+
+    bool HasArguments { get; set; }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/Native.cs

@@ -0,0 +1,157 @@
+// 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.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+[SuppressMessage("Interoperability", "CA1401:P/Invokes should not be visible", Justification = "We want plugins to share this NativeMethods class, instead of each one creating its own.")]
+public sealed class Native
+{
+    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+    public static extern int SHLoadIndirectString(string pszSource, StringBuilder pszOutBuf, int cchOutBuf, nint ppvReserved);
+
+    [DllImport("shell32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    public static extern int SHCreateItemFromParsingName([MarshalAs(UnmanagedType.LPWStr)] string path, nint pbc, ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out IShellItem shellItem);
+
+    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+    public static extern HRESULT SHCreateStreamOnFileEx(string fileName, STGM grfMode, uint attributes, bool create, System.Runtime.InteropServices.ComTypes.IStream reserved, out System.Runtime.InteropServices.ComTypes.IStream stream);
+
+    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+    public static extern HRESULT SHLoadIndirectString(string pszSource, StringBuilder pszOutBuf, uint cchOutBuf, nint ppvReserved);
+
+    public enum HRESULT : uint
+    {
+        /// <summary>
+        /// Operation successful.
+        /// </summary>
+        S_OK = 0x00000000,
+
+        /// <summary>
+        /// Operation successful. (negative condition/no operation)
+        /// </summary>
+        S_FALSE = 0x00000001,
+
+        /// <summary>
+        /// Not implemented.
+        /// </summary>
+        E_NOTIMPL = 0x80004001,
+
+        /// <summary>
+        /// No such interface supported.
+        /// </summary>
+        E_NOINTERFACE = 0x80004002,
+
+        /// <summary>
+        /// Pointer that is not valid.
+        /// </summary>
+        E_POINTER = 0x80004003,
+
+        /// <summary>
+        /// Operation aborted.
+        /// </summary>
+        E_ABORT = 0x80004004,
+
+        /// <summary>
+        /// Unspecified failure.
+        /// </summary>
+        E_FAIL = 0x80004005,
+
+        /// <summary>
+        /// Unexpected failure.
+        /// </summary>
+        E_UNEXPECTED = 0x8000FFFF,
+
+        /// <summary>
+        /// General access denied error.
+        /// </summary>
+        E_ACCESSDENIED = 0x80070005,
+
+        /// <summary>
+        /// Handle that is not valid.
+        /// </summary>
+        E_HANDLE = 0x80070006,
+
+        /// <summary>
+        /// Failed to allocate necessary memory.
+        /// </summary>
+        E_OUTOFMEMORY = 0x8007000E,
+
+        /// <summary>
+        /// One or more arguments are not valid.
+        /// </summary>
+        E_INVALIDARG = 0x80070057,
+
+        /// <summary>
+        /// The operation was canceled by the user. (Error source 7 means Win32.)
+        /// </summary>
+        /// <SeeAlso href="https://learn.microsoft.com/windows/win32/debug/system-error-codes--1000-1299-"/>
+        /// <SeeAlso href="https://en.wikipedia.org/wiki/HRESULT"/>
+        E_CANCELLED = 0x800704C7,
+    }
+
+    public static class ShellItemTypeConstants
+    {
+        /// <summary>
+        /// Guid for type IShellItem.
+        /// </summary>
+        public static readonly Guid ShellItemGuid = new("43826d1e-e718-42ee-bc55-a1e261c37bfe");
+
+        /// <summary>
+        /// Guid for type IShellItem2.
+        /// </summary>
+        public static readonly Guid ShellItem2Guid = new("7E9FB0D3-919F-4307-AB2E-9B1860310C93");
+    }
+
+    /// <summary>
+    /// The following are ShellItem DisplayName types.
+    /// </summary>
+    [Flags]
+    public enum SIGDN : uint
+    {
+        NORMALDISPLAY = 0,
+        PARENTRELATIVEPARSING = 0x80018001,
+        PARENTRELATIVEFORADDRESSBAR = 0x8001c001,
+        DESKTOPABSOLUTEPARSING = 0x80028000,
+        PARENTRELATIVEEDITING = 0x80031001,
+        DESKTOPABSOLUTEEDITING = 0x8004c000,
+        FILESYSPATH = 0x80058000,
+        URL = 0x80068000,
+    }
+
+    [ComImport]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")]
+    public interface IShellItem
+    {
+        void BindToHandler(
+            nint pbc,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid bhid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid riid,
+            out nint ppv);
+
+        void GetParent(out IShellItem ppsi);
+
+        void GetDisplayName(SIGDN sigdnName, [MarshalAs(UnmanagedType.LPWStr)] out string ppszName);
+
+        void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+
+        void Compare(IShellItem psi, uint hint, out int piOrder);
+    }
+
+    /// <summary>
+    /// <see href="https://learn.microsoft.com/windows/win32/stg/stgm-constants">see all STGM values</see>
+    /// </summary>
+    [Flags]
+    public enum STGM : long
+    {
+        READ = 0x00000000L,
+        WRITE = 0x00000001L,
+        READWRITE = 0x00000002L,
+        CREATE = 0x00001000L,
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/ShellCommand.cs

@@ -0,0 +1,45 @@
+// 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.Text;
+using System.Threading;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+public static class ShellCommand
+{
+    public enum RunAsType
+    {
+        None,
+        Administrator,
+        OtherUser,
+    }
+
+    public static ProcessStartInfo GetProcessStartInfo(string target, string parentDir, string programArguments, RunAsType runAs = RunAsType.None)
+    {
+        return new ProcessStartInfo
+        {
+            FileName = target,
+            WorkingDirectory = parentDir,
+            UseShellExecute = true,
+            Arguments = programArguments,
+            Verb = runAs == RunAsType.Administrator ? "runAs" : runAs == RunAsType.OtherUser ? "runAsUser" : string.Empty,
+        };
+    }
+
+    public static ProcessStartInfo SetProcessStartInfo(this string fileName, string workingDirectory = "", string arguments = "", string verb = "")
+    {
+        var info = new ProcessStartInfo
+        {
+            FileName = fileName,
+            WorkingDirectory = workingDirectory,
+            Arguments = arguments,
+            Verb = verb,
+        };
+
+        return info;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/ShellLinkHelper.cs

@@ -0,0 +1,188 @@
+// 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.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Text;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+public class ShellLinkHelper : IShellLinkHelper
+{
+    [Flags]
+    private enum SLGP_FLAGS
+    {
+        SLGP_SHORTPATH = 0x1,
+        SLGP_UNCPRIORITY = 0x2,
+        SLGP_RAWPATH = 0x4,
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching COM")]
+    private struct WIN32_FIND_DATAW
+    {
+        public uint dwFileAttributes;
+        public long ftCreationTime;
+        public long ftLastAccessTime;
+        public long ftLastWriteTime;
+        public uint nFileSizeHigh;
+        public uint nFileSizeLow;
+        public uint dwReserved0;
+        public uint dwReserved1;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
+        public string cFileName;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
+        public string cAlternateFileName;
+    }
+
+    [Flags]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Implements COM Interface")]
+    public enum SLR_FLAGS
+    {
+        SLR_NO_UI = 0x1,
+        SLR_ANY_MATCH = 0x2,
+        SLR_UPDATE = 0x4,
+        SLR_NOUPDATE = 0x8,
+        SLR_NOSEARCH = 0x10,
+        SLR_NOTRACK = 0x20,
+        SLR_NOLINKINFO = 0x40,
+        SLR_INVOKE_MSI = 0x80,
+    }
+
+    // Reference : http://www.pinvoke.net/default.aspx/Interfaces.IShellLinkW
+
+    // The IShellLink interface allows Shell links to be created, modified, and resolved
+    [ComImport]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [Guid("000214F9-0000-0000-C000-000000000046")]
+    private interface IShellLinkW
+    {
+        /// <summary>Retrieves the path and file name of a Shell link object</summary>
+        void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, ref WIN32_FIND_DATAW pfd, SLGP_FLAGS fFlags);
+
+        /// <summary>Retrieves the list of item identifiers for a Shell link object</summary>
+        void GetIDList(out nint ppidl);
+
+        /// <summary>Sets the pointer to an item identifier list (PIDL) for a Shell link object.</summary>
+        void SetIDList(nint pidl);
+
+        /// <summary>Retrieves the description string for a Shell link object</summary>
+        void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName);
+
+        /// <summary>Sets the description for a Shell link object. The description can be any application-defined string</summary>
+        void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+
+        /// <summary>Retrieves the name of the working directory for a Shell link object</summary>
+        void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath);
+
+        /// <summary>Sets the name of the working directory for a Shell link object</summary>
+        void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir);
+
+        /// <summary>Retrieves the command-line arguments associated with a Shell link object</summary>
+        void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath);
+
+        /// <summary>Sets the command-line arguments for a Shell link object</summary>
+        void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs);
+
+        /// <summary>Retrieves the hot key for a Shell link object</summary>
+        void GetHotkey(out short pwHotkey);
+
+        /// <summary>Sets a hot key for a Shell link object</summary>
+        void SetHotkey(short wHotkey);
+
+        /// <summary>Retrieves the show command for a Shell link object</summary>
+        void GetShowCmd(out int piShowCmd);
+
+        /// <summary>Sets the show command for a Shell link object. The show command sets the initial show state of the window.</summary>
+        void SetShowCmd(int iShowCmd);
+
+        /// <summary>Retrieves the location (path and index) of the icon for a Shell link object</summary>
+        void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, int cchIconPath, out int piIcon);
+
+        /// <summary>Sets the location (path and index) of the icon for a Shell link object</summary>
+        void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon);
+
+        /// <summary>Sets the relative path to the Shell link object</summary>
+        void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved);
+
+        /// <summary>Attempts to find the target of a Shell link, even if it has been moved or renamed</summary>
+        void Resolve(ref nint hwnd, SLR_FLAGS fFlags);
+
+        /// <summary>Sets the path and file name of a Shell link object</summary>
+        void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile);
+    }
+
+    [ComImport]
+    [Guid("00021401-0000-0000-C000-000000000046")]
+    private class ShellLink
+    {
+    }
+
+    // Contains the description of the app
+    public string Description { get; set; } = string.Empty;
+
+    // Contains the arguments to the app
+    public string Arguments { get; set; } = string.Empty;
+
+    public bool HasArguments { get; set; }
+
+    // Retrieve the target path using Shell Link
+    public string RetrieveTargetPath(string path)
+    {
+        var link = new ShellLink();
+        const int STGM_READ = 0;
+
+        try
+        {
+            ((IPersistFile)link).Load(path, STGM_READ);
+        }
+        catch (System.IO.FileNotFoundException)
+        {
+            // Log.Exception("Path could not be retrieved", ex, GetType(), path);
+            return string.Empty;
+        }
+
+        var hwnd = default(nint);
+        ((IShellLinkW)link).Resolve(ref hwnd, 0);
+
+        const int MAX_PATH = 260;
+        var buffer = new StringBuilder(MAX_PATH);
+
+        var data = default(WIN32_FIND_DATAW);
+        ((IShellLinkW)link).GetPath(buffer, buffer.Capacity, ref data, SLGP_FLAGS.SLGP_SHORTPATH);
+        var target = buffer.ToString();
+
+        // To set the app description
+        if (!string.IsNullOrEmpty(target))
+        {
+            buffer = new StringBuilder(MAX_PATH);
+            try
+            {
+                ((IShellLinkW)link).GetDescription(buffer, MAX_PATH);
+                Description = buffer.ToString();
+            }
+            catch (Exception)
+            {
+                // Log.Exception($"Failed to fetch description for {target}, {e.Message}", e, GetType());
+                Description = string.Empty;
+            }
+
+            var argumentBuffer = new StringBuilder(MAX_PATH);
+            ((IShellLinkW)link).GetArguments(argumentBuffer, argumentBuffer.Capacity);
+            Arguments = argumentBuffer.ToString();
+
+            // Set variable to true if the program takes in any arguments
+            if (argumentBuffer.Length != 0)
+            {
+                HasArguments = true;
+            }
+        }
+
+        // To release unmanaged memory
+        Marshal.ReleaseComObject(link);
+
+        return target;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/ShellLocalization.cs

@@ -0,0 +1,82 @@
+// 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.Concurrent;
+using System.IO;
+using static Microsoft.CmdPal.Ext.Apps.Utils.Native;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+/// <summary>
+/// Class to get localized name of shell items like 'My computer'. The localization is based on the 'windows display language'.
+/// </summary>
+public class ShellLocalization
+{
+    internal static readonly ShellLocalization Instance = new();
+
+    // Cache for already localized names. This makes localization of already localized string faster.
+    private ConcurrentDictionary<string, string> _localizationCache = new ConcurrentDictionary<string, string>();
+
+    /// <summary>
+    /// Returns the localized name of a shell item.
+    /// </summary>
+    /// <param name="path">Path to the shell item (e. g. shortcut 'File Explorer.lnk').</param>
+    /// <returns>The localized name as string or <see cref="string.Empty"/>.</returns>
+    public string GetLocalizedName(string path)
+    {
+        var lowerInvariantPath = path.ToLowerInvariant();
+
+        // Checking cache if path is already localized
+        if (_localizationCache.TryGetValue(lowerInvariantPath, out var value))
+        {
+            return value;
+        }
+
+        var shellItemType = ShellItemTypeConstants.ShellItemGuid;
+        var retCode = SHCreateItemFromParsingName(path, nint.Zero, ref shellItemType, out var shellItem);
+        if (retCode != 0)
+        {
+            return string.Empty;
+        }
+
+        shellItem.GetDisplayName(SIGDN.NORMALDISPLAY, out var filename);
+
+        _ = _localizationCache.TryAdd(lowerInvariantPath, filename);
+
+        return filename;
+    }
+
+    /// <summary>
+    /// This method returns the localized path to a shell item (folder or file)
+    /// </summary>
+    /// <param name="path">The path to localize</param>
+    /// <returns>The localized path or the original path if localized version is not available</returns>
+    public string GetLocalizedPath(string path)
+    {
+        path = Environment.ExpandEnvironmentVariables(path);
+        var ext = Path.GetExtension(path);
+        var pathParts = path.Split("\\");
+        var locPath = new string[pathParts.Length];
+
+        for (var i = 0; i < pathParts.Length; i++)
+        {
+            if (i == 0 && pathParts[i].EndsWith(':'))
+            {
+                // Skip the drive letter.
+                locPath[0] = pathParts[0];
+                continue;
+            }
+
+            // Localize path.
+            var iElements = i + 1;
+            var lName = GetLocalizedName(string.Join("\\", pathParts[..iElements]));
+            locPath[i] = !string.IsNullOrEmpty(lName) ? lName : pathParts[i];
+        }
+
+        var newPath = string.Join("\\", locPath);
+        newPath = !newPath.EndsWith(ext, StringComparison.InvariantCultureIgnoreCase) ? newPath + ext : newPath;
+
+        return newPath;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/Theme.cs

@@ -0,0 +1,22 @@
+// 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.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+public enum Theme
+{
+    System,
+    Light,
+    Dark,
+    HighContrastOne,
+    HighContrastTwo,
+    HighContrastBlack,
+    HighContrastWhite,
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Utils/ThemeHelper.cs

@@ -0,0 +1,70 @@
+// 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 System.Linq;
+
+using Microsoft.Win32;
+
+namespace Microsoft.CmdPal.Ext.Apps.Utils;
+
+public static class ThemeHelper
+{
+    public static Theme GetCurrentTheme()
+    {
+        // Check for high-contrast mode
+        Theme highContrastTheme = GetHighContrastBaseType();
+        if (highContrastTheme != Theme.Light)
+        {
+            return highContrastTheme;
+        }
+
+        // Check if the system is using dark or light mode
+        return IsSystemDarkMode() ? Theme.Dark : Theme.Light;
+    }
+
+    private static bool IsSystemDarkMode()
+    {
+        const string registryKey = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
+        const string registryValue = "AppsUseLightTheme";
+
+        // Retrieve the registry value, which is a DWORD (0 or 1)
+        var registryValueObj = Registry.GetValue(registryKey, registryValue, null);
+        if (registryValueObj != null)
+        {
+            // 0 = Dark mode, 1 = Light mode
+            var isLightMode = Convert.ToBoolean((int)registryValueObj, CultureInfo.InvariantCulture);
+            return !isLightMode; // Invert because 0 = Dark
+        }
+        else
+        {
+            // Default to Light theme if the registry key is missing
+            return false; // Default to dark mode assumption
+        }
+    }
+
+    public static Theme GetHighContrastBaseType()
+    {
+        const string registryKey = @"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes";
+        const string registryValue = "CurrentTheme";
+
+        var themePath = (string?)Registry.GetValue(registryKey, registryValue, string.Empty);
+        if (string.IsNullOrEmpty(themePath))
+        {
+            return Theme.Light; // Default to light theme if missing
+        }
+
+        var theme = themePath.Split('\\').Last().Split('.').First().ToLowerInvariant();
+
+        return theme switch
+        {
+            "hc1" => Theme.HighContrastOne,
+            "hc2" => Theme.HighContrastTwo,
+            "hcwhite" => Theme.HighContrastWhite,
+            "hcblack" => Theme.HighContrastBlack,
+            _ => Theme.Light,
+        };
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/AddBookmarkForm.cs

@@ -0,0 +1,107 @@
+// 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.Json;
+using System.Text.Json.Nodes;
+using Microsoft.CmdPal.Ext.Bookmarks.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+internal sealed partial class AddBookmarkForm : FormContent
+{
+    internal event TypedEventHandler<object, BookmarkData>? AddedCommand;
+
+    private readonly BookmarkData? _bookmark;
+
+    public AddBookmarkForm(BookmarkData? bookmark)
+    {
+        _bookmark = bookmark;
+        var name = _bookmark?.Name ?? string.Empty;
+        var url = _bookmark?.Bookmark ?? string.Empty;
+        TemplateJson = $$"""
+{
+    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+    "type": "AdaptiveCard",
+    "version": "1.5",
+    "body": [
+        {
+            "type": "Input.Text",
+            "style": "text",
+            "id": "name",
+            "label": "{{Resources.bookmarks_form_name_label}}",
+            "value": {{JsonSerializer.Serialize(name)}},
+            "isRequired": true,
+            "errorMessage": "{{Resources.bookmarks_form_name_required}}"
+        },
+        {
+            "type": "Input.Text",
+            "style": "text",
+            "id": "bookmark",
+            "value": {{JsonSerializer.Serialize(url)}},
+            "label": "{{Resources.bookmarks_form_bookmark_label}}",
+            "isRequired": true,
+            "errorMessage": "{{Resources.bookmarks_form_bookmark_required}}"
+        }
+    ],
+    "actions": [
+        {
+            "type": "Action.Submit",
+            "title": "{{Resources.bookmarks_form_save}}",
+            "data": {
+                "name": "name",
+                "bookmark": "bookmark"
+            }
+        }
+    ]
+}
+""";
+    }
+
+    public override CommandResult SubmitForm(string payload)
+    {
+        var formInput = JsonNode.Parse(payload);
+        if (formInput == null)
+        {
+            return CommandResult.GoHome();
+        }
+
+        // get the name and url out of the values
+        var formName = formInput["name"] ?? string.Empty;
+        var formBookmark = formInput["bookmark"] ?? string.Empty;
+        var hasPlaceholder = formBookmark.ToString().Contains('{') && formBookmark.ToString().Contains('}');
+
+        // Determine the type of the bookmark
+        string bookmarkType;
+
+        if (formBookmark.ToString().StartsWith("http://", StringComparison.OrdinalIgnoreCase) || formBookmark.ToString().StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+        {
+            bookmarkType = "web";
+        }
+        else if (File.Exists(formBookmark.ToString()))
+        {
+            bookmarkType = "file";
+        }
+        else if (Directory.Exists(formBookmark.ToString()))
+        {
+            bookmarkType = "folder";
+        }
+        else
+        {
+            // Default to web if we can't determine the type
+            bookmarkType = "web";
+        }
+
+        var updated = _bookmark ?? new BookmarkData();
+        updated.Name = formName.ToString();
+        updated.Bookmark = formBookmark.ToString();
+        updated.Type = bookmarkType;
+
+        AddedCommand?.Invoke(this, updated);
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/AddBookmarkPage.cs

@@ -0,0 +1,34 @@
+// 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.Bookmarks.Properties;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+internal sealed partial class AddBookmarkPage : ContentPage
+{
+    private readonly AddBookmarkForm _addBookmark;
+
+    internal event TypedEventHandler<object, BookmarkData>? AddedCommand
+    {
+        add => _addBookmark.AddedCommand += value;
+        remove => _addBookmark.AddedCommand -= value;
+    }
+
+    public override IContent[] GetContent() => [_addBookmark];
+
+    public AddBookmarkPage(BookmarkData? bookmark)
+    {
+        var name = bookmark?.Name ?? string.Empty;
+        var url = bookmark?.Bookmark ?? string.Empty;
+        Icon = IconHelpers.FromRelativePath("Assets\\Bookmark.svg");
+        var isAdd = string.IsNullOrEmpty(name) && string.IsNullOrEmpty(url);
+        Title = isAdd ? Resources.bookmarks_add_title : Resources.bookmarks_edit_name;
+        Name = isAdd ? Resources.bookmarks_add_name : Resources.bookmarks_edit_name;
+        _addBookmark = new(bookmark);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Assets/Bookmark.svg

@@ -0,0 +1,20 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3.84868 15.8874C3.49425 16.1693 3 15.8893 3 15.4067V3.56616C3 2.14891 4.03946 1 5.3217 1H10.6783C11.9605 1 13 2.14891 13 3.56616V15.4067C13 15.8893 12.5057 16.1693 12.1513 15.8874L7.99999 12.5863L3.84868 15.8874Z" fill="url(#paint0_linear_1900_17905)"/>
+<path d="M9.17749 1.02412C9.86491 0.564808 10.6731 0.31963 11.4998 0.319592C12.6082 0.320929 13.6707 0.761812 14.4545 1.54554C15.2382 2.32931 15.6791 3.39196 15.6804 4.50037C15.6803 5.32705 15.4352 6.13515 14.9759 6.82251C14.5165 7.50998 13.8636 8.04578 13.0998 8.36219C12.3359 8.6786 11.4954 8.76138 10.6844 8.60008C9.87352 8.43878 9.12865 8.04063 8.54401 7.45599C7.95937 6.87135 7.56122 6.12647 7.39992 5.31556C7.23862 4.50464 7.3214 3.6641 7.63781 2.90023C7.95421 2.13636 8.49003 1.48347 9.17749 1.02412Z" fill="url(#paint1_linear_1900_17905)" stroke="url(#paint2_linear_1900_17905)" stroke-width="0.639184"/>
+<rect x="8" y="4" width="7" height="1" rx="0.5" fill="#0C58A2"/>
+<rect x="11" y="8" width="7" height="1" rx="0.5" transform="rotate(-90 11 8)" fill="#0C58A2"/>
+<defs>
+<linearGradient id="paint0_linear_1900_17905" x1="4.2484" y1="-0.184382" x2="12.4694" y2="16.9798" gradientUnits="userSpaceOnUse">
+<stop stop-color="#0A7ACC"/>
+<stop offset="1" stop-color="#0E5497"/>
+</linearGradient>
+<linearGradient id="paint1_linear_1900_17905" x1="13.7504" y1="8.39775" x2="9.24963" y2="0.60225" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FCFCFC"/>
+<stop offset="1" stop-color="#E7E7E7"/>
+</linearGradient>
+<linearGradient id="paint2_linear_1900_17905" x1="9.75" y1="5.63474e-08" x2="12.8347" y2="9.07039" gradientUnits="userSpaceOnUse">
+<stop stop-color="#173A73" stop-opacity="0.1"/>
+<stop offset="1" stop-color="#173A73" stop-opacity="0.25"/>
+</linearGradient>
+</defs>
+</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/BookmarkData.cs

@@ -0,0 +1,19 @@
+// 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.Text.Json.Serialization;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+public class BookmarkData
+{
+    public string Name { get; set; } = string.Empty;
+
+    public string Bookmark { get; set; } = string.Empty;
+
+    public string Type { get; set; } = string.Empty;
+
+    [JsonIgnore]
+    public bool IsPlaceholder => Bookmark.Contains('{') && Bookmark.Contains('}');
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/BookmarkPlaceholderForm.cs

@@ -0,0 +1,109 @@
+// 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 System.Linq;
+using System.Text;
+using System.Text.Json.Nodes;
+using System.Text.RegularExpressions;
+using Microsoft.CmdPal.Ext.Bookmarks.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+internal sealed partial class BookmarkPlaceholderForm : FormContent
+{
+    private static readonly CompositeFormat ErrorMessage = System.Text.CompositeFormat.Parse(Resources.bookmarks_required_placeholder);
+
+    private readonly List<string> _placeholderNames;
+
+    private readonly string _bookmark = string.Empty;
+
+    // TODO pass in an array of placeholders
+    public BookmarkPlaceholderForm(string name, string url, string type)
+    {
+        _bookmark = url;
+        var r = new Regex(Regex.Escape("{") + "(.*?)" + Regex.Escape("}"));
+        var matches = r.Matches(url);
+        _placeholderNames = matches.Select(m => m.Groups[1].Value).ToList();
+        var inputs = _placeholderNames.Select(p =>
+        {
+            var errorMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessage, p);
+            return $$"""
+{
+    "type": "Input.Text",
+    "style": "text",
+    "id": "{{p}}",
+    "label": "{{p}}",
+    "isRequired": true,
+    "errorMessage": "{{errorMessage}}"
+}
+""";
+        }).ToList();
+
+        var allInputs = string.Join(",", inputs);
+
+        TemplateJson = $$"""
+{
+  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+  "type": "AdaptiveCard",
+  "version": "1.5",
+  "body": [
+""" + allInputs + $$"""
+  ],
+  "actions": [
+    {
+      "type": "Action.Submit",
+      "title": "{{Resources.bookmarks_form_open}}",
+      "data": {
+        "placeholder": "placeholder"
+      }
+    }
+  ]
+}
+""";
+    }
+
+    public override CommandResult SubmitForm(string payload)
+    {
+        var target = _bookmark;
+
+        // parse the submitted JSON and then open the link
+        var formInput = JsonNode.Parse(payload);
+        var formObject = formInput?.AsObject();
+        if (formObject == null)
+        {
+            return CommandResult.GoHome();
+        }
+
+        foreach (var (key, value) in formObject)
+        {
+            var placeholderString = $"{{{key}}}";
+            var placeholderData = value?.ToString();
+            target = target.Replace(placeholderString, placeholderData);
+        }
+
+        try
+        {
+            var uri = UrlCommand.GetUri(target);
+            if (uri != null)
+            {
+                _ = Launcher.LaunchUriAsync(uri);
+            }
+            else
+            {
+                // throw new UriFormatException("The provided URL is not valid.");
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error launching URL: {ex.Message}");
+        }
+
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/BookmarkPlaceholderPage.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 Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+internal sealed partial class BookmarkPlaceholderPage : ContentPage
+{
+    private readonly FormContent _bookmarkPlaceholder;
+
+    public override IContent[] GetContent() => [_bookmarkPlaceholder];
+
+    public BookmarkPlaceholderPage(BookmarkData data)
+        : this(data.Name, data.Bookmark, data.Type)
+    {
+    }
+
+    public BookmarkPlaceholderPage(string name, string url, string type)
+    {
+        Name = name;
+        Icon = new IconInfo(UrlCommand.IconFromUrl(url, type));
+        _bookmarkPlaceholder = new BookmarkPlaceholderForm(name, url, type);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Bookmarks.cs

@@ -0,0 +1,44 @@
+// 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;
+using System.IO;
+using System.Text.Json;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+public sealed class Bookmarks
+{
+    public List<BookmarkData> Data { get; set; } = [];
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        IncludeFields = true,
+    };
+
+    public static Bookmarks ReadFromFile(string path)
+    {
+        var data = new Bookmarks();
+
+        // if the file exists, load it and append the new item
+        if (File.Exists(path))
+        {
+            var jsonStringReading = File.ReadAllText(path);
+
+            if (!string.IsNullOrEmpty(jsonStringReading))
+            {
+                data = JsonSerializer.Deserialize<Bookmarks>(jsonStringReading, _jsonOptions) ?? new Bookmarks();
+            }
+        }
+
+        return data;
+    }
+
+    public static void WriteToFile(string path, Bookmarks data)
+    {
+        var jsonString = JsonSerializer.Serialize(data, _jsonOptions);
+
+        File.WriteAllText(BookmarksCommandProvider.StateJsonPath(), jsonString);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/BookmarksCommandProvider.cs

@@ -0,0 +1,183 @@
+// 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 Microsoft.CmdPal.Ext.Bookmarks.Properties;
+using Microsoft.CmdPal.Ext.Indexer;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+public partial class BookmarksCommandProvider : CommandProvider
+{
+    private readonly List<CommandItem> _commands = [];
+
+    private readonly AddBookmarkPage _addNewCommand = new(null);
+
+    private Bookmarks? _bookmarks;
+
+    public static IconInfo DeleteIcon { get; private set; } = new("\uE74D"); // Delete
+
+    public static IconInfo EditIcon { get; private set; } = new("\uE70F"); // Edit
+
+    public BookmarksCommandProvider()
+    {
+        Id = "Bookmarks";
+        DisplayName = Resources.bookmarks_display_name;
+        Icon = new IconInfo("\uE718"); // Pin
+
+        _addNewCommand.AddedCommand += AddNewCommand_AddedCommand;
+    }
+
+    private void AddNewCommand_AddedCommand(object sender, BookmarkData args)
+    {
+        ExtensionHost.LogMessage($"Adding bookmark ({args.Name},{args.Bookmark})");
+        if (_bookmarks != null)
+        {
+            _bookmarks.Data.Add(args);
+        }
+
+        SaveAndUpdateCommands();
+    }
+
+    // In the edit path, `args` was already in _bookmarks, we just updated it
+    private void Edit_AddedCommand(object sender, BookmarkData args)
+    {
+        ExtensionHost.LogMessage($"Edited bookmark ({args.Name},{args.Bookmark})");
+
+        SaveAndUpdateCommands();
+    }
+
+    private void SaveAndUpdateCommands()
+    {
+        if (_bookmarks != null)
+        {
+            var jsonPath = BookmarksCommandProvider.StateJsonPath();
+            Bookmarks.WriteToFile(jsonPath, _bookmarks);
+        }
+
+        LoadCommands();
+        RaiseItemsChanged(0);
+    }
+
+    private void LoadCommands()
+    {
+        List<CommandItem> collected = [];
+        collected.Add(new CommandItem(_addNewCommand));
+
+        if (_bookmarks == null)
+        {
+            LoadBookmarksFromFile();
+        }
+
+        if (_bookmarks != null)
+        {
+            collected.AddRange(_bookmarks.Data.Select(BookmarkToCommandItem));
+        }
+
+        _commands.Clear();
+        _commands.AddRange(collected);
+    }
+
+    private void LoadBookmarksFromFile()
+    {
+        try
+        {
+            var jsonFile = StateJsonPath();
+            if (File.Exists(jsonFile))
+            {
+                _bookmarks = Bookmarks.ReadFromFile(jsonFile);
+            }
+        }
+        catch (Exception ex)
+        {
+            // debug log error
+            Debug.WriteLine($"Error loading commands: {ex.Message}");
+        }
+
+        if (_bookmarks == null)
+        {
+            _bookmarks = new();
+        }
+    }
+
+    private CommandItem BookmarkToCommandItem(BookmarkData bookmark)
+    {
+        ICommand command = bookmark.IsPlaceholder ?
+            new BookmarkPlaceholderPage(bookmark) :
+            new UrlCommand(bookmark);
+
+        var listItem = new CommandItem(command) { Icon = command.Icon };
+
+        List<CommandContextItem> contextMenu = [];
+
+        // Add commands for folder types
+        if (command is UrlCommand urlCommand)
+        {
+            if (urlCommand.Type == "folder")
+            {
+                contextMenu.Add(
+                    new CommandContextItem(new DirectoryPage(urlCommand.Url)));
+
+                contextMenu.Add(
+                    new CommandContextItem(new OpenInTerminalCommand(urlCommand.Url)));
+            }
+
+            listItem.Subtitle = urlCommand.Url;
+        }
+
+        var edit = new AddBookmarkPage(bookmark) { Icon = EditIcon };
+        edit.AddedCommand += Edit_AddedCommand;
+        contextMenu.Add(new CommandContextItem(edit));
+
+        var delete = new CommandContextItem(
+            title: Resources.bookmarks_delete_title,
+            name: Resources.bookmarks_delete_name,
+            action: () =>
+            {
+                if (_bookmarks != null)
+                {
+                    ExtensionHost.LogMessage($"Deleting bookmark ({bookmark.Name},{bookmark.Bookmark})");
+
+                    _bookmarks.Data.Remove(bookmark);
+
+                    SaveAndUpdateCommands();
+                }
+            },
+            result: CommandResult.KeepOpen())
+        {
+            IsCritical = true,
+            Icon = DeleteIcon,
+        };
+        contextMenu.Add(delete);
+
+        listItem.MoreCommands = contextMenu.ToArray();
+
+        return listItem;
+    }
+
+    public override ICommandItem[] TopLevelCommands()
+    {
+        if (_commands.Count == 0)
+        {
+            LoadCommands();
+        }
+
+        return _commands.ToArray();
+    }
+
+    internal static string StateJsonPath()
+    {
+        var directory = Utilities.BaseSettingsPath("Microsoft.CmdPal");
+        Directory.CreateDirectory(directory);
+
+        // now, the state is just next to the exe
+        return System.IO.Path.Combine(directory, "bookmarks.json");
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Microsoft.CmdPal.Ext.Bookmarks.csproj

@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <PropertyGroup>
+    <RootNamespace>Microsoft.CmdPal.Ext.Bookmarks</RootNamespace>
+    <Nullable>enable</Nullable>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <!-- MRT from windows app sdk will search for a pri file with the same name of the module before defaulting to resources.pri -->
+    <ProjectPriFileName>Microsoft.CmdPal.Ext.Bookmarks.pri</ProjectPriFileName>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Remove="Assets\Bookmark.svg" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Indexer\Microsoft.CmdPal.Ext.Indexer.csproj" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <Compile Update="Properties\Resources.Designer.cs">
+      <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
+  </ItemGroup>
+  
+  <ItemGroup>
+    <Content Update="Assets\Bookmark.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Update="Assets\Bookmark.svg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Update="Properties\Resources.resx">
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <Generator>PublicResXFileCodeGenerator</Generator>
+    </EmbeddedResource>
+  </ItemGroup>
+  
+</Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/OpenInTerminalCommand.cs

@@ -0,0 +1,42 @@
+// 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 Microsoft.CmdPal.Ext.Bookmarks.Properties;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+internal sealed partial class OpenInTerminalCommand : InvokableCommand
+{
+    private readonly string _folder;
+
+    public OpenInTerminalCommand(string folder)
+    {
+        Name = Resources.bookmarks_open_in_terminal_name;
+        _folder = folder;
+    }
+
+    public override ICommandResult Invoke()
+    {
+        try
+        {
+            // Start Windows Terminal with the specified folder
+            var startInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "wt.exe",
+                Arguments = $"-d \"{_folder}\"",
+                UseShellExecute = true,
+            };
+            System.Diagnostics.Process.Start(startInfo);
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error launching Windows Terminal: {ex.Message}");
+        }
+
+        return CommandResult.Dismiss();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Properties/Resources.Designer.cs

@@ -0,0 +1,189 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.CmdPal.Ext.Bookmarks.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.CmdPal.Ext.Bookmarks.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Add bookmark.
+        /// </summary>
+        public static string bookmarks_add_name {
+            get {
+                return ResourceManager.GetString("bookmarks_add_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Add a bookmark.
+        /// </summary>
+        public static string bookmarks_add_title {
+            get {
+                return ResourceManager.GetString("bookmarks_add_title", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Delete.
+        /// </summary>
+        public static string bookmarks_delete_name {
+            get {
+                return ResourceManager.GetString("bookmarks_delete_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Delete bookmark.
+        /// </summary>
+        public static string bookmarks_delete_title {
+            get {
+                return ResourceManager.GetString("bookmarks_delete_title", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Bookmarks.
+        /// </summary>
+        public static string bookmarks_display_name {
+            get {
+                return ResourceManager.GetString("bookmarks_display_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Edit bookmark.
+        /// </summary>
+        public static string bookmarks_edit_name {
+            get {
+                return ResourceManager.GetString("bookmarks_edit_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to URL or file path.
+        /// </summary>
+        public static string bookmarks_form_bookmark_label {
+            get {
+                return ResourceManager.GetString("bookmarks_form_bookmark_label", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to URL or file path is required.
+        /// </summary>
+        public static string bookmarks_form_bookmark_required {
+            get {
+                return ResourceManager.GetString("bookmarks_form_bookmark_required", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Name.
+        /// </summary>
+        public static string bookmarks_form_name_label {
+            get {
+                return ResourceManager.GetString("bookmarks_form_name_label", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Name is required.
+        /// </summary>
+        public static string bookmarks_form_name_required {
+            get {
+                return ResourceManager.GetString("bookmarks_form_name_required", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Open.
+        /// </summary>
+        public static string bookmarks_form_open {
+            get {
+                return ResourceManager.GetString("bookmarks_form_open", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Save.
+        /// </summary>
+        public static string bookmarks_form_save {
+            get {
+                return ResourceManager.GetString("bookmarks_form_save", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Open in Terminal.
+        /// </summary>
+        public static string bookmarks_open_in_terminal_name {
+            get {
+                return ResourceManager.GetString("bookmarks_open_in_terminal_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to {0} is required.
+        /// </summary>
+        public static string bookmarks_required_placeholder {
+            get {
+                return ResourceManager.GetString("bookmarks_required_placeholder", resourceCulture);
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Properties/Resources.resx

@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="bookmarks_display_name" xml:space="preserve">
+    <value>Bookmarks</value>
+  </data>
+  <data name="bookmarks_add_title" xml:space="preserve">
+    <value>Add a bookmark</value>
+  </data>
+  <data name="bookmarks_edit_name" xml:space="preserve">
+    <value>Edit bookmark</value>
+  </data>
+  <data name="bookmarks_add_name" xml:space="preserve">
+    <value>Add bookmark</value>
+  </data>
+  <data name="bookmarks_delete_title" xml:space="preserve">
+    <value>Delete bookmark</value>
+  </data>
+  <data name="bookmarks_delete_name" xml:space="preserve">
+    <value>Delete</value>
+  </data>
+  <data name="bookmarks_open_in_terminal_name" xml:space="preserve">
+    <value>Open in Terminal</value>
+    <comment>"Terminal" should be the localized name of the Windows Terminal</comment>
+  </data>
+  <data name="bookmarks_form_name_label" xml:space="preserve">
+    <value>Name</value>
+  </data>
+  <data name="bookmarks_form_save" xml:space="preserve">
+    <value>Save</value>
+  </data>
+  <data name="bookmarks_form_open" xml:space="preserve">
+    <value>Open</value>
+  </data>
+  <data name="bookmarks_form_name_required" xml:space="preserve">
+    <value>Name is required</value>
+  </data>
+  <data name="bookmarks_form_bookmark_label" xml:space="preserve">
+    <value>URL or file path</value>
+  </data>
+  <data name="bookmarks_form_bookmark_required" xml:space="preserve">
+    <value>URL or file path is required</value>
+  </data>
+  <data name="bookmarks_required_placeholder" xml:space="preserve">
+    <value>{0} is required</value>
+    <comment>{0} will be replaced by a parameter name provided by the user</comment>
+  </data>
+</root>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/UrlCommand.cs

@@ -0,0 +1,98 @@
+// 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 Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+public partial class UrlCommand : InvokableCommand
+{
+    public string Type { get; }
+
+    public string Url { get; }
+
+    public UrlCommand(BookmarkData data)
+        : this(data.Name, data.Bookmark, data.Type)
+    {
+    }
+
+    public UrlCommand(string name, string url, string type)
+    {
+        Name = name;
+        Type = type;
+        Url = url;
+        Icon = new IconInfo(IconFromUrl(Url, type));
+    }
+
+    public override CommandResult Invoke()
+    {
+        var target = Url;
+        try
+        {
+            var uri = GetUri(target);
+            if (uri != null)
+            {
+                _ = Launcher.LaunchUriAsync(uri);
+            }
+            else
+            {
+                // throw new UriFormatException("The provided URL is not valid.");
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error launching URL: {ex.Message}");
+        }
+
+        return CommandResult.Dismiss();
+    }
+
+    internal static Uri? GetUri(string url)
+    {
+        Uri? uri;
+        if (!Uri.TryCreate(url, UriKind.Absolute, out uri))
+        {
+            if (!Uri.TryCreate("https://" + url, UriKind.Absolute, out uri))
+            {
+                return null;
+            }
+        }
+
+        return uri;
+    }
+
+    internal static string IconFromUrl(string url, string type)
+    {
+        switch (type)
+        {
+            case "file":
+                return "📄";
+            case "folder":
+                return "📁";
+            case "web":
+            default:
+                // Get the base url up to the first placeholder
+                var placeholderIndex = url.IndexOf('{');
+                var baseString = placeholderIndex > 0 ? url.Substring(0, placeholderIndex) : url;
+                try
+                {
+                    var uri = GetUri(baseString);
+                    if (uri != null)
+                    {
+                        var hostname = uri.Host;
+                        var faviconUrl = $"{uri.Scheme}://{hostname}/favicon.ico";
+                        return faviconUrl;
+                    }
+                }
+                catch (UriFormatException)
+                {
+                    // return "🔗";
+                }
+
+                return "🔗";
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Assets/Calculator.svg

@@ -0,0 +1,45 @@
+<svg width="16" height="17" viewBox="0 0 16 17" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.3333 17H2.66667C2.29848 17 2 16.7015 2 16.3333V1.66667C2 1.29848 2.29848 1 2.66667 1H13.3333C13.7015 1 14 1.29848 14 1.66667V16.3333C14 16.7015 13.7015 17 13.3333 17Z" fill="url(#paint0_linear_1825_17892)"/>
+<g filter="url(#filter0_dd_1825_17892)">
+<path d="M12.333 2.33398H3.66634C3.48224 2.33398 3.33301 2.48322 3.33301 2.66732V4.66732C3.33301 4.85141 3.48224 5.00065 3.66634 5.00065H12.333C12.5171 5.00065 12.6663 4.85141 12.6663 4.66732V2.66732C12.6663 2.48322 12.5171 2.33398 12.333 2.33398Z" fill="url(#paint1_linear_1825_17892)"/>
+</g>
+<path d="M5.66634 9.00065H3.66634C3.48224 9.00065 3.33301 8.85141 3.33301 8.66732V6.66732C3.33301 6.48322 3.48224 6.33398 3.66634 6.33398H5.66634C5.85044 6.33398 5.99967 6.48322 5.99967 6.66732V8.66732C5.99967 8.85141 5.85044 9.00065 5.66634 9.00065Z" fill="#CAD2D9"/>
+<path d="M9.00033 9.00065H7.00033C6.81623 9.00065 6.66699 8.85141 6.66699 8.66732V6.66732C6.66699 6.48322 6.81623 6.33398 7.00033 6.33398H9.00033C9.18442 6.33398 9.33366 6.48322 9.33366 6.66732V8.66732C9.33366 8.85141 9.18443 9.00065 9.00033 9.00065Z" fill="#CAD2D9"/>
+<path d="M12.3333 9.00065H10.3333C10.1492 9.00065 10 8.85141 10 8.66732V6.66732C10 6.48322 10.1492 6.33398 10.3333 6.33398H12.3333C12.5174 6.33398 12.6667 6.48322 12.6667 6.66732V8.66732C12.6667 8.85141 12.5174 9.00065 12.3333 9.00065Z" fill="#CAD2D9"/>
+<path d="M5.66634 12.3327H3.66634C3.48224 12.3327 3.33301 12.1834 3.33301 11.9993V9.99935C3.33301 9.81526 3.48224 9.66602 3.66634 9.66602H5.66634C5.85044 9.66602 5.99967 9.81526 5.99967 9.99935V11.9993C5.99967 12.1834 5.85044 12.3327 5.66634 12.3327Z" fill="#CAD2D9"/>
+<path d="M9.00033 12.3327H7.00033C6.81623 12.3327 6.66699 12.1834 6.66699 11.9993V9.99935C6.66699 9.81526 6.81623 9.66602 7.00033 9.66602H9.00033C9.18442 9.66602 9.33366 9.81526 9.33366 9.99935V11.9993C9.33366 12.1834 9.18443 12.3327 9.00033 12.3327Z" fill="#CAD2D9"/>
+<path d="M12.3333 15.666H10.3333C10.1492 15.666 10 15.5168 10 15.3327V9.99935C10 9.81526 10.1492 9.66602 10.3333 9.66602H12.3333C12.5174 9.66602 12.6667 9.81526 12.6667 9.99935V15.3327C12.6667 15.5168 12.5174 15.666 12.3333 15.666Z" fill="url(#paint2_linear_1825_17892)"/>
+<path d="M5.66634 15.6667H3.66634C3.48224 15.6667 3.33301 15.5174 3.33301 15.3333V13.3333C3.33301 13.1492 3.48224 13 3.66634 13H5.66634C5.85044 13 5.99967 13.1492 5.99967 13.3333V15.3333C5.99967 15.5174 5.85044 15.6667 5.66634 15.6667Z" fill="#CAD2D9"/>
+<path d="M9.00033 15.6667H7.00033C6.81623 15.6667 6.66699 15.5174 6.66699 15.3333V13.3333C6.66699 13.1492 6.81623 13 7.00033 13H9.00033C9.18442 13 9.33366 13.1492 9.33366 13.3333V15.3333C9.33366 15.5174 9.18443 15.6667 9.00033 15.6667Z" fill="#CAD2D9"/>
+<defs>
+<filter id="filter0_dd_1825_17892" x="0.333008" y="0.333984" width="15.333" height="8.66602" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset dy="0.5"/>
+<feGaussianBlur stdDeviation="0.5"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.1 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1825_17892"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset dy="1"/>
+<feGaussianBlur stdDeviation="1.5"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
+<feBlend mode="normal" in2="effect1_dropShadow_1825_17892" result="effect2_dropShadow_1825_17892"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect2_dropShadow_1825_17892" result="shape"/>
+</filter>
+<linearGradient id="paint0_linear_1825_17892" x1="12.8421" y1="17.3868" x2="3.15785" y2="0.613153" gradientUnits="userSpaceOnUse">
+<stop stop-color="#626F7A"/>
+<stop offset="1" stop-color="#8B9299"/>
+</linearGradient>
+<linearGradient id="paint1_linear_1825_17892" x1="9.68271" y1="6.58243" x2="6.31664" y2="0.752205" gradientUnits="userSpaceOnUse">
+<stop stop-color="#28AFEA"/>
+<stop offset="0.37387" stop-color="#3CCAF4"/>
+<stop offset="0.74949" stop-color="#4BDFFC"/>
+<stop offset="1" stop-color="#50E6FF"/>
+</linearGradient>
+<linearGradient id="paint2_linear_1825_17892" x1="12.9047" y1="15.3878" x2="9.76194" y2="9.94428" gradientUnits="userSpaceOnUse">
+<stop stop-color="#173A73"/>
+<stop offset="0.55519" stop-color="#134584"/>
+<stop offset="1" stop-color="#114A8B"/>
+</linearGradient>
+</defs>
+</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/CalculatorCommandProvider.cs

@@ -0,0 +1,177 @@
+// 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.Data;
+using System.Globalization;
+using System.Text;
+using Microsoft.CmdPal.Ext.Calc.Properties;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.Calc;
+
+public partial class CalculatorCommandProvider : CommandProvider
+{
+    private readonly ListItem _listItem = new(new CalculatorListPage()) { Subtitle = Resources.calculator_top_level_subtitle };
+    private readonly FallbackCalculatorItem _fallback = new();
+
+    public CalculatorCommandProvider()
+    {
+        Id = "Calculator";
+        DisplayName = Resources.calculator_display_name;
+        Icon = IconHelpers.FromRelativePath("Assets\\Calculator.svg");
+    }
+
+    public override ICommandItem[] TopLevelCommands() => [_listItem];
+
+    public override IFallbackCommandItem[] FallbackCommands() => [_fallback];
+}
+
+// The calculator page is a dynamic list page
+// * The first command is where we display the results. Title=result, Subtitle=query
+//   - The default command is `SaveCommand`.
+//     - When you save, insert into list at spot 1
+//     - change SearchText to the result
+//   - MoreCommands: a single `CopyCommand` to copy the result to the clipboard
+// * The rest of the items are previously saved results
+//   - Command is a CopyCommand
+//   - Each item also sets the TextToSuggest to the result
+[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "This is sample code")]
+public sealed partial class CalculatorListPage : DynamicListPage
+{
+    private readonly List<ListItem> _items = [];
+    private readonly SaveCommand _saveCommand = new();
+    private readonly CopyTextCommand _copyContextCommand;
+    private readonly CommandContextItem _copyContextMenuItem;
+    private static readonly CompositeFormat ErrorMessage = System.Text.CompositeFormat.Parse(Properties.Resources.calculator_error);
+
+    public CalculatorListPage()
+    {
+        Icon = IconHelpers.FromRelativePath("Assets\\Calculator.svg");
+        Name = Resources.calculator_title;
+        PlaceholderText = Resources.calculator_placeholder_text;
+        Id = "com.microsoft.cmdpal.calculator";
+
+        _copyContextCommand = new CopyTextCommand(string.Empty);
+        _copyContextMenuItem = new CommandContextItem(_copyContextCommand);
+
+        _items.Add(new(_saveCommand) { Icon = new IconInfo("\uE94E") });
+
+        UpdateSearchText(string.Empty, string.Empty);
+
+        _saveCommand.SaveRequested += HandleSave;
+    }
+
+    private void HandleSave(object sender, object args)
+    {
+        var lastResult = _items[0].Title;
+        if (!string.IsNullOrEmpty(lastResult))
+        {
+            var li = new ListItem(new CopyTextCommand(lastResult))
+            {
+                Title = _items[0].Title,
+                Subtitle = _items[0].Subtitle,
+                TextToSuggest = lastResult,
+            };
+            _items.Insert(1, li);
+            _items[0].Subtitle = string.Empty;
+            SearchText = lastResult;
+            this.RaiseItemsChanged(this._items.Count);
+        }
+    }
+
+    public override void UpdateSearchText(string oldSearch, string newSearch)
+    {
+        var firstItem = _items[0];
+        if (string.IsNullOrEmpty(newSearch))
+        {
+            firstItem.Title = Resources.calculator_placeholder_text;
+            firstItem.Subtitle = string.Empty;
+            firstItem.MoreCommands = [];
+        }
+        else
+        {
+            _copyContextCommand.Text = ParseQuery(newSearch, out var result) ? result : string.Empty;
+            firstItem.Title = result;
+            firstItem.Subtitle = newSearch;
+            firstItem.MoreCommands = [_copyContextMenuItem];
+        }
+    }
+
+    internal static bool ParseQuery(string equation, out string result)
+    {
+        try
+        {
+            var resultNumber = new DataTable().Compute(equation, null);
+            result = resultNumber.ToString() ?? string.Empty;
+            return true;
+        }
+        catch (Exception e)
+        {
+            result = string.Format(CultureInfo.CurrentCulture, ErrorMessage, e.Message);
+            return false;
+        }
+    }
+
+    public override IListItem[] GetItems() => _items.ToArray();
+}
+
+[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "This is sample code")]
+public sealed partial class SaveCommand : InvokableCommand
+{
+    public event TypedEventHandler<object, object> SaveRequested;
+
+    public SaveCommand()
+    {
+        Name = Resources.calculator_save_command_name;
+    }
+
+    public override ICommandResult Invoke()
+    {
+        SaveRequested?.Invoke(this, this);
+        return CommandResult.KeepOpen();
+    }
+}
+
+[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "This is sample code")]
+internal sealed partial class FallbackCalculatorItem : FallbackCommandItem
+{
+    private readonly CopyTextCommand _copyCommand = new(string.Empty);
+    private static readonly IconInfo _cachedIcon = IconHelpers.FromRelativePath("Assets\\Calculator.svg");
+
+    public FallbackCalculatorItem()
+        : base(new NoOpCommand(), Resources.calculator_title)
+    {
+        Command = _copyCommand;
+        _copyCommand.Name = string.Empty;
+        Title = string.Empty;
+        Subtitle = Resources.calculator_placeholder_text;
+        Icon = _cachedIcon;
+    }
+
+    public override void UpdateQuery(string query)
+    {
+        if (CalculatorListPage.ParseQuery(query, out var result))
+        {
+            _copyCommand.Text = result;
+            _copyCommand.Name = string.IsNullOrWhiteSpace(query) ? string.Empty : Resources.calculator_copy_command_name;
+            Title = result;
+
+            // we have to make the subtitle the equation,
+            // so that we will still string match the original query
+            // Otherwise, something like 1+2 will have a title of "3" and not match
+            Subtitle = query;
+        }
+        else
+        {
+            _copyCommand.Text = string.Empty;
+            _copyCommand.Name = string.Empty;
+            Title = string.Empty;
+            Subtitle = string.Empty;
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <PropertyGroup>
+    <RootNamespace>Microsoft.CmdPal.Ext.Calc</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <!-- MRT from windows app sdk will search for a pri file with the same name of the module before defaulting to resources.pri -->
+    <ProjectPriFileName>Microsoft.CmdPal.Ext.Calc.pri</ProjectPriFileName>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Properties\Resources.Designer.cs">
+      <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Remove="Assets\Calculator.svg" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Update="Assets\Calculator.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Update="Assets\Calculator.svg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Update="Properties\Resources.resx">
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <Generator>PublicResXFileCodeGenerator</Generator>
+    </EmbeddedResource>
+  </ItemGroup>
+
+</Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Properties/Resources.Designer.cs

@@ -0,0 +1,126 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.CmdPal.Ext.Calc.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.CmdPal.Ext.Calc.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Copy.
+        /// </summary>
+        public static string calculator_copy_command_name {
+            get {
+                return ResourceManager.GetString("calculator_copy_command_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Calculator.
+        /// </summary>
+        public static string calculator_display_name {
+            get {
+                return ResourceManager.GetString("calculator_display_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Error: {0}.
+        /// </summary>
+        public static string calculator_error {
+            get {
+                return ResourceManager.GetString("calculator_error", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Type an equation....
+        /// </summary>
+        public static string calculator_placeholder_text {
+            get {
+                return ResourceManager.GetString("calculator_placeholder_text", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Save.
+        /// </summary>
+        public static string calculator_save_command_name {
+            get {
+                return ResourceManager.GetString("calculator_save_command_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Calculator.
+        /// </summary>
+        public static string calculator_title {
+            get {
+                return ResourceManager.GetString("calculator_title", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Press = to type an equation.
+        /// </summary>
+        public static string calculator_top_level_subtitle {
+            get {
+                return ResourceManager.GetString("calculator_top_level_subtitle", resourceCulture);
+            }
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Properties/Resources.resx

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="calculator_display_name" xml:space="preserve">
+    <value>Calculator</value>
+  </data>
+  <data name="calculator_title" xml:space="preserve">
+    <value>Calculator</value>
+  </data>
+  <data name="calculator_top_level_subtitle" xml:space="preserve">
+    <value>Press = to type an equation</value>
+    <comment>{Locked="="}</comment>
+  </data>
+  <data name="calculator_placeholder_text" xml:space="preserve">
+    <value>Type an equation...</value>
+  </data>
+  <data name="calculator_error" xml:space="preserve">
+    <value>Error: {0}</value>
+    <comment>{0} will be replaced by an error message from an invalid equation</comment>
+  </data>
+  <data name="calculator_save_command_name" xml:space="preserve">
+    <value>Save</value>
+  </data>
+  <data name="calculator_copy_command_name" xml:space="preserve">
+    <value>Copy</value>
+  </data>
+</root>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/ClipboardHistoryCommandsProvider.cs

@@ -0,0 +1,32 @@
+// 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.ClipboardHistory.Pages;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory;
+
+public partial class ClipboardHistoryCommandsProvider : CommandProvider
+{
+    private readonly ListItem _clipboardHistoryListItem;
+
+    public ClipboardHistoryCommandsProvider()
+    {
+        _clipboardHistoryListItem = new ListItem(new ClipboardHistoryListPage())
+        {
+            Title = "Search Clipboard History",
+            Icon = new IconInfo("\xE8C8"), // Copy icon
+        };
+
+        DisplayName = $"Clipboard History";
+        Icon = new IconInfo("\xE8C8"); // Copy icon
+        Id = "Windows.ClipboardHistory";
+    }
+
+    public override IListItem[] TopLevelCommands()
+    {
+        return [_clipboardHistoryListItem];
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Commands/CopyCommand.cs

@@ -0,0 +1,35 @@
+// 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.ClipboardHistory.Models;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Commands;
+
+internal sealed partial class CopyCommand : InvokableCommand
+{
+    private readonly ClipboardItem _clipboardItem;
+    private readonly ClipboardFormat _clipboardFormat;
+
+    internal CopyCommand(ClipboardItem clipboardItem, ClipboardFormat clipboardFormat)
+    {
+        _clipboardItem = clipboardItem;
+        _clipboardFormat = clipboardFormat;
+        Name = "Copy";
+        if (clipboardFormat == ClipboardFormat.Text)
+        {
+            Icon = new("\xE8C8"); // Copy icon
+        }
+        else
+        {
+            Icon = new("\xE8B9"); // Picture icon
+        }
+    }
+
+    public override CommandResult Invoke()
+    {
+        ClipboardHelper.SetClipboardContent(_clipboardItem, _clipboardFormat);
+        return CommandResult.ShowToast("Copied to clipboard");
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Commands/PasteCommand.cs

@@ -0,0 +1,44 @@
+// 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 CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.Common.Messages;
+using Microsoft.CmdPal.Ext.ClipboardHistory.Models;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+using Windows.ApplicationModel.DataTransfer;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Commands;
+
+internal sealed partial class PasteCommand : InvokableCommand
+{
+    private readonly ClipboardItem _clipboardItem;
+    private readonly ClipboardFormat _clipboardFormat;
+
+    internal PasteCommand(ClipboardItem clipboardItem, ClipboardFormat clipboardFormat)
+    {
+        _clipboardItem = clipboardItem;
+        _clipboardFormat = clipboardFormat;
+        Name = "Paste";
+        Icon = new("\xE8C8"); // Copy icon
+    }
+
+    private void HideWindow()
+    {
+        // TODO GH #524: This isn't great - this requires us to have Secret Sauce in
+        // the clipboard extension to be able to manipulate the HWND.
+        // We probably need to put some window manipulation into the API, but
+        // what form that takes is not clear yet.
+        WeakReferenceMessenger.Default.Send<HideWindowMessage>(new());
+    }
+
+    public override CommandResult Invoke()
+    {
+        ClipboardHelper.SetClipboardContent(_clipboardItem, _clipboardFormat);
+        HideWindow();
+        ClipboardHelper.SendPasteKeyCombination();
+        Clipboard.DeleteItemFromHistory(_clipboardItem.Item);
+        return CommandResult.ShowToast("Pasting");
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Helpers/ClipboardHelper.cs

@@ -0,0 +1,262 @@
+// 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.Linq;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.ClipboardHistory.Helpers;
+using Microsoft.CmdPal.Ext.ClipboardHistory.Models;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Data.Html;
+using Windows.Graphics.Imaging;
+using Windows.Storage;
+using Windows.Storage.Streams;
+using Windows.System;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory;
+
+internal static class ClipboardHelper
+{
+    private static readonly HashSet<string> ImageFileTypes = new(StringComparer.InvariantCultureIgnoreCase) { ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".ico", ".svg" };
+
+    private static readonly (string DataFormat, ClipboardFormat ClipboardFormat)[] DataFormats =
+    [
+        (StandardDataFormats.Text, ClipboardFormat.Text),
+        (StandardDataFormats.Html, ClipboardFormat.Html),
+        (StandardDataFormats.Bitmap, ClipboardFormat.Image),
+    ];
+
+    internal static async Task<ClipboardFormat> GetAvailableClipboardFormatsAsync(DataPackageView clipboardData)
+    {
+        var availableClipboardFormats = DataFormats.Aggregate(
+            ClipboardFormat.None,
+            (result, formatPair) => clipboardData.Contains(formatPair.DataFormat) ? (result | formatPair.ClipboardFormat) : result);
+
+        if (clipboardData.Contains(StandardDataFormats.StorageItems))
+        {
+            var storageItems = await clipboardData.GetStorageItemsAsync();
+
+            if (storageItems.Count == 1 && storageItems.Single() is StorageFile file && ImageFileTypes.Contains(file.FileType))
+            {
+                availableClipboardFormats |= ClipboardFormat.ImageFile;
+            }
+        }
+
+        return availableClipboardFormats;
+    }
+
+    internal static void SetClipboardTextContent(string text)
+    {
+        if (!string.IsNullOrEmpty(text))
+        {
+            DataPackage output = new();
+            output.SetText(text);
+            try
+            {
+                // Clipboard.SetContentWithOptions(output, null);
+                Clipboard.SetContent(output);
+                Flush();
+                ExtensionHost.LogMessage(new LogMessage() { Message = "Copied text to clipboard" });
+            }
+            catch (COMException ex)
+            {
+                ExtensionHost.LogMessage($"Error: {ex.HResult}\n{ex.Source}\n{ex.StackTrace}");
+            }
+        }
+    }
+
+    private static bool Flush()
+    {
+        // TODO(stefan): For some reason Flush() fails from time to time when directly activated via hotkey.
+        // Calling inside a loop makes it work.
+        // Exception is: The operation is not permitted because the calling application is not the owner of the data on the clipboard.
+        const int maxAttempts = 5;
+        for (var i = 1; i <= maxAttempts; i++)
+        {
+            try
+            {
+                Task.Run(Clipboard.Flush).Wait();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                if (i == maxAttempts)
+                {
+                    ExtensionHost.LogMessage(new LogMessage()
+                    {
+                        Message = $"{nameof(Clipboard)}.{nameof(Flush)}() failed: {ex}",
+                    });
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static async Task<bool> FlushAsync() => await Task.Run(Flush);
+
+    internal static async Task SetClipboardFileContentAsync(string fileName)
+    {
+        var storageFile = await StorageFile.GetFileFromPathAsync(fileName);
+
+        DataPackage output = new();
+        output.SetStorageItems([storageFile]);
+        Clipboard.SetContent(output);
+
+        await FlushAsync();
+    }
+
+    internal static void SetClipboardImageContent(RandomAccessStreamReference image)
+    {
+        ExtensionHost.LogMessage(new LogMessage() { Message = "Copied image to clipboard" });
+
+        if (image is not null)
+        {
+            DataPackage output = new();
+            output.SetBitmap(image);
+            Clipboard.SetContentWithOptions(output, null);
+
+            Flush();
+        }
+    }
+
+    internal static void SetClipboardContent(ClipboardItem clipboardItem, ClipboardFormat clipboardFormat)
+    {
+        switch (clipboardFormat)
+        {
+            case ClipboardFormat.Text:
+                if (clipboardItem.Content == null)
+                {
+                    ExtensionHost.LogMessage(new LogMessage() { Message = "No valid clipboard content" });
+                    return;
+                }
+                else
+                {
+                    SetClipboardTextContent(clipboardItem.Content);
+                }
+
+                break;
+
+            case ClipboardFormat.Image:
+                if (clipboardItem.ImageData == null)
+                {
+                    ExtensionHost.LogMessage(new LogMessage() { Message = "No valid clipboard content" });
+                    return;
+                }
+                else
+                {
+                    SetClipboardImageContent(clipboardItem.ImageData);
+                }
+
+                break;
+
+            default:
+                ExtensionHost.LogMessage(new LogMessage { Message = "Unsupported clipboard format." });
+                break;
+        }
+    }
+
+    // Function to send a single key event
+    private static void SendSingleKeyboardInput(short keyCode, uint keyStatus)
+    {
+        var ignoreKeyEventFlag = (UIntPtr)0x5555;
+
+        var inputShift = new NativeMethods.INPUT
+        {
+            type = NativeMethods.INPUTTYPE.INPUT_KEYBOARD,
+            data = new NativeMethods.InputUnion
+            {
+                ki = new NativeMethods.KEYBDINPUT
+                {
+                    wVk = keyCode,
+                    dwFlags = keyStatus,
+
+                    // Any keyevent with the extraInfo set to this value will be ignored by the keyboard hook and sent to the system instead.
+                    dwExtraInfo = ignoreKeyEventFlag,
+                },
+            },
+        };
+
+        var inputs = new NativeMethods.INPUT[] { inputShift };
+        _ = NativeMethods.SendInput(1, inputs, NativeMethods.INPUT.Size);
+    }
+
+    internal static void SendPasteKeyCombination()
+    {
+        ExtensionHost.LogMessage(new LogMessage() { Message = "Sending paste keys..." });
+
+        SendSingleKeyboardInput((short)VirtualKey.LeftControl, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.RightControl, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.LeftWindows, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.RightWindows, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.LeftShift, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.RightShift, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.LeftMenu, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.RightMenu, (uint)NativeMethods.KeyEventF.KeyUp);
+
+        // Send Ctrl + V
+        SendSingleKeyboardInput((short)VirtualKey.Control, (uint)NativeMethods.KeyEventF.KeyDown);
+        SendSingleKeyboardInput((short)VirtualKey.V, (uint)NativeMethods.KeyEventF.KeyDown);
+        SendSingleKeyboardInput((short)VirtualKey.V, (uint)NativeMethods.KeyEventF.KeyUp);
+        SendSingleKeyboardInput((short)VirtualKey.Control, (uint)NativeMethods.KeyEventF.KeyUp);
+
+        ExtensionHost.LogMessage(new LogMessage() { Message = "Paste sent" });
+    }
+
+    internal static async Task<string> GetClipboardTextOrHtmlTextAsync(DataPackageView clipboardData)
+    {
+        if (clipboardData.Contains(StandardDataFormats.Text))
+        {
+            return await clipboardData.GetTextAsync();
+        }
+        else if (clipboardData.Contains(StandardDataFormats.Html))
+        {
+            var html = await clipboardData.GetHtmlFormatAsync();
+            return HtmlUtilities.ConvertToText(html);
+        }
+        else
+        {
+            return string.Empty;
+        }
+    }
+
+    internal static async Task<string> GetClipboardHtmlContentAsync(DataPackageView clipboardData) =>
+        clipboardData.Contains(StandardDataFormats.Html) ? await clipboardData.GetHtmlFormatAsync() : string.Empty;
+
+    internal static async Task<SoftwareBitmap?> GetClipboardImageContentAsync(DataPackageView clipboardData)
+    {
+        using var stream = await GetClipboardImageStreamAsync(clipboardData);
+        if (stream != null)
+        {
+            var decoder = await BitmapDecoder.CreateAsync(stream);
+            return await decoder.GetSoftwareBitmapAsync();
+        }
+
+        return null;
+    }
+
+    private static async Task<IRandomAccessStream?> GetClipboardImageStreamAsync(DataPackageView clipboardData)
+    {
+        if (clipboardData.Contains(StandardDataFormats.StorageItems))
+        {
+            var storageItems = await clipboardData.GetStorageItemsAsync();
+            var file = storageItems.Count == 1 ? storageItems[0] as StorageFile : null;
+            if (file != null)
+            {
+                return await file.OpenReadAsync();
+            }
+        }
+
+        if (clipboardData.Contains(StandardDataFormats.Bitmap))
+        {
+            var bitmap = await clipboardData.GetBitmapAsync();
+            return await bitmap.OpenReadAsync();
+        }
+
+        return null;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Helpers/NativeMethods.cs

@@ -0,0 +1,101 @@
+// 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.Runtime.InteropServices;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Helpers;
+
+internal static class NativeMethods
+{
+    [StructLayout(LayoutKind.Sequential)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+    internal struct INPUT
+    {
+        internal INPUTTYPE type;
+        internal InputUnion data;
+
+        internal static int Size => Marshal.SizeOf(typeof(INPUT));
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+    internal struct InputUnion
+    {
+        [FieldOffset(0)]
+        internal MOUSEINPUT mi;
+        [FieldOffset(0)]
+        internal KEYBDINPUT ki;
+        [FieldOffset(0)]
+        internal HARDWAREINPUT hi;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+    internal struct MOUSEINPUT
+    {
+        internal int dx;
+        internal int dy;
+        internal int mouseData;
+        internal uint dwFlags;
+        internal uint time;
+        internal UIntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+    internal struct KEYBDINPUT
+    {
+        internal short wVk;
+        internal short wScan;
+        internal uint dwFlags;
+        internal int time;
+        internal UIntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1307:Accessible fields should begin with upper-case letter", Justification = "Matching Native Structure")]
+    internal struct HARDWAREINPUT
+    {
+        internal int uMsg;
+        internal short wParamL;
+        internal short wParamH;
+    }
+
+    internal enum INPUTTYPE : uint
+    {
+        INPUT_MOUSE = 0,
+        INPUT_KEYBOARD = 1,
+        INPUT_HARDWARE = 2,
+    }
+
+    [Flags]
+    internal enum KeyEventF
+    {
+        KeyDown = 0x0000,
+        ExtendedKey = 0x0001,
+        KeyUp = 0x0002,
+        Unicode = 0x0004,
+        Scancode = 0x0008,
+    }
+
+    [DllImport("user32.dll")]
+    internal static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
+    internal static extern short GetAsyncKeyState(int vKey);
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PointInter
+    {
+        public int X;
+        public int Y;
+
+        public static explicit operator Point(PointInter point) => new(point.X, point.Y);
+    }
+
+    [DllImport("user32.dll")]
+    internal static extern bool GetCursorPos(out PointInter lpPoint);
+}

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

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <PropertyGroup>
+    <RootNamespace>Microsoft.CmdPal.Ext.ClipboardHistory</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+	  <Nullable>enable</Nullable> 
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Microsoft.CmdPal.Common\Microsoft.CmdPal.Common.csproj" />
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Mvvm" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Models/ClipboardFormat.cs

@@ -0,0 +1,18 @@
+// 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;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Models;
+
+[Flags]
+public enum ClipboardFormat
+{
+    None,
+    Text = 1 << 0,
+    Html = 1 << 1,
+    Audio = 1 << 2,
+    Image = 1 << 3,
+    ImageFile = 1 << 4,
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Models/ClipboardItem.cs

@@ -0,0 +1,145 @@
+// 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.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CmdPal.Ext.ClipboardHistory.Commands;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Models;
+
+public class ClipboardItem
+{
+    public string? Content { get; set; }
+
+    public required ClipboardHistoryItem Item { get; set; }
+
+    public DateTimeOffset Timestamp => Item?.Timestamp ?? DateTimeOffset.MinValue;
+
+    public RandomAccessStreamReference? ImageData { get; set; }
+
+    public string GetDataType()
+    {
+        // Check if there is valid image data
+        if (IsImage)
+        {
+            return "Image";
+        }
+
+        // Check if there is valid text content
+        return IsText ? "Text" : "Unknown";
+    }
+
+    [MemberNotNullWhen(true, nameof(ImageData))]
+    private bool IsImage => ImageData != null;
+
+    [MemberNotNullWhen(true, nameof(Content))]
+    private bool IsText => !string.IsNullOrEmpty(Content);
+
+    public static List<string> ShiftLinesLeft(List<string> lines)
+    {
+        // Determine the minimum leading whitespace
+        var minLeadingWhitespace = lines
+            .Where(line => !string.IsNullOrWhiteSpace(line))
+            .Min(line => line.TakeWhile(char.IsWhiteSpace).Count());
+
+        // Check if all lines have at least that much leading whitespace
+        if (lines.Any(line => line.TakeWhile(char.IsWhiteSpace).Count() < minLeadingWhitespace))
+        {
+            return lines; // Return the original lines if any line doesn't have enough leading whitespace
+        }
+
+        // Remove the minimum leading whitespace from each line
+        var shiftedLines = lines.Select(line => line.Substring(minLeadingWhitespace)).ToList();
+
+        return shiftedLines;
+    }
+
+    public static List<string> StripLeadingWhitespace(List<string> lines)
+    {
+        // Determine the minimum leading whitespace
+        var minLeadingWhitespace = lines
+            .Min(line => line.TakeWhile(char.IsWhiteSpace).Count());
+
+        // Remove the minimum leading whitespace from each line
+        var shiftedLines = lines.Select(line =>
+            line.Length >= minLeadingWhitespace
+            ? line.Substring(minLeadingWhitespace)
+            : line).ToList();
+
+        return shiftedLines;
+    }
+
+    public ListItem ToListItem()
+    {
+        ListItem listItem;
+
+        List<DetailsElement> metadata = [];
+        metadata.Add(new DetailsElement()
+        {
+            Key = "Copied on",
+            Data = new DetailsLink(Item.Timestamp.DateTime.ToString(DateTimeFormatInfo.CurrentInfo)),
+        });
+
+        if (IsImage)
+        {
+            var iconData = new IconData(ImageData);
+            var heroImage = new IconInfo(iconData, iconData);
+            listItem = new(new CopyCommand(this, ClipboardFormat.Image))
+            {
+                // Placeholder subtitle as there’s no BitmapImage dimensions to retrieve
+                Title = "Image Data",
+                Details = new Details()
+                {
+                    HeroImage = heroImage,
+                    Title = GetDataType(),
+                    Body = Timestamp.ToString(CultureInfo.InvariantCulture),
+                    Metadata = metadata.ToArray(),
+                },
+                MoreCommands = [
+                    new CommandContextItem(new PasteCommand(this, ClipboardFormat.Image))
+                ],
+            };
+        }
+        else if (IsText)
+        {
+            var splitContent = Content.Split("\n");
+            var head = splitContent.AsSpan(0, Math.Min(3, splitContent.Length)).ToArray().ToList();
+            var preview2 = string.Join(
+                "\n",
+                StripLeadingWhitespace(head));
+
+            listItem = new(new CopyCommand(this, ClipboardFormat.Text))
+            {
+                Title = preview2,
+
+                Details = new Details
+                {
+                    Title = GetDataType(),
+                    Body = $"```text\n{Content}\n```",
+                    Metadata = metadata.ToArray(),
+                },
+                MoreCommands = [
+                                new CommandContextItem(new PasteCommand(this, ClipboardFormat.Text)),
+                            ],
+            };
+        }
+        else
+        {
+            listItem = new(new NoOpCommand())
+            {
+                Title = "Unknown",
+                Subtitle = GetDataType(),
+                Details = new Details { Title = GetDataType() },
+            };
+        }
+
+        return listItem;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Pages/ClipboardHistoryListPage.cs

@@ -0,0 +1,154 @@
+// 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.Collections.ObjectModel;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CmdPal.Ext.ClipboardHistory.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.Win32;
+using Windows.ApplicationModel.DataTransfer;
+
+namespace Microsoft.CmdPal.Ext.ClipboardHistory.Pages;
+
+internal sealed partial class ClipboardHistoryListPage : ListPage
+{
+    private readonly ObservableCollection<ClipboardItem> clipboardHistory;
+    private readonly string _defaultIconPath;
+
+    public ClipboardHistoryListPage()
+    {
+        clipboardHistory = [];
+        _defaultIconPath = string.Empty;
+        Icon = new("\uF0E3"); // ClipboardList icon
+        Name = "Clipboard History";
+        Id = "com.microsoft.cmdpal.clipboardHistory";
+        ShowDetails = true;
+
+        Clipboard.HistoryChanged += TrackClipboardHistoryChanged_EventHandler;
+    }
+
+    private void TrackClipboardHistoryChanged_EventHandler(object? sender, ClipboardHistoryChangedEventArgs? e) => RaiseItemsChanged(0);
+
+    private bool IsClipboardHistoryEnabled()
+    {
+        var registryKey = @"HKEY_CURRENT_USER\Software\Microsoft\Clipboard\";
+        try
+        {
+            var enableClipboardHistory = (int)(Registry.GetValue(registryKey, "EnableClipboardHistory", false) ?? 0);
+            return enableClipboardHistory != 0;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    private bool IsClipboardHistoryDisabledByGPO()
+    {
+        var registryKey = @"HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\System\";
+        try
+        {
+            var allowClipboardHistory = Registry.GetValue(registryKey, "AllowClipboardHistory", null);
+            return allowClipboardHistory != null ? (int)allowClipboardHistory == 0 : false;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    private async Task LoadClipboardHistoryAsync()
+    {
+        try
+        {
+            List<ClipboardItem> items = [];
+
+            if (!Clipboard.IsHistoryEnabled())
+            {
+                return;
+            }
+
+            var historyItems = await Clipboard.GetHistoryItemsAsync();
+            if (historyItems.Status != ClipboardHistoryItemsResultStatus.Success)
+            {
+                return;
+            }
+
+            foreach (var item in historyItems.Items)
+            {
+                if (item.Content.Contains(StandardDataFormats.Text))
+                {
+                    var text = await item.Content.GetTextAsync();
+                    items.Add(new ClipboardItem { Content = text, Item = item });
+                }
+                else if (item.Content.Contains(StandardDataFormats.Bitmap))
+                {
+                    items.Add(new ClipboardItem { Item = item });
+                }
+            }
+
+            clipboardHistory.Clear();
+
+            foreach (var item in items)
+            {
+                if (item.Item.Content.Contains(StandardDataFormats.Bitmap))
+                {
+                    var imageReceived = await item.Item.Content.GetBitmapAsync();
+
+                    if (imageReceived != null)
+                    {
+                        item.ImageData = imageReceived;
+                    }
+                }
+
+                clipboardHistory.Add(item);
+            }
+        }
+        catch (Exception ex)
+        {
+            // TODO GH #108 We need to figure out some logging
+            // Logger.LogError("Loading clipboard history failed", ex);
+            ExtensionHost.ShowStatus(new StatusMessage() { Message = "Loading clipboard history failed", State = MessageState.Error }, StatusContext.Page);
+            ExtensionHost.LogMessage(ex.ToString());
+        }
+    }
+
+    private void LoadClipboardHistoryInSTA()
+    {
+        // https://github.com/microsoft/windows-rs/issues/317
+        // Clipboard API needs to be called in STA or it
+        // hangs.
+        var thread = new Thread(() =>
+        {
+            var t = LoadClipboardHistoryAsync();
+            t.ConfigureAwait(false);
+            t.Wait();
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+    }
+
+    private ListItem[] GetClipboardHistoryListItems()
+    {
+        LoadClipboardHistoryInSTA();
+        List<ListItem> listItems = [];
+        for (var i = 0; i < clipboardHistory.Count; i++)
+        {
+            var item = clipboardHistory[i];
+            if (item != null)
+            {
+                listItems.Add(item.ToListItem());
+            }
+        }
+
+        return listItems.ToArray();
+    }
+
+    public override IListItem[] GetItems() => GetClipboardHistoryListItems();
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Assets/FileExplorer.svg

@@ -0,0 +1,93 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1825_18138)">
+<path d="M8.3125 3L7.47871 1.89974C7.26684 1.62016 6.9931 1.39344 6.67896 1.23734C6.36481 1.08125 6.01879 1.00001 5.668 1H1C0.734784 1 0.48043 1.10536 0.292893 1.29289C0.105357 1.48043 0 1.73478 0 2L0 12C0.00155124 12.53 0.212763 13.0378 0.5875 13.4125C0.962237 13.7872 1.47004 13.9984 2 14H14C14.53 13.9984 15.0378 13.7872 15.4125 13.4125C15.7872 13.0378 15.9984 12.53 16 12V4C16 3.73478 15.8946 3.48043 15.7071 3.29289C15.5196 3.10536 15.2652 3 15 3H8.3125Z" fill="url(#paint0_linear_1825_18138)"/>
+<mask id="mask0_1825_18138" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="1" width="16" height="13">
+<path d="M8.3125 3L7.47871 1.89974C7.26684 1.62016 6.9931 1.39344 6.67896 1.23734C6.36481 1.08125 6.01879 1.00001 5.668 1H1C0.734784 1 0.48043 1.10536 0.292893 1.29289C0.105357 1.48043 0 1.73478 0 2L0 12C0.00155124 12.53 0.212763 13.0378 0.5875 13.4125C0.962237 13.7872 1.47004 13.9984 2 14H14C14.53 13.9984 15.0378 13.7872 15.4125 13.4125C15.7872 13.0378 15.9984 12.53 16 12V4C16 3.73478 15.8946 3.48043 15.7071 3.29289C15.5196 3.10536 15.2652 3 15 3H8.3125Z" fill="url(#paint1_linear_1825_18138)"/>
+</mask>
+<g mask="url(#mask0_1825_18138)">
+<g filter="url(#filter0_dd_1825_18138)">
+<path d="M14.9985 5.00187H10L8 5.00172C7.62917 5.19449 6.41839 4.9973 6.00047 5.00171H1.00151C0.868112 4.99367 0.734525 5.01401 0.609573 5.06142C0.484622 5.10882 0.37115 5.18219 0.276655 5.27669C0.18216 5.37119 0.108792 5.48467 0.061398 5.60962C0.0140044 5.73458 -0.00633622 5.86817 0.00172002 6.00156V13.9986C-0.00634109 14.132 0.0139961 14.2656 0.0613881 14.3905C0.10878 14.5155 0.182148 14.6289 0.276644 14.7234C0.37114 14.8179 0.484614 14.8913 0.609568 14.9387C0.734521 14.9861 0.868111 15.0065 1.00151 14.9984H14.9985C15.1319 15.0065 15.2655 14.9861 15.3904 14.9387C15.5154 14.8913 15.6289 14.8179 15.7234 14.7234C15.8178 14.6289 15.8912 14.5155 15.9386 14.3905C15.986 14.2655 16.0064 14.132 15.9983 13.9986V6.00171C16.0064 5.86832 15.986 5.73473 15.9386 5.60977C15.8912 5.48481 15.8179 5.37134 15.7234 5.27683C15.6289 5.18233 15.5154 5.10896 15.3905 5.06156C15.2655 5.01416 15.1319 4.99382 14.9985 5.00187Z" fill="url(#paint2_linear_1825_18138)"/>
+</g>
+</g>
+<path d="M14.9985 4.00172H8.2L7.20022 4.70161C6.82939 4.89438 6.41839 4.99714 6.00047 5.00156H1.00151C0.868112 4.99351 0.734525 5.01386 0.609573 5.06126C0.484622 5.10866 0.37115 5.18203 0.276655 5.27654C0.18216 5.37104 0.108792 5.48451 0.061398 5.60947C0.0140044 5.73442 -0.00633622 5.86801 0.00172002 6.00141V13.9984C-0.00634109 14.1318 0.0139961 14.2654 0.0613881 14.3904C0.10878 14.5153 0.182148 14.6288 0.276644 14.7233C0.37114 14.8178 0.484614 14.8912 0.609568 14.9386C0.734521 14.986 0.868111 15.0063 1.00151 14.9983H14.9985C15.1319 15.0063 15.2655 14.9859 15.3904 14.9385C15.5154 14.8911 15.6289 14.8178 15.7234 14.7233C15.8178 14.6288 15.8912 14.5153 15.9386 14.3903C15.986 14.2654 16.0064 14.1318 15.9983 13.9984V5.00156C16.0064 4.86816 15.986 4.73457 15.9386 4.60961C15.8912 4.48466 15.8179 4.37118 15.7234 4.27668C15.6289 4.18218 15.5154 4.1088 15.3905 4.0614C15.2655 4.01401 15.1319 3.99366 14.9985 4.00172H14.9985Z" fill="url(#paint3_linear_1825_18138)"/>
+<path opacity="0.25" d="M15.7017 4.30036C15.6137 4.20263 15.5056 4.1252 15.3847 4.0734C15.2638 4.0216 15.1332 3.99668 15.0017 4.00036H8.20172L7.20172 4.70036C6.83081 4.89316 6.41972 4.99594 6.00172 5.00036H1.00172C0.868297 4.9923 0.734682 5.01264 0.609705 5.06005C0.484727 5.10745 0.371231 5.18083 0.276715 5.27535C0.182198 5.36987 0.108814 5.48336 0.0614098 5.60834C0.0140056 5.73332 -0.00633928 5.86693 0.00171929 6.00036V7.00036C-0.00634091 6.86693 0.0140029 6.73332 0.0614065 6.60834C0.10881 6.48336 0.182194 6.36986 0.276711 6.27535C0.371227 6.18083 0.484724 6.10745 0.609703 6.06004C0.734681 6.01264 0.868296 5.9923 1.00172 6.00036H6.00172C6.60283 5.98827 7.18978 5.81563 7.70172 5.50036L8.50172 5.00036H15.0017C15.1351 4.9923 15.2688 5.01265 15.3937 5.06006C15.5187 5.10746 15.6322 5.18085 15.7267 5.27536C15.8212 5.36988 15.8946 5.48337 15.942 5.60835C15.9894 5.73332 16.0098 5.86693 16.0017 6.00036V5.00036C16.0054 4.86891 15.9805 4.73823 15.9287 4.61736C15.8769 4.49649 15.7995 4.38833 15.7017 4.30036Z" fill="url(#paint4_linear_1825_18138)"/>
+<mask id="mask1_1825_18138" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="4" width="16" height="11">
+<path d="M14.9985 4.00172H8.2L7.20022 4.70161C6.82939 4.89438 6.41839 4.99714 6.00047 5.00156H1.00151C0.868112 4.99351 0.734525 5.01386 0.609573 5.06126C0.484622 5.10866 0.37115 5.18203 0.276655 5.27654C0.18216 5.37104 0.108792 5.48451 0.061398 5.60947C0.0140044 5.73442 -0.00633622 5.86801 0.00172002 6.00141V13.9984C-0.00634109 14.1318 0.0139961 14.2654 0.0613881 14.3904C0.10878 14.5153 0.182148 14.6288 0.276644 14.7233C0.37114 14.8178 0.484614 14.8912 0.609568 14.9386C0.734521 14.986 0.868111 15.0063 1.00151 14.9983H14.9985C15.1319 15.0063 15.2655 14.9859 15.3904 14.9385C15.5154 14.8911 15.6289 14.8178 15.7234 14.7233C15.8178 14.6288 15.8912 14.5153 15.9386 14.3903C15.986 14.2654 16.0064 14.1318 15.9983 13.9984V5.00156C16.0064 4.86816 15.986 4.73457 15.9386 4.60961C15.8912 4.48466 15.8179 4.37118 15.7234 4.27668C15.6289 4.18218 15.5154 4.1088 15.3905 4.0614C15.2655 4.01401 15.1319 3.99366 14.9985 4.00172H14.9985Z" fill="url(#paint5_linear_1825_18138)"/>
+</mask>
+<g mask="url(#mask1_1825_18138)">
+<g filter="url(#filter1_dd_1825_18138)">
+<path d="M5 10H11C11.5304 10 12.0391 10.2107 12.4142 10.5858C12.7893 10.9609 13 11.4696 13 12V15H3V12C3 11.4696 3.21071 10.9609 3.58579 10.5858C3.96086 10.2107 4.46957 10 5 10Z" fill="url(#paint6_linear_1825_18138)"/>
+</g>
+</g>
+<path d="M5 10H11C11.5304 10 12.0391 10.2107 12.4142 10.5858C12.7893 10.9609 13 11.4696 13 12V15H3V12C3 11.4696 3.21071 10.9609 3.58579 10.5858C3.96086 10.2107 4.46957 10 5 10Z" fill="url(#paint7_linear_1825_18138)"/>
+<path d="M10.5 12H5.5C5.22386 12 5 12.2239 5 12.5C5 12.7761 5.22386 13 5.5 13H10.5C10.7761 13 11 12.7761 11 12.5C11 12.2239 10.7761 12 10.5 12Z" fill="#114A8B"/>
+</g>
+<defs>
+<filter id="filter0_dd_1825_18138" x="-1" y="4" width="18" height="12" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="0.166667"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.1 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1825_18138"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="0.5"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
+<feBlend mode="normal" in2="effect1_dropShadow_1825_18138" result="effect2_dropShadow_1825_18138"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect2_dropShadow_1825_18138" result="shape"/>
+</filter>
+<filter id="filter1_dd_1825_18138" x="2" y="9" width="12" height="7" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="0.166667"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.1 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_1825_18138"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
+<feOffset/>
+<feGaussianBlur stdDeviation="0.5"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.2 0"/>
+<feBlend mode="normal" in2="effect1_dropShadow_1825_18138" result="effect2_dropShadow_1825_18138"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect2_dropShadow_1825_18138" result="shape"/>
+</filter>
+<linearGradient id="paint0_linear_1825_18138" x1="11.4683" y1="14.139" x2="4.1515" y2="1.4659" gradientUnits="userSpaceOnUse">
+<stop offset="0.1135" stop-color="#D18B00"/>
+<stop offset="0.6162" stop-color="#E09F00"/>
+</linearGradient>
+<linearGradient id="paint1_linear_1825_18138" x1="11.4683" y1="14.139" x2="4.1515" y2="1.4659" gradientUnits="userSpaceOnUse">
+<stop offset="0.1135" stop-color="#D18B00"/>
+<stop offset="0.6162" stop-color="#E09F00"/>
+</linearGradient>
+<linearGradient id="paint2_linear_1825_18138" x1="12.1767" y1="16.7345" x2="4.48067" y2="3.40451" gradientUnits="userSpaceOnUse">
+<stop stop-color="#F5B300"/>
+<stop offset="0.5" stop-color="#FFCB3C"/>
+<stop offset="1" stop-color="#FFD762"/>
+</linearGradient>
+<linearGradient id="paint3_linear_1825_18138" x1="12.1767" y1="16.7343" x2="4.48067" y2="3.40435" gradientUnits="userSpaceOnUse">
+<stop stop-color="#F5B300"/>
+<stop offset="0.5" stop-color="#FFCB3C"/>
+<stop offset="1" stop-color="#FFD762"/>
+</linearGradient>
+<linearGradient id="paint4_linear_1825_18138" x1="0.430309" y1="5.50017" x2="16.0017" y2="5.50017" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="white" stop-opacity="0"/>
+</linearGradient>
+<linearGradient id="paint5_linear_1825_18138" x1="12.1767" y1="16.7343" x2="4.48067" y2="3.40435" gradientUnits="userSpaceOnUse">
+<stop stop-color="#F5B300"/>
+<stop offset="0.5" stop-color="#FFCB3C"/>
+<stop offset="1" stop-color="#FFD762"/>
+</linearGradient>
+<linearGradient id="paint6_linear_1825_18138" x1="8.30516" y1="15.1422" x2="7.36003" y2="9.7821" gradientUnits="userSpaceOnUse">
+<stop stop-color="#0062B4"/>
+<stop offset="1" stop-color="#1493DF"/>
+</linearGradient>
+<linearGradient id="paint7_linear_1825_18138" x1="8.30516" y1="15.1422" x2="7.36003" y2="9.7821" gradientUnits="userSpaceOnUse">
+<stop stop-color="#0062B4"/>
+<stop offset="1" stop-color="#1493DF"/>
+</linearGradient>
+<clipPath id="clip0_1825_18138">
+<rect width="16" height="16" fill="white"/>
+</clipPath>
+</defs>
+</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Commands/CopyPathCommand.cs

@@ -0,0 +1,34 @@
+// 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.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Commands;
+
+internal sealed partial class CopyPathCommand : InvokableCommand
+{
+    private readonly IndexerItem _item;
+
+    internal CopyPathCommand(IndexerItem item)
+    {
+        this._item = item;
+        this.Name = Resources.Indexer_Command_CopyPath;
+        this.Icon = new IconInfo("\uE8c8");
+    }
+
+    public override CommandResult Invoke()
+    {
+        try
+        {
+            ClipboardHelper.SetText(_item.FullPath);
+        }
+        catch
+        {
+        }
+
+        return CommandResult.KeepOpen();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Commands/OpenFileCommand.cs

@@ -0,0 +1,44 @@
+// 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.ComponentModel;
+using System.Diagnostics;
+using ManagedCommon;
+using Microsoft.CmdPal.Ext.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Commands;
+
+internal sealed partial class OpenFileCommand : InvokableCommand
+{
+    private readonly IndexerItem _item;
+
+    internal OpenFileCommand(IndexerItem item)
+    {
+        this._item = item;
+        this.Name = Resources.Indexer_Command_OpenFile;
+        this.Icon = Icons.OpenFile;
+    }
+
+    public override CommandResult Invoke()
+    {
+        using (var process = new Process())
+        {
+            process.StartInfo.FileName = _item.FullPath;
+            process.StartInfo.UseShellExecute = true;
+
+            try
+            {
+                process.Start();
+            }
+            catch (Win32Exception ex)
+            {
+                Logger.LogError($"Unable to open {_item.FullPath}", ex);
+            }
+        }
+
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Commands/OpenInConsoleCommand.cs

@@ -0,0 +1,45 @@
+// 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.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using ManagedCommon;
+using Microsoft.CmdPal.Ext.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Commands;
+
+internal sealed partial class OpenInConsoleCommand : InvokableCommand
+{
+    private readonly IndexerItem _item;
+
+    internal OpenInConsoleCommand(IndexerItem item)
+    {
+        this._item = item;
+        this.Name = Resources.Indexer_Command_OpenPathInConsole;
+        this.Icon = new IconInfo("\uE756");
+    }
+
+    public override CommandResult Invoke()
+    {
+        using (var process = new Process())
+        {
+            process.StartInfo.WorkingDirectory = Path.GetDirectoryName(_item.FullPath);
+            process.StartInfo.FileName = "cmd.exe";
+
+            try
+            {
+                process.Start();
+            }
+            catch (Win32Exception ex)
+            {
+                Logger.LogError($"Unable to open {_item.FullPath}", ex);
+            }
+        }
+
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Commands/OpenPropertiesCommand.cs

@@ -0,0 +1,71 @@
+// 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.Runtime.InteropServices;
+using ManagedCommon;
+using Microsoft.CmdPal.Ext.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Native;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.Shell;
+using Windows.Win32.UI.WindowsAndMessaging;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Commands;
+
+internal sealed partial class OpenPropertiesCommand : InvokableCommand
+{
+    private readonly IndexerItem _item;
+
+    private static unsafe bool ShowFileProperties(string filename)
+    {
+        var propertiesPtr = Marshal.StringToHGlobalUni("properties");
+        var filenamePtr = Marshal.StringToHGlobalUni(filename);
+
+        try
+        {
+            var filenamePCWSTR = new PCWSTR((char*)filenamePtr);
+            var propertiesPCWSTR = new PCWSTR((char*)propertiesPtr);
+
+            var info = new SHELLEXECUTEINFOW
+            {
+                cbSize = (uint)Marshal.SizeOf<SHELLEXECUTEINFOW>(),
+                lpVerb = propertiesPCWSTR,
+                lpFile = filenamePCWSTR,
+                nShow = (int)SHOW_WINDOW_CMD.SW_SHOW,
+                fMask = NativeHelpers.SEEMASKINVOKEIDLIST,
+            };
+
+            return PInvoke.ShellExecuteEx(ref info);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(filenamePtr);
+            Marshal.FreeHGlobal(propertiesPtr);
+        }
+    }
+
+    internal OpenPropertiesCommand(IndexerItem item)
+    {
+        this._item = item;
+        this.Name = Resources.Indexer_Command_OpenProperties;
+        this.Icon = new IconInfo("\uE90F");
+    }
+
+    public override CommandResult Invoke()
+    {
+        try
+        {
+            ShowFileProperties(_item.FullPath);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError("Error showing file properties: ", ex);
+        }
+
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Commands/OpenWithCommand.cs

@@ -0,0 +1,62 @@
+// 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.InteropServices;
+using Microsoft.CmdPal.Ext.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Native;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.Shell;
+using Windows.Win32.UI.WindowsAndMessaging;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Commands;
+
+internal sealed partial class OpenWithCommand : InvokableCommand
+{
+    private readonly IndexerItem _item;
+
+    private static unsafe bool OpenWith(string filename)
+    {
+        var filenamePtr = Marshal.StringToHGlobalUni(filename);
+        var verbPtr = Marshal.StringToHGlobalUni("openas");
+
+        try
+        {
+            var filenamePCWSTR = new PCWSTR((char*)filenamePtr);
+            var verbPCWSTR = new PCWSTR((char*)verbPtr);
+
+            var info = new SHELLEXECUTEINFOW
+            {
+                cbSize = (uint)Marshal.SizeOf<SHELLEXECUTEINFOW>(),
+                lpVerb = verbPCWSTR,
+                lpFile = filenamePCWSTR,
+                nShow = (int)SHOW_WINDOW_CMD.SW_SHOWNORMAL,
+                fMask = NativeHelpers.SEEMASKINVOKEIDLIST,
+            };
+
+            return PInvoke.ShellExecuteEx(ref info);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(filenamePtr);
+            Marshal.FreeHGlobal(verbPtr);
+        }
+    }
+
+    internal OpenWithCommand(IndexerItem item)
+    {
+        this._item = item;
+        this.Name = Resources.Indexer_Command_OpenWith;
+        this.Icon = new IconInfo("\uE7AC");
+    }
+
+    public override CommandResult Invoke()
+    {
+        OpenWith(_item.FullPath);
+
+        return CommandResult.GoHome();
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Data/IndexerItem.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.IO;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Data;
+
+internal sealed class IndexerItem
+{
+    internal string FullPath { get; init; }
+
+    internal string FileName { get; init; }
+
+    internal bool IsDirectory()
+    {
+        if (!Path.Exists(FullPath))
+        {
+            return false;
+        }
+
+        var attr = File.GetAttributes(FullPath);
+
+        // detect whether it is a directory or file
+        return (attr & FileAttributes.Directory) == FileAttributes.Directory;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Data/IndexerListItem.cs

@@ -0,0 +1,57 @@
+// 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;
+using Microsoft.CmdPal.Ext.Indexer.Commands;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Data;
+
+internal sealed partial class IndexerListItem : ListItem
+{
+    internal string FilePath { get; private set; }
+
+    public IndexerListItem(
+        IndexerItem indexerItem,
+        IncludeBrowseCommand browseByDefault = IncludeBrowseCommand.Include)
+        : base(new OpenFileCommand(indexerItem))
+    {
+        FilePath = indexerItem.FullPath;
+
+        Title = indexerItem.FileName;
+        Subtitle = indexerItem.FullPath;
+        List<CommandContextItem> context = [];
+        if (indexerItem.IsDirectory())
+        {
+            var directoryPage = new DirectoryPage(indexerItem.FullPath);
+            if (browseByDefault == IncludeBrowseCommand.AsDefault)
+            {
+                // Swap the open file command into the context menu
+                context.Add(new CommandContextItem(Command));
+                Command = directoryPage;
+            }
+            else if (browseByDefault == IncludeBrowseCommand.Include)
+            {
+                context.Add(new CommandContextItem(directoryPage));
+            }
+        }
+
+        MoreCommands = [
+            ..context,
+            new CommandContextItem(new OpenWithCommand(indexerItem)),
+            new CommandContextItem(new ShowFileInFolderCommand(indexerItem.FullPath) { Name = Resources.Indexer_Command_ShowInFolder }),
+            new CommandContextItem(new CopyPathCommand(indexerItem)),
+            new CommandContextItem(new OpenInConsoleCommand(indexerItem)),
+            new CommandContextItem(new OpenPropertiesCommand(indexerItem)),
+        ];
+    }
+}
+
+internal enum IncludeBrowseCommand
+{
+    AsDefault = 0,
+    Include = 1,
+    Exclude = 2,
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/FallbackOpenFileItem.cs

@@ -0,0 +1,54 @@
+// 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.IO;
+using Microsoft.CmdPal.Ext.Indexer.Data;
+using Microsoft.CmdPal.Ext.Indexer.Properties;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.Ext.Indexer;
+
+internal sealed partial class FallbackOpenFileItem : FallbackCommandItem
+{
+    public FallbackOpenFileItem()
+        : base(new NoOpCommand(), Resources.Indexer_Find_Path_fallback_display_title)
+    {
+        Title = string.Empty;
+        Subtitle = string.Empty;
+    }
+
+    public override void UpdateQuery(string query)
+    {
+        if (Path.Exists(query))
+        {
+            var item = new IndexerItem() { FullPath = query, FileName = Path.GetFileName(query) };
+            var listItemForUs = new IndexerListItem(item, IncludeBrowseCommand.AsDefault);
+            Command = listItemForUs.Command;
+            MoreCommands = listItemForUs.MoreCommands;
+            Subtitle = item.FileName;
+            Title = item.FullPath;
+            Icon = listItemForUs.Icon;
+
+            try
+            {
+                var stream = ThumbnailHelper.GetThumbnail(item.FullPath).Result;
+                if (stream != null)
+                {
+                    var data = new IconData(RandomAccessStreamReference.CreateFromStream(stream));
+                    Icon = new IconInfo(data, data);
+                }
+            }
+            catch
+            {
+            }
+        }
+        else
+        {
+            Title = string.Empty;
+            Subtitle = string.Empty;
+            Command = new NoOpCommand();
+        }
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Indexer/DataSourceManager.cs

@@ -0,0 +1,49 @@
+// 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 ManagedCommon;
+using Windows.Win32;
+using Windows.Win32.System.Com;
+using Windows.Win32.System.Search;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Indexer;
+
+internal static class DataSourceManager
+{
+    private static readonly Guid CLSIDCollatorDataSource = new("9E175B8B-F52A-11D8-B9A5-505054503030");
+
+    private static IDBInitialize _dataSource;
+
+    public static IDBInitialize GetDataSource()
+    {
+        if (_dataSource == null)
+        {
+            InitializeDataSource();
+        }
+
+        return _dataSource;
+    }
+
+    private static bool InitializeDataSource()
+    {
+        var hr = PInvoke.CoCreateInstance(CLSIDCollatorDataSource, null, CLSCTX.CLSCTX_INPROC_SERVER, typeof(IDBInitialize).GUID, out var dataSourceObj);
+        if (hr != 0)
+        {
+            Logger.LogError("CoCreateInstance failed: " + hr);
+            return false;
+        }
+
+        if (dataSourceObj == null)
+        {
+            Logger.LogError("CoCreateInstance failed: dataSourceObj is null");
+            return false;
+        }
+
+        _dataSource = (IDBInitialize)dataSourceObj;
+        _dataSource.Initialize();
+
+        return true;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Indexer/OleDB/DBPROP.cs

@@ -0,0 +1,21 @@
+// 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.InteropServices;
+using Windows.Win32.Storage.IndexServer;
+using Windows.Win32.System.Com.StructuredStorage;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Indexer.OleDB;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct DBPROP
+{
+#pragma warning disable SA1307 // Accessible fields should begin with upper-case letter
+    public uint dwPropertyID;
+    public uint dwOptions;
+    public uint dwStatus;
+    public DBID colid;
+    public PROPVARIANT vValue;
+#pragma warning restore SA1307 // Accessible fields should begin with upper-case letter
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Indexer/OleDB/DBPROPIDSET.cs

@@ -0,0 +1,18 @@
+// 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.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Indexer.OleDB;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct DBPROPIDSET
+{
+#pragma warning disable SA1307 // Accessible fields should begin with upper-case letter
+    public IntPtr rgPropertyIDs; // Pointer to array of property IDs
+    public uint cPropertyIDs;    // Number of properties in array
+    public Guid guidPropertySet; // GUID of the property set
+#pragma warning restore SA1307 // Accessible fields should begin with upper-case letter
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Indexer/OleDB/DBPROPSET.cs

@@ -0,0 +1,18 @@
+// 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.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Indexer.OleDB;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct DBPROPSET
+{
+#pragma warning disable SA1307 // Accessible fields should begin with upper-case letter
+    public IntPtr rgProperties;    // Pointer to an array of DBPROP
+    public uint cProperties;       // Number of properties in the array
+    public Guid guidPropertySet;   // GUID of the property set
+#pragma warning restore SA1307 // Accessible fields should begin with upper-case letter
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/Indexer/OleDB/IRowset.cs

@@ -0,0 +1,43 @@
+// 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.Runtime.InteropServices;
+
+namespace Microsoft.CmdPal.Ext.Indexer.Indexer.OleDB;
+
+[ComImport]
+[Guid("0c733a7c-2a1c-11ce-ade5-00aa0044773d")]
+[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+public interface IRowset
+{
+    [PreserveSig]
+    int AddRefRows(
+        uint cRows,
+        [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IntPtr[] rghRows,
+        [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] uint[] rgRefCounts,
+        [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] int[] rgRowStatus);
+
+    [PreserveSig]
+    int GetData(
+        IntPtr hRow,
+        IntPtr hAccessor,
+        IntPtr pData);
+
+    [PreserveSig]
+    int GetNextRows(
+       IntPtr hReserved,
+       long lRowsOffset,
+       long cRows,
+       out uint pcRowsObtained,
+       out IntPtr prghRows);
+
+    [PreserveSig]
+    int ReleaseRows(
+        uint cRows,
+        [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IntPtr[] rghRows,
+        IntPtr rgRowOptions,
+        [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] uint[] rgRefCounts,
+        [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] int[] rgRowStatus);
+}