add process

Signed-off-by: Shawn Yuan <shuaiyuan@microsoft.com>

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

@@ -27,7 +27,6 @@ admx
 advancedpaste
 advancedpasteui
 advancedpasteuishortcut
-advapi
 advfirewall
 AFeature
 affordances

.github/workflows/automatic-issue-deduplication.yml

@@ -1,19 +0,0 @@
-name: Automatic New Issue Deduplication
-on:
-  issues:
-    types: [opened, reopened]
-permissions:
-  models: read
-  issues: write
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
-  cancel-in-progress: true
-jobs:
-  deduplicate:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run Deduplicate Action
-        uses: pelikhan/action-genai-issue-dedup@v0
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          label_as_duplicate: true

.pipelines/v2/templates/job-build-project.yml

@@ -411,28 +411,9 @@ jobs:
           !**\obj\**
 
   - pwsh: |-
-      $Packages = Get-ChildItem -Recurse -Filter "Microsoft.CmdPal.UI_*.msix"
-      Write-Host "Found $($Packages.Count) CmdPal MSIX package(s):"
-      foreach ($pkg in $Packages) {
-          Write-Host "  - $($pkg.FullName)"
-      }
-      
-      if ($Packages.Count -gt 0) {
-          # Priority: Look for platform-specific MSIX (x64/arm64) first, then fall back to any
-          $PlatformPackage = $Packages | Where-Object { $_.Name -match "Microsoft\.CmdPal\.UI_.*_(x64|arm64)\.msix$" } | Select-Object -First 1
-          if ($PlatformPackage) {
-              $Package = $PlatformPackage
-              Write-Host "Using platform-specific package: $($Package.FullName)"
-          } else {
-              $Package = $Packages | Select-Object -First 1
-              Write-Host "Using first available package: $($Package.FullName)"
-          }
-          
-          $PackageFilename = $Package.FullName
-          Write-Host "##vso[task.setvariable variable=CmdPalPackagePath]${PackageFilename}"
-      } else {
-          Write-Warning "No CmdPal MSIX packages found!"
-      }
+      $Package = (Get-ChildItem -Recurse -Filter "Microsoft.CmdPal.UI_*.msix" | Select -First 1)
+      $PackageFilename = $Package.FullName
+      Write-Host "##vso[task.setvariable variable=CmdPalPackagePath]${PackageFilename}"
     displayName: Locate the CmdPal MSIX
 
   - ${{ if eq(parameters.codeSign, true) }}:

.vscode/mcp.json

@@ -0,0 +1,12 @@
+{
+  "servers": {
+    "powertoys-mcp": {
+      "command": "D:/work/PowerToys/x64/Debug/PowerToys.MCPServer.exe",
+      "transport": "stdio",
+      "args": [],
+      "env": {
+        "NODE_ENV": "production"
+      }
+    }
+  }
+}

Directory.Packages.props

@@ -45,7 +45,7 @@
     <PackageVersion Include="Microsoft.Extensions.Hosting.WindowsServices" Version="9.0.8" />
     <PackageVersion Include="Microsoft.SemanticKernel" Version="1.15.0" />
     <PackageVersion Include="Microsoft.Toolkit.Uwp.Notifications" Version="7.1.2" />
-    <PackageVersion Include="Microsoft.Web.WebView2" Version="1.0.3179.45" />
+    <PackageVersion Include="Microsoft.Web.WebView2" Version="1.0.2903.40" />
     <!-- Package Microsoft.Win32.SystemEvents added as a hack for being able to exclude the runtime assets so they don't conflict with 8.0.1. This is a dependency of System.Drawing.Common but the 8.0.1 version wasn't published to nuget. -->
     <PackageVersion Include="Microsoft.Win32.SystemEvents" Version="9.0.8" />
     <PackageVersion Include="Microsoft.WindowsPackageManager.ComInterop" Version="1.10.340" />
@@ -57,10 +57,11 @@
       This is present due to a bug in CsWinRT where WPF projects cause the analyzer to fail.
 	-->
     <PackageVersion Include="Microsoft.Windows.CsWinRT" Version="2.2.0" />
-    <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.4948" />
-    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.8.250907003" />
+    <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.4188" />
+    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.7.250513003" />
     <PackageVersion Include="Microsoft.Xaml.Behaviors.WinUI.Managed" Version="2.0.9" />
     <PackageVersion Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.39" />
+	<PackageVersion Include="ModelContextProtocol" Version="0.3.0-preview.4" />
     <PackageVersion Include="ModernWpfUI" Version="0.9.4" />
     <!-- Moq to stay below v4.20 due to behavior change. need to be sure fixed -->
     <PackageVersion Include="Moq" Version="4.18.4" />

PowerToys.sln

@@ -805,6 +805,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.WebSea
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.Shell.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.Shell.UnitTests\Microsoft.CmdPal.Ext.Shell.UnitTests.csproj", "{E816D7B4-4688-4ECB-97CC-3D8E798F3833}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MCPServer", "MCPServer", "{B637E6DD-FB81-4595-BB9C-01168556EA9E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MCPServer", "src\modules\MCPServer\MCPServer\MCPServer.csproj", "{20CBF173-9E8D-3236-6664-5B9C303794A3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|ARM64 = Debug|ARM64
@@ -2923,6 +2927,14 @@ Global
 		{E816D7B4-4688-4ECB-97CC-3D8E798F3833}.Release|ARM64.Build.0 = Release|ARM64
 		{E816D7B4-4688-4ECB-97CC-3D8E798F3833}.Release|x64.ActiveCfg = Release|x64
 		{E816D7B4-4688-4ECB-97CC-3D8E798F3833}.Release|x64.Build.0 = Release|x64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Debug|x64.ActiveCfg = Debug|x64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Debug|x64.Build.0 = Debug|x64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Release|ARM64.Build.0 = Release|ARM64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Release|x64.ActiveCfg = Release|x64
+		{20CBF173-9E8D-3236-6664-5B9C303794A3}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -2932,6 +2944,7 @@ Global
 		{D1D6BC88-09AE-4FB4-AD24-5DED46A791DD} = {4574FDD0-F61D-4376-98BF-E5A1262C11EC}
 		{F9C68EDF-AC74-4B77-9AF1-005D9C9F6A99} = {D1D6BC88-09AE-4FB4-AD24-5DED46A791DD}
 		{9C6A7905-72D4-4BF5-B256-ABFDAEF68AE9} = {264B412F-DB8B-4CF8-A74B-96998B183045}
+		{1AFB6476-670D-4E80-A464-657E01DFF482} = {557C4636-D7E1-4838-A504-7D19B725EE95}
 		{1A066C63-64B3-45F8-92FE-664E1CCE8077} = {1AFB6476-670D-4E80-A464-657E01DFF482}
 		{5CCC8468-DEC8-4D36-99D4-5C891BEBD481} = {D1D6BC88-09AE-4FB4-AD24-5DED46A791DD}
 		{89E20BCE-EB9C-46C8-8B50-E01A82E6FDC3} = {4574FDD0-F61D-4376-98BF-E5A1262C11EC}
@@ -3242,6 +3255,8 @@ Global
 		{E816D7B3-4688-4ECB-97CC-3D8E798F3832} = {8EF25507-2575-4ADE-BF7E-D23376903AB8}
 		{E816D7B2-4688-4ECB-97CC-3D8E798F3831} = {8EF25507-2575-4ADE-BF7E-D23376903AB8}
 		{E816D7B4-4688-4ECB-97CC-3D8E798F3833} = {8EF25507-2575-4ADE-BF7E-D23376903AB8}
+		{B637E6DD-FB81-4595-BB9C-01168556EA9E} = {4574FDD0-F61D-4376-98BF-E5A1262C11EC}
+		{20CBF173-9E8D-3236-6664-5B9C303794A3} = {B637E6DD-FB81-4595-BB9C-01168556EA9E}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {C3A2F9D1-7930-4EF4-A6FC-7EE0A99821D0}

installer/PowerToysSetup/CmdPal.wxs

@@ -9,6 +9,13 @@
   <Fragment>
     <DirectoryRef Id="WinUI3AppsInstallFolder">
       <Directory Id="CmdPalInstallFolder" Name="CmdPal">
+        <Directory Id="CmdPalDepsInstallFolder" Name="Dependencies">
+        <?if $(sys.BUILDARCH) = x64 ?>
+          <Directory Id="CmdPalDepsX64InstallFolder" Name="x64" />
+        <?else ?>
+          <Directory Id="CmdPalDepsArm64InstallFolder" Name="arm64" />
+        <?endif ?>
+        </Directory>
       </Directory>
     </DirectoryRef>
 
@@ -26,14 +33,41 @@
       </Component>
     </DirectoryRef>
 
+    <?if $(sys.BUILDARCH) = x64 ?>
+    <DirectoryRef Id="CmdPalDepsX64InstallFolder" FileSource="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\x64">
+      <Component Id="Module_CmdPal_Deps" Win64="yes" Guid="C2790FC4-0665-4462-947A-D942A2AABFF0">
+        <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
+          <RegistryValue Type="string" Name="Module_CmdPal_Deps" Value="" KeyPath="yes"/>
+        </RegistryKey>
+        <File Source="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\x64\Microsoft.VCLibs.x64.14.00.Desktop.appx" />
+      </Component>
+    </DirectoryRef>
+    <?else ?>
+    <DirectoryRef Id="CmdPalDepsArm64InstallFolder" FileSource="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\arm64">
+      <Component Id="Module_CmdPal_Deps" Win64="yes" Guid="C2790FC4-0665-4462-947A-D942A2AABFF0">
+        <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
+          <RegistryValue Type="string" Name="Module_CmdPal_Deps" Value="" KeyPath="yes"/>
+        </RegistryKey>
+        <File Source="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\arm64\Microsoft.VCLibs.ARM64.14.00.Desktop.appx" />
+      </Component>
+    </DirectoryRef>
+    <?endif ?>
+
     <ComponentGroup Id="CmdPalComponentGroup">
       <Component Id="RemoveCmdPalFolder" Guid="2DF90C08-CC75-4245-A14E-B82904636C53" Directory="INSTALLFOLDER">
         <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
           <RegistryValue Type="string" Name="RemoveCmdPalFolder" Value="" KeyPath="yes"/>
         </RegistryKey>
         <RemoveFolder Id="RemoveCmdPalInstallDirFolder" Directory="CmdPalInstallFolder" On="uninstall"/>
+        <RemoveFolder Id="RemoveCmdPalDepsInstallDirFolder" Directory="CmdPalDepsInstallFolder" On="uninstall"/>
+    <?if $(sys.BUILDARCH) = x64 ?>
+        <RemoveFolder Id="RemoveCmdPalDepsX64InstallDirFolder" Directory="CmdPalDepsX64InstallFolder" On="uninstall"/>
+    <?else ?>
+        <RemoveFolder Id="RemoveCmdPalDepsArm64InstallDirFolder" Directory="CmdPalDepsArm64InstallFolder" On="uninstall"/>
+    <?endif ?>
       </Component>
       <ComponentRef Id="Module_CmdPal" />
+      <ComponentRef Id="Module_CmdPal_Deps" />
     </ComponentGroup>
 
   </Fragment>

installer/PowerToysSetupVNext/CmdPal.wxs

@@ -4,6 +4,13 @@
   <Fragment>
     <DirectoryRef Id="WinUI3AppsInstallFolder">
       <Directory Id="CmdPalInstallFolder" Name="CmdPal">
+        <Directory Id="CmdPalDepsInstallFolder" Name="Dependencies">
+        <?if $(sys.BUILDARCH) = x64 ?>
+          <Directory Id="CmdPalDepsX64InstallFolder" Name="x64" />
+        <?else?>
+          <Directory Id="CmdPalDepsArm64InstallFolder" Name="arm64" />
+        <?endif?>
+        </Directory>
       </Directory>
     </DirectoryRef>
     <DirectoryRef Id="CmdPalInstallFolder" FileSource="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test">
@@ -18,14 +25,40 @@
         <?endif?>
       </Component>
     </DirectoryRef>
+    <?if $(sys.BUILDARCH) = x64 ?>
+    <DirectoryRef Id="CmdPalDepsX64InstallFolder" FileSource="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\x64">
+      <Component Id="Module_CmdPal_Deps" Guid="C2790FC4-0665-4462-947A-D942A2AABFF0" Bitness="always64">
+        <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
+          <RegistryValue Type="string" Name="Module_CmdPal_Deps" Value="" KeyPath="yes" />
+        </RegistryKey>
+        <File Id="Microsoft.VCLibs.x64.14.00.Desktop.appx" Source="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\x64\Microsoft.VCLibs.x64.14.00.Desktop.appx" />
+      </Component>
+    </DirectoryRef>
+    <?else?>
+    <DirectoryRef Id="CmdPalDepsArm64InstallFolder" FileSource="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\arm64">
+      <Component Id="Module_CmdPal_Deps" Guid="C2790FC4-0665-4462-947A-D942A2AABFF0" Bitness="always64">
+        <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
+          <RegistryValue Type="string" Name="Module_CmdPal_Deps" Value="" KeyPath="yes" />
+        </RegistryKey>
+        <File Id="Microsoft.VCLibs.ARM64.14.00.Desktop.appx" Source="$(var.CmdPalBuildDir)AppPackages\Microsoft.CmdPal.UI_$(var.CmdPalVersion)_Test\Dependencies\arm64\Microsoft.VCLibs.ARM64.14.00.Desktop.appx" />
+      </Component>
+    </DirectoryRef>
+    <?endif?>
     <ComponentGroup Id="CmdPalComponentGroup">
       <Component Id="RemoveCmdPalFolder" Guid="2DF90C08-CC75-4245-A14E-B82904636C53" Directory="INSTALLFOLDER">
         <RegistryKey Root="$(var.RegistryScope)" Key="Software\Classes\powertoys\components">
           <RegistryValue Type="string" Name="RemoveCmdPalFolder" Value="" KeyPath="yes" />
         </RegistryKey>
         <RemoveFolder Id="RemoveCmdPalInstallDirFolder" Directory="CmdPalInstallFolder" On="uninstall" />
+        <RemoveFolder Id="RemoveCmdPalDepsInstallDirFolder" Directory="CmdPalDepsInstallFolder" On="uninstall" />
+    <?if $(sys.BUILDARCH) = x64 ?>
+        <RemoveFolder Id="RemoveCmdPalDepsX64InstallDirFolder" Directory="CmdPalDepsX64InstallFolder" On="uninstall" />
+    <?else?>
+        <RemoveFolder Id="RemoveCmdPalDepsArm64InstallDirFolder" Directory="CmdPalDepsArm64InstallFolder" On="uninstall" />
+    <?endif?>
       </Component>
       <ComponentRef Id="Module_CmdPal" />
+      <ComponentRef Id="Module_CmdPal_Deps" />
     </ComponentGroup>
   </Fragment>
 </Wix>

src/common/ManagedCommon/ErrorResponse.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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+
+namespace ManagedCommon
+{
+    public sealed class ErrorResponse
+    {
+        public string Error { get; set; } = string.Empty;
+
+        public IEnumerable<string>? RegisteredModules { get; set; }
+
+        public string[]? AvailableEndpoints { get; set; }
+
+        public int? StatusCode { get; set; }
+
+        public DateTimeOffset Timestamp { get; set; }
+    }
+}

src/common/ManagedCommon/GlobalStatusResponse.cs

@@ -0,0 +1,26 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+
+namespace ManagedCommon
+{
+    public sealed class GlobalStatusResponse
+    {
+        public string Application { get; set; } = string.Empty;
+
+        public string? Version { get; set; }
+
+        public string Status { get; set; } = string.Empty;
+
+        public int RegisteredModules { get; set; }
+
+        public Dictionary<string, ModuleStatusResponse> Modules { get; set; } = [];
+
+        public DateTimeOffset Timestamp { get; set; }
+    }
+}

src/common/ManagedCommon/HttpServer.cs

@@ -0,0 +1,358 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ManagedCommon
+{
+    public sealed class HttpServer : IDisposable
+    {
+        private readonly HttpListener _listener;
+        private readonly CancellationTokenSource _cancellationTokenSource;
+        private readonly Dictionary<string, IHttpRequestHandler> _requestHandlers;
+        private readonly JsonSerializerOptions _fallbackJsonOptions;
+        private Task? _listenerTask;
+        private bool _disposed;
+
+        public HttpServer(string prefix = "http://localhost:8080/")
+        {
+            _listener = new HttpListener();
+            _listener.Prefixes.Add(prefix);
+            _cancellationTokenSource = new CancellationTokenSource();
+            _requestHandlers = new Dictionary<string, IHttpRequestHandler>(StringComparer.OrdinalIgnoreCase);
+
+            // Cached fallback options for generic deserialization
+            _fallbackJsonOptions = new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            };
+
+            Logger.LogInfo($"HTTP server configured to listen on: {prefix}");
+        }
+
+        /// <summary>
+        /// Register a request handler for a specific module.
+        /// </summary>
+        /// <param name="handler">The request handler to register.</param>
+        public void RegisterHandler(IHttpRequestHandler handler)
+        {
+            ArgumentNullException.ThrowIfNull(handler);
+
+            if (string.IsNullOrWhiteSpace(handler.ModuleName))
+            {
+                throw new ArgumentException("Module name cannot be null or empty", nameof(handler));
+            }
+
+            _requestHandlers[handler.ModuleName] = handler;
+            Logger.LogInfo($"Registered HTTP handler for module: {handler.ModuleName}");
+        }
+
+        /// <summary>
+        /// Unregister a request handler for a specific module.
+        /// </summary>
+        /// <param name="moduleName">The name of the module to unregister.</param>
+        public void UnregisterHandler(string moduleName)
+        {
+            if (_requestHandlers.Remove(moduleName))
+            {
+                Logger.LogInfo($"Unregistered HTTP handler for module: {moduleName}");
+            }
+        }
+
+        public void Start()
+        {
+            try
+            {
+                _listener.Start();
+                Logger.LogInfo("HTTP server started successfully");
+
+                _listenerTask = Task.Run(async () => await ListenAsync(_cancellationTokenSource.Token));
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Failed to start HTTP server: {ex.Message}");
+                throw;
+            }
+        }
+
+        public void Stop()
+        {
+            try
+            {
+                _cancellationTokenSource.Cancel();
+                _listener.Stop();
+                _listenerTask?.Wait(TimeSpan.FromSeconds(5));
+                Logger.LogInfo("HTTP server stopped");
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Error stopping HTTP server: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Utility method for modules to write JSON responses.
+        /// </summary>
+        /// <param name="response">The HTTP response to write to.</param>
+        /// <param name="data">The object to serialize as JSON.</param>
+        public async Task WriteJsonResponseAsync(HttpListenerResponse response, object data)
+        {
+            response.ContentType = "application/json";
+            response.ContentEncoding = Encoding.UTF8;
+
+            string json = data switch
+            {
+                ServerStatusResponse serverStatus => JsonSerializer.Serialize(serverStatus, HttpServerJsonContext.Default.ServerStatusResponse),
+                GlobalStatusResponse globalStatus => JsonSerializer.Serialize(globalStatus, HttpServerJsonContext.Default.GlobalStatusResponse),
+                ErrorResponse error => JsonSerializer.Serialize(error, HttpServerJsonContext.Default.ErrorResponse),
+                _ => JsonSerializer.Serialize(data, HttpServerJsonContext.Default.Object),
+            };
+
+            var buffer = Encoding.UTF8.GetBytes(json);
+
+            response.ContentLength64 = buffer.Length;
+            await response.OutputStream.WriteAsync(buffer.AsMemory(), _cancellationTokenSource.Token);
+            response.Close();
+        }
+
+        /// <summary>
+        /// Utility method for modules to read JSON request bodies as string.
+        /// Modules should handle their own deserialization to maintain AOT compatibility.
+        /// </summary>
+        /// <param name="request">The HTTP request to read from.</param>
+        /// <returns>The JSON string, or null if no body.</returns>
+        public async Task<string?> ReadJsonRequestBodyAsync(HttpListenerRequest request)
+        {
+            if (!request.HasEntityBody)
+            {
+                return null;
+            }
+
+            using var reader = new StreamReader(request.InputStream, Encoding.UTF8);
+            var body = await reader.ReadToEndAsync();
+
+            return string.IsNullOrWhiteSpace(body) ? null : body;
+        }
+
+        /// <summary>
+        /// Legacy utility method for modules to read JSON request bodies.
+        /// Warning: This method uses reflection-based deserialization and is not AOT-compatible.
+        /// Consider using ReadJsonRequestBodyAsync and handling deserialization in your module.
+        /// </summary>
+        /// <typeparam name="T">The type to deserialize to.</typeparam>
+        /// <param name="request">The HTTP request to read from.</param>
+        /// <returns>The deserialized object, or null if no body or invalid JSON.</returns>
+        [Obsolete("Use ReadJsonRequestBodyAsync and handle deserialization in your module for AOT compatibility")]
+        public async Task<T?> ReadJsonRequestAsync<T>(HttpListenerRequest request)
+            where T : class
+        {
+            var body = await ReadJsonRequestBodyAsync(request);
+            if (body == null)
+            {
+                return null;
+            }
+
+            try
+            {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling
+                return JsonSerializer.Deserialize<T>(body, _fallbackJsonOptions);
+#pragma warning restore IL3050
+#pragma warning restore IL2026
+            }
+            catch (JsonException ex)
+            {
+                Logger.LogError($"Error deserializing request body: {ex.Message}");
+                return null;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (!_disposed)
+            {
+                Stop();
+                _cancellationTokenSource?.Dispose();
+                _listener?.Close();
+                _disposed = true;
+            }
+        }
+
+        private async Task ListenAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested && _listener.IsListening)
+            {
+                try
+                {
+                    var contextTask = _listener.GetContextAsync();
+                    var context = await contextTask.ConfigureAwait(false);
+
+                    // Handle request asynchronously without blocking the listener
+                    _ = Task.Run(async () => await HandleRequestAsync(context), cancellationToken);
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Expected when listener is stopped
+                    break;
+                }
+                catch (HttpListenerException ex) when (ex.ErrorCode == 995)
+                {
+                    // Expected when listener is stopped
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError($"Error in HTTP listener: {ex.Message}");
+                }
+            }
+        }
+
+        private async Task HandleRequestAsync(HttpListenerContext context)
+        {
+            try
+            {
+                var request = context.Request;
+                var response = context.Response;
+
+                Logger.LogInfo($"HTTP Request: {request.HttpMethod} {request.Url?.AbsolutePath}");
+
+                // Set CORS headers
+                response.Headers.Add("Access-Control-Allow-Origin", "*");
+                response.Headers.Add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+                response.Headers.Add("Access-Control-Allow-Headers", "Content-Type");
+
+                if (request.HttpMethod == "OPTIONS")
+                {
+                    response.StatusCode = 200;
+                    response.Close();
+                    return;
+                }
+
+                var path = request.Url?.AbsolutePath?.TrimStart('/');
+
+                if (string.IsNullOrEmpty(path))
+                {
+                    await HandleRootRequestAsync(response);
+                    return;
+                }
+
+                // Parse the path to extract module name and sub-path
+                var segments = path.Split('/', 2);
+                var moduleName = segments[0];
+                var subPath = segments.Length > 1 ? segments[1] : string.Empty;
+
+                // Check for global endpoints
+                if (string.Equals(moduleName, "status", StringComparison.OrdinalIgnoreCase))
+                {
+                    await HandleGlobalStatusAsync(response);
+                    return;
+                }
+
+                // Route to module-specific handler
+                if (_requestHandlers.TryGetValue(moduleName, out var handler))
+                {
+                    try
+                    {
+                        await handler.HandleRequestAsync(context, subPath);
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.LogError($"Error in module handler for {moduleName}: {ex.Message}");
+                        await HandleErrorAsync(response, 500, $"Internal server error in {moduleName} module: {ex.Message}");
+                    }
+                }
+                else
+                {
+                    await HandleNotFoundAsync(response, moduleName);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Unhandled error in HTTP request handler: {ex.Message}");
+            }
+        }
+
+        private async Task HandleRootRequestAsync(HttpListenerResponse response)
+        {
+            var rootInfo = new ServerStatusResponse
+            {
+                Application = "PowerToys HTTP Server",
+                Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version?.ToString(),
+                Status = "Running",
+                RegisteredModules = _requestHandlers.Keys,
+                AvailableEndpoints = [
+                    "GET /status - Get server status",
+                    "GET /{module}/... - Module-specific endpoints",
+                ],
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            await WriteJsonResponseAsync(response, rootInfo);
+        }
+
+        private async Task HandleGlobalStatusAsync(HttpListenerResponse response)
+        {
+            var moduleStatuses = new Dictionary<string, ModuleStatusResponse>();
+
+            foreach (var kvp in _requestHandlers)
+            {
+                moduleStatuses[kvp.Key] = new ModuleStatusResponse
+                {
+                    ModuleName = kvp.Value.ModuleName,
+                    AvailableEndpoints = kvp.Value.GetAvailableEndpoints(),
+                };
+            }
+
+            var status = new GlobalStatusResponse
+            {
+                Application = "PowerToys HTTP Server",
+                Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version?.ToString(),
+                Status = "Running",
+                RegisteredModules = _requestHandlers.Count,
+                Modules = moduleStatuses,
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            await WriteJsonResponseAsync(response, status);
+        }
+
+        private async Task HandleNotFoundAsync(HttpListenerResponse response, string requestedModule)
+        {
+            var errorResponse = new ErrorResponse
+            {
+                Error = $"Module '{requestedModule}' not found",
+                RegisteredModules = _requestHandlers.Keys,
+                AvailableEndpoints = [
+                    "GET /status - Get server status and available modules",
+                ],
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            response.StatusCode = 404;
+            await WriteJsonResponseAsync(response, errorResponse);
+        }
+
+        private async Task HandleErrorAsync(HttpListenerResponse response, int statusCode, string message)
+        {
+            response.StatusCode = statusCode;
+            var errorResponse = new ErrorResponse
+            {
+                Error = message,
+                StatusCode = statusCode,
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            await WriteJsonResponseAsync(response, errorResponse);
+        }
+    }
+}

src/common/ManagedCommon/HttpServerJsonContext.cs

@@ -0,0 +1,23 @@
+// 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.
+
+#nullable enable
+
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace ManagedCommon
+{
+    [JsonSerializable(typeof(ServerStatusResponse))]
+    [JsonSerializable(typeof(ModuleStatusResponse))]
+    [JsonSerializable(typeof(GlobalStatusResponse))]
+    [JsonSerializable(typeof(ErrorResponse))]
+    [JsonSerializable(typeof(Dictionary<string, ModuleStatusResponse>))]
+    [JsonSerializable(typeof(string[]))]
+    [JsonSerializable(typeof(IEnumerable<string>))]
+    [JsonSerializable(typeof(object))]
+    internal sealed partial class HttpServerJsonContext : JsonSerializerContext
+    {
+    }
+}

src/common/ManagedCommon/IHttpRequestHandler.cs

@@ -0,0 +1,36 @@
+// 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.Net;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ManagedCommon
+{
+    public interface IHttpRequestHandler
+    {
+        /// <summary>
+        /// Handle an HTTP request for this module.
+        /// </summary>
+        /// <param name="context">The HTTP context containing request and response.</param>
+        /// <param name="path">The requested path (after module prefix).</param>
+        /// <returns>Task representing the async operation.</returns>
+        Task HandleRequestAsync(HttpListenerContext context, string path);
+
+        /// <summary>
+        /// Get the module name used for URL routing (e.g., "awake", "fancyzones").
+        /// </summary>
+        string ModuleName { get; }
+
+        /// <summary>
+        /// Get the available endpoints for this module (for documentation).
+        /// </summary>
+        string[] GetAvailableEndpoints();
+    }
+}

src/common/ManagedCommon/ModuleStatusResponse.cs

@@ -0,0 +1,15 @@
+// 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.
+
+#nullable enable
+
+namespace ManagedCommon
+{
+    public sealed class ModuleStatusResponse
+    {
+        public string ModuleName { get; set; } = string.Empty;
+
+        public string[] AvailableEndpoints { get; set; } = [];
+    }
+}

src/common/ManagedCommon/RotSingletonHost.cs

@@ -0,0 +1,225 @@
+// 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.Threading;
+
+#nullable enable
+#pragma warning disable IL2050 // Suppress COM interop trimming warnings for ROT hosting P/Invokes (desktop only scenario)
+
+namespace ManagedCommon
+{
+    /// <summary>
+    /// Generic helper to host a single COM-visible automation object in the Running Object Table (ROT)
+    /// without registry/CLSID class factory registration. Used for lightweight cross-process automation.
+    /// Pattern: create instance -> register with moniker -> wait until Stop.
+    /// Threading: spins up a dedicated STA thread so objects needing STA semantics are safe.
+    /// </summary>
+    public sealed class RotSingletonHost : IDisposable
+    {
+        private readonly Lock _sync = new();
+        private readonly Func<object> _factory;
+        private readonly string _monikerName;
+        private readonly string _threadName;
+        private readonly ManualResetEvent _shutdown = new(false);
+
+        private Thread? _thread;
+        private int _rotCookie;
+        private object? _instance; // keep alive
+        private IMoniker? _moniker;
+        private bool _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RotSingletonHost"/> class.
+        /// </summary>
+        /// <param name="monikerName">Moniker name (logical unique id), e.g. "Awake.Automation".</param>
+        /// <param name="factory">Factory that creates the object to expose. Should return a COM-visible object.</param>
+        /// <param name="threadName">Optional thread name for diagnostics.</param>
+        public RotSingletonHost(string monikerName, Func<object> factory, string? threadName = null)
+        {
+            _monikerName = string.IsNullOrWhiteSpace(monikerName) ? throw new ArgumentException("Moniker required", nameof(monikerName)) : monikerName;
+            _factory = factory ?? throw new ArgumentNullException(nameof(factory));
+            _threadName = threadName ?? $"RotHost:{_monikerName}";
+        }
+
+        public bool IsRunning => _thread != null;
+
+        public string MonikerName => _monikerName;
+
+        public void Start()
+        {
+            lock (_sync)
+            {
+                if (_disposed)
+                {
+                    ObjectDisposedException.ThrowIf(_disposed, this);
+                }
+
+                if (_thread != null)
+                {
+                    return; // already running
+                }
+
+                _thread = new Thread(ThreadMain)
+                {
+                    IsBackground = true,
+                    Name = _threadName,
+                };
+                _thread.SetApartmentState(ApartmentState.STA);
+                _thread.Start();
+                Logger.LogInfo($"ROT host starting for moniker '{_monikerName}'");
+            }
+        }
+
+        public void Stop()
+        {
+            lock (_sync)
+            {
+                if (_thread == null)
+                {
+                    return;
+                }
+
+                _shutdown.Set();
+            }
+
+            _thread?.Join(3000);
+            _thread = null;
+            _shutdown.Reset();
+        }
+
+        private void ThreadMain()
+        {
+            int hr = Ole32.CoInitializeEx(IntPtr.Zero, Ole32.CoinitApartmentThreaded);
+            if (hr < 0)
+            {
+                Logger.LogError($"CoInitializeEx failed: 0x{hr:X8}");
+                return;
+            }
+
+            try
+            {
+                hr = Ole32.GetRunningObjectTable(0, out var rot);
+                if (hr < 0 || rot == null)
+                {
+                    Logger.LogError($"GetRunningObjectTable failed: 0x{hr:X8}");
+                    return;
+                }
+
+                hr = Ole32.CreateItemMoniker("!", _monikerName, out _moniker);
+                if (hr < 0 || _moniker == null)
+                {
+                    Logger.LogError($"CreateItemMoniker failed: 0x{hr:X8}");
+                    return;
+                }
+
+                _instance = _factory();
+                var unk = Marshal.GetIUnknownForObject(_instance);
+                try
+                {
+                    hr = rot.Register(0x1 /* ROTFLAGS_REGISTRATIONKEEPSALIVE */, _instance, _moniker, out _rotCookie);
+                    if (hr < 0)
+                    {
+                        Logger.LogError($"IRunningObjectTable.Register failed: 0x{hr:X8}");
+                        return;
+                    }
+                }
+                finally
+                {
+                    Marshal.Release(unk);
+                }
+
+                Logger.LogInfo($"ROT registered: '{_monikerName}'");
+                WaitHandle.WaitAny(new WaitHandle[] { _shutdown });
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"ROT host exception: {ex}");
+            }
+            finally
+            {
+                try
+                {
+                    if (_rotCookie != 0 && Ole32.GetRunningObjectTable(0, out var rot2) == 0 && rot2 != null)
+                    {
+                        rot2.Revoke(_rotCookie);
+                        _rotCookie = 0;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogWarning($"Exception revoking ROT registration: {ex.Message}");
+                }
+
+                Ole32.CoUninitialize();
+                Logger.LogInfo($"ROT host stopped: '{_monikerName}'");
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            Stop();
+            _disposed = true;
+        }
+
+        private static class Ole32
+        {
+            internal const int CoinitApartmentThreaded = 0x2;
+
+#pragma warning disable IL2050 // Suppress trimming warnings for COM interop P/Invokes; ROT hosting not used in trimmed scenarios.
+            [DllImport("ole32.dll")]
+            internal static extern int CoInitializeEx(IntPtr pvReserved, int dwCoInit);
+
+            [DllImport("ole32.dll")]
+            internal static extern void CoUninitialize();
+
+            [DllImport("ole32.dll")]
+            internal static extern int GetRunningObjectTable(int reserved, out IRunningObjectTable? prot);
+
+            [DllImport("ole32.dll")]
+            internal static extern int CreateItemMoniker([MarshalAs(UnmanagedType.LPWStr)] string lpszDelim, [MarshalAs(UnmanagedType.LPWStr)] string lpszItem, out IMoniker? ppmk);
+#pragma warning restore IL2050
+        }
+
+        [ComImport]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        [Guid("00000010-0000-0000-C000-000000000046")]
+        private interface IRunningObjectTable
+        {
+            int Register(int grfFlags, [MarshalAs(UnmanagedType.IUnknown)] object punkObject, IMoniker pmkObjectName, out int pdwRegister);
+
+            int Revoke(int dwRegister);
+
+            void IsRunning(IMoniker pmkObjectName);
+
+            int GetObject(IMoniker pmkObjectName, [MarshalAs(UnmanagedType.IUnknown)] out object? ppunkObject);
+
+            void NoteChangeTime(int dwRegister, ref FileTime pfiletime);
+
+            int GetTimeOfLastChange(IMoniker pmkObjectName, ref FileTime pfiletime);
+
+            int EnumRunning(out object ppenumMoniker);
+        }
+
+        [ComImport]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        [Guid("0000000f-0000-0000-C000-000000000046")]
+        private interface IMoniker
+        {
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct FileTime
+        {
+            public uint DwLowDateTime;
+            public uint DwHighDateTime;
+        }
+    }
+}

src/common/ManagedCommon/ServerStatusResponse.cs

@@ -0,0 +1,26 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+
+namespace ManagedCommon
+{
+    public sealed class ServerStatusResponse
+    {
+        public string Application { get; set; } = string.Empty;
+
+        public string? Version { get; set; }
+
+        public string Status { get; set; } = string.Empty;
+
+        public IEnumerable<string> RegisteredModules { get; set; } = [];
+
+        public string[] AvailableEndpoints { get; set; } = [];
+
+        public DateTimeOffset Timestamp { get; set; }
+    }
+}

src/modules/MCPServer/MCPServer/MCPServer.csproj

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\Common.SelfContained.props" />
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <UseWindowsForms>false</UseWindowsForms>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <AssemblyName>PowerToys.MCPServer</AssemblyName>
+    <AssemblyDescription>PowerToys MCP Server for Model Context Protocol</AssemblyDescription>
+    <DisableWinExeOutputInference>true</DisableWinExeOutputInference>
+    <OutputPath>..\..\..\..\$(Platform)\$(Configuration)</OutputPath>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <NoWin32Manifest>true</NoWin32Manifest>
+    <RootNamespace>PowerToys.MCPServer</RootNamespace>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <!-- CsWinRT configuration -->
+  <PropertyGroup>
+    <CsWinRTIncludes>PowerToys.GPOWrapper</CsWinRTIncludes>
+    <CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
+    <ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Core dependencies -->
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+	<PackageReference Include="ModelContextProtocol " />
+    <PackageReference Include="Microsoft.Data.Sqlite" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- PowerToys project references -->
+    <ProjectReference Include="..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+    <ProjectReference Include="..\..\..\common\GPOWrapper\GPOWrapper.vcxproj" />
+    <ProjectReference Include="..\..\..\settings-ui\Settings.UI.Library\Settings.UI.Library.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+</Project>

src/modules/MCPServer/MCPServer/Program.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.ComponentModel;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Server;
+using PowerToys.MCPServer.Tools;
+
+namespace MCPServer
+{
+    internal sealed class Program
+    {
+        private static async Task<int> Main(string[] args)
+        {
+            var builder = Host.CreateApplicationBuilder(args);
+            builder.Logging.AddConsole(consoleLogOptions =>
+            {
+                // Configure all logs to go to stderr
+                consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
+            });
+            builder.Services
+                .AddMcpServer()
+                .WithStdioServerTransport()
+                .WithToolsFromAssembly();
+            await builder.Build().RunAsync();
+
+            return 0;
+        }
+    }
+}

src/modules/MCPServer/MCPServer/Tools/AwakeTools.cs

@@ -0,0 +1,312 @@
+// 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.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Data.Sqlite;
+using Microsoft.PowerToys.Settings.UI.Library;
+using ModelContextProtocol.Server;
+
+namespace PowerToys.MCPServer.Tools
+{
+    [McpServerToolType]
+    public static class AwakeTools
+    {
+        [McpServerTool]
+        [Description("Echoes the message back to the client.")]
+        public static string SetTimeTest(string message) => $"Hello {message}";
+
+        // =============================
+        // HTTP client (Awake remote control)
+        // =============================
+        private static readonly HttpClient _http = new HttpClient();
+
+        // Base URL for Awake HTTP server. Default matches Awake --http-port default (8080).
+        // Allow override through environment variable POWERTOYS_AWAKE_HTTP (e.g. http://localhost:9090/)
+        private static string BaseUrl => (Environment.GetEnvironmentVariable("POWERTOYS_AWAKE_HTTP") ?? "http://localhost:8080/").TrimEnd('/') + "/";
+
+        private static string JsonError(string msg, int? status = null) => JsonSerializer.Serialize(new { success = false, error = msg, status });
+
+        private static string JsonOk(object payload) => JsonSerializer.Serialize(payload);
+
+        private static string SendAwakeRequest(string method, string relativePath, object? body = null)
+        {
+            try
+            {
+                using var req = new HttpRequestMessage(new HttpMethod(method), BaseUrl + relativePath.TrimStart('/'));
+                if (body != null)
+                {
+                    string json = JsonSerializer.Serialize(body);
+                    req.Content = new StringContent(json, Encoding.UTF8, "application/json");
+                }
+
+                using var resp = _http.Send(req);
+                string respText = resp.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+                if (!resp.IsSuccessStatusCode)
+                {
+                    return JsonError($"HTTP {(int)resp.StatusCode} {resp.StatusCode}", (int)resp.StatusCode) + "\n" + respText;
+                }
+
+                return respText;
+            }
+            catch (HttpRequestException ex)
+            {
+                return JsonError($"Connection failed: {ex.Message}. Ensure Awake is running with --http-server.");
+            }
+            catch (Exception ex)
+            {
+                return JsonError(ex.Message);
+            }
+        }
+
+        [McpServerTool]
+        [Description("RECOMMENDED FOR BUILDS: Intelligently keeps the system awake during build, compile, download, or process operations. Monitors CPU/memory/network activity and prevents sleep only when system is actively working. Automatically returns to sleep when build completes. PREFERRED over indefinite mode for development workflows. Params: cpuThresholdPercent (0-100), memThresholdPercent (0-100), netThresholdKBps (KB/s), sampleIntervalSeconds (>0), inactivityTimeoutSeconds (>0), keepDisplayOn=true|false")]
+        public static string AwakeHttpActivityBased(uint cpuThresholdPercent = 50, uint memThresholdPercent = 50, uint netThresholdKBps = 10, uint sampleIntervalSeconds = 30, uint inactivityTimeoutSeconds = 300, bool keepDisplayOn = true)
+        {
+            if (cpuThresholdPercent > 100)
+            {
+                return JsonError("cpuThresholdPercent must be 0-100");
+            }
+
+            if (memThresholdPercent > 100)
+            {
+                return JsonError("memThresholdPercent must be 0-100");
+            }
+
+            if (sampleIntervalSeconds == 0)
+            {
+                return JsonError("sampleIntervalSeconds must be > 0");
+            }
+
+            if (inactivityTimeoutSeconds == 0)
+            {
+                return JsonError("inactivityTimeoutSeconds must be > 0");
+            }
+
+            return SendAwakeRequest("POST", "awake/activity", new
+            {
+                cpuThresholdPercent,
+                memThresholdPercent,
+                netThresholdKBps,
+                sampleIntervalSeconds,
+                inactivityTimeoutSeconds,
+                keepDisplayOn,
+            });
+        }
+
+        [McpServerTool]
+        [Description("Get Awake HTTP status (GET /awake/status). Requires Awake launched with --http-server.")]
+        public static string AwakeHttpStatus() => SendAwakeRequest("GET", "awake/status");
+
+        [McpServerTool]
+        [Description("Keeps the system awake indefinitely until manually changed. WARNING: Less efficient than activity-based mode for builds. Use only when you need guaranteed continuous awake state regardless of system activity. Params: keepDisplayOn=true|false, processId=0")]
+        public static string AwakeHttpIndefinite(bool keepDisplayOn = true, int processId = 0)
+            => SendAwakeRequest("POST", "awake/indefinite", new { keepDisplayOn, processId });
+
+        [McpServerTool]
+        [Description("Set timed keep-awake via HTTP. Params: seconds (>0), keepDisplayOn=true|false")]
+        public static string AwakeHttpTimed(uint seconds, bool keepDisplayOn = true)
+        {
+            if (seconds == 0)
+            {
+                return JsonError("seconds must be > 0");
+            }
+
+            return SendAwakeRequest("POST", "awake/timed", new { seconds, keepDisplayOn });
+        }
+
+        [McpServerTool]
+        [Description("Set expirable keep-awake via HTTP. Params: expireAt (ISO 8601), keepDisplayOn=true|false")]
+        public static string AwakeHttpExpirable(string expireAt, bool keepDisplayOn = true)
+        {
+            if (string.IsNullOrWhiteSpace(expireAt))
+            {
+                return JsonError("expireAt required (ISO 8601)");
+            }
+
+            return SendAwakeRequest("POST", "awake/expirable", new { expireAt, keepDisplayOn });
+        }
+
+        [McpServerTool]
+        [Description("Set passive mode via HTTP (POST /awake/passive).")]
+        public static string AwakeHttpPassive() => SendAwakeRequest("POST", "awake/passive");
+
+        [McpServerTool]
+        [Description("Toggle display keep-on via HTTP (POST /awake/display/toggle).")]
+        public static string AwakeHttpToggleDisplay() => SendAwakeRequest("POST", "awake/display/toggle");
+
+        [McpServerTool]
+        [Description("Get Awake settings via HTTP (GET /awake/settings).")]
+        public static string AwakeHttpSettings() => SendAwakeRequest("GET", "awake/settings");
+
+        [McpServerTool]
+        [Description("Check current PowerToys Awake mode and configuration. Returns active mode (indefinite, timed, activity-based, or passive), remaining time, thresholds, and display settings. Use to verify if system is being kept awake and what settings are active.")]
+        public static string AwakeHttpConfig() => SendAwakeRequest("GET", "awake/config");
+
+        private sealed class AppUsageRecord
+        {
+            [JsonPropertyName("process")]
+            public string ProcessName { get; set; } = string.Empty;
+
+            [JsonPropertyName("totalSeconds")]
+            public double TotalSeconds { get; set; }
+
+            [JsonPropertyName("lastUpdatedUtc")]
+            public DateTime LastUpdatedUtc { get; set; }
+
+            [JsonPropertyName("firstSeenUtc")]
+            public DateTime FirstSeenUtc { get; set; }
+        }
+
+        [McpServerTool]
+        [Description("Get top N foreground app usage entries recorded by Awake. Reads usage.sqlite if present (preferred) else legacy usage.json. Parameters: top (default 10), days (default 7). Returns JSON array.")]
+        public static string GetAwakeUsageSummary(int top = 10, int days = 7)
+        {
+            try
+            {
+                SettingsUtils utils = new();
+                string settingsPath = utils.GetSettingsFilePath("Awake");
+                string directory = Path.GetDirectoryName(settingsPath)!;
+                string sqlitePath = Path.Combine(directory, "usage.sqlite");
+                string legacyJson = Path.Combine(directory, "usage.json");
+
+                if (File.Exists(sqlitePath))
+                {
+                    return QuerySqlite(sqlitePath, top, days);
+                }
+
+                if (File.Exists(legacyJson))
+                {
+                    return QueryLegacyJson(legacyJson, top, days, note: "legacy-json");
+                }
+
+                return JsonSerializer.Serialize(new { error = "No usage data found", sqlite = sqlitePath, legacy = legacyJson });
+            }
+            catch (Exception ex)
+            {
+                return JsonSerializer.Serialize(new { error = ex.Message });
+            }
+        }
+
+        private static string QuerySqlite(string dbPath, int top, int days)
+        {
+            try
+            {
+                int safeDays = Math.Max(1, days);
+                using SqliteConnection conn = new(new SqliteConnectionStringBuilder { DataSource = dbPath, Mode = SqliteOpenMode.ReadOnly }.ToString());
+                conn.Open();
+                using SqliteCommand cmd = conn.CreateCommand();
+                cmd.CommandText = @"SELECT process_name, SUM(total_seconds) AS total_seconds, MIN(first_seen_utc) AS first_seen_utc, MAX(last_updated_utc) AS last_updated_utc
+FROM process_usage
+WHERE day_utc >= date('now', @cutoff)
+GROUP BY process_name
+ORDER BY total_seconds DESC
+LIMIT @top;";
+                cmd.Parameters.AddWithValue("@cutoff", $"-{safeDays} days");
+                cmd.Parameters.AddWithValue("@top", top);
+
+                var list = cmd.ExecuteReader()
+                    .Cast<System.Data.Common.DbDataRecord>()
+                    .Select(r => new AppUsageRecord
+                    {
+                        ProcessName = r.GetString(0),
+                        TotalSeconds = r.GetDouble(1),
+                        FirstSeenUtc = DateTime.Parse(r.GetString(2), null, System.Globalization.DateTimeStyles.RoundtripKind),
+                        LastUpdatedUtc = DateTime.Parse(r.GetString(3), null, System.Globalization.DateTimeStyles.RoundtripKind),
+                    })
+                    .OrderByDescending(r => r.TotalSeconds)
+                    .Select(r => new
+                    {
+                        process = r.ProcessName,
+                        totalSeconds = Math.Round(r.TotalSeconds, 1),
+                        totalHours = Math.Round(r.TotalSeconds / 3600.0, 2),
+                        firstSeenUtc = r.FirstSeenUtc,
+                        lastUpdatedUtc = r.LastUpdatedUtc,
+                        source = "sqlite",
+                    });
+
+                return JsonSerializer.Serialize(list);
+            }
+            catch (Exception ex)
+            {
+                return JsonSerializer.Serialize(new { error = "sqlite query failed", message = ex.Message, path = dbPath });
+            }
+        }
+
+        private static string QueryLegacyJson(string usageFile, int top, int days, string? note = null)
+        {
+            try
+            {
+                string json = File.ReadAllText(usageFile);
+                using JsonDocument doc = JsonDocument.Parse(json);
+                DateTime cutoff = DateTime.UtcNow.AddDays(-Math.Max(1, days));
+                var result = doc.RootElement
+                    .EnumerateArray()
+                    .Select(e => new
+                    {
+                        process = e.GetPropertyOrDefault("process", string.Empty),
+                        totalSeconds = e.GetPropertyOrDefault("totalSeconds", 0.0),
+                        lastUpdatedUtc = e.GetPropertyOrDefaultDateTime("lastUpdatedUtc"),
+                        firstSeenUtc = e.GetPropertyOrDefaultDateTime("firstSeenUtc"),
+                    })
+                    .Where(r => r.lastUpdatedUtc >= cutoff)
+                    .OrderByDescending(r => r.totalSeconds)
+                    .Take(top)
+                    .Select(r => new
+                    {
+                        r.process,
+                        totalSeconds = Math.Round(r.totalSeconds, 1),
+                        totalHours = Math.Round(r.totalSeconds / 3600.0, 2),
+                        r.firstSeenUtc,
+                        r.lastUpdatedUtc,
+                        source = note ?? "json",
+                    });
+                return JsonSerializer.Serialize(result);
+            }
+            catch (Exception ex)
+            {
+                return JsonSerializer.Serialize(new { error = "legacy json read failed", message = ex.Message, path = usageFile });
+            }
+        }
+
+        private static string GetPropertyOrDefault(this JsonElement element, string name, string defaultValue)
+        {
+            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out JsonElement value) && value.ValueKind == JsonValueKind.String)
+            {
+                return value.GetString() ?? defaultValue;
+            }
+
+            return defaultValue;
+        }
+
+        private static double GetPropertyOrDefault(this JsonElement element, string name, double defaultValue)
+        {
+            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out JsonElement value) && value.ValueKind == JsonValueKind.Number && value.TryGetDouble(out double d))
+            {
+                return d;
+            }
+
+            return defaultValue;
+        }
+
+        private static DateTime GetPropertyOrDefaultDateTime(this JsonElement element, string name)
+        {
+            if (element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out JsonElement value))
+            {
+                if (value.ValueKind == JsonValueKind.String && value.TryGetDateTime(out DateTime dt))
+                {
+                    return dt;
+                }
+            }
+
+            return DateTime.MinValue;
+        }
+    }
+}

src/modules/MCPServer/MCPServer/Tools/EchoTool.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 System.ComponentModel;
+using ModelContextProtocol.Server;
+
+namespace PowerToys.MCPServer.Tools
+{
+    [McpServerToolType]
+    public static class EchoTool
+    {
+        [McpServerTool]
+        [Description("Echoes the message back to the client.")]
+        public static string Echo(string message) => $"Hello {message}";
+    }
+}

src/modules/MCPServer/MCPServer/appsettings.json

@@ -0,0 +1,18 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information",
+      "PowerToys.MCPServer": "Debug"
+    }
+  },
+  "MCPServer": {
+    "Port": 8080,
+    "MaxConcurrentConnections": 100,
+    "RequestTimeoutSeconds": 30,
+    "EnableTools": true,
+    "EnableResources": true,
+    "Transport": "http"
+  }
+}

src/modules/MCPServer/MCPServerModuleInterface/MCPServerModuleInterface.def

@@ -0,0 +1,2 @@
+EXPORTS
+powertoy_create

src/modules/MCPServer/MCPServerModuleInterface/MCPServerModuleInterface.vcxproj

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\..\..\Common.Cpp.props" />
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <ProjectGuid>{A8B8D654-8F2A-4E6C-9B4F-1234567890AB}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>MCPServerModuleInterface</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <ModuleDefinitionFile>MCPServerModuleInterface.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="MCPServerModuleInterface.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\common\SettingsAPI\SettingsAPI.vcxproj" />
+    <ProjectReference Include="..\..\..\..\common\logger\logger.vcxproj" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

src/modules/MCPServer/MCPServerModuleInterface/dllmain.cpp

@@ -0,0 +1,298 @@
+#include "pch.h"
+#include <interface/powertoy_module_interface.h>
+#include <common/logger/logger.h>
+#include <common/utils/resources.h>
+#include <common/SettingsAPI/settings_objects.h>
+#include <common/utils/winapi_error.h>
+#include <shellapi.h>
+
+namespace NonLocalizable
+{
+    const wchar_t ModulePath[] = L"PowerToys.MCPServer.exe";
+    const wchar_t ModuleKey[] = L"MCPServer";
+}
+
+BOOL APIENTRY DllMain(HMODULE /*hModule*/, DWORD ul_reason_for_call, LPVOID /*lpReserved*/)
+{
+    switch (ul_reason_for_call)
+    {
+    case DLL_PROCESS_ATTACH:
+        break;
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+    return TRUE;
+}
+
+class MCPServerModuleInterface : public PowertoyModuleIface
+{
+public:
+    virtual PCWSTR get_name() override
+    {
+        return app_name.c_str();
+    }
+
+    virtual const wchar_t* get_key() override
+    {
+        return app_key.c_str();
+    }
+
+    virtual powertoys_gpo::gpo_rule_configured_t gpo_policy_enabled_configuration() override
+    {
+        return powertoys_gpo::gpo_rule_configured_t::gpo_rule_configured_not_configured;
+    }
+
+    virtual bool get_config(wchar_t* buffer, int* buffer_size) override
+    {
+        HINSTANCE hinstance = reinterpret_cast<HINSTANCE>(&__ImageBase);
+        PowerToysSettings::Settings settings(hinstance, get_name());
+        
+        settings.set_description(L"MCP Server provides Model Context Protocol access to PowerToys functionality for AI assistants and tools");
+        settings.set_icon_key(L"pt-mcp-server");
+
+        // Port configuration
+        settings.add_int_spinner(
+            L"port",
+            L"Server Port",
+            m_port,
+            1024,
+            65535,
+            1);
+
+        // Auto start option
+        settings.add_bool_toggle(
+            L"auto_start",
+            L"Auto Start Server",
+            m_auto_start);
+
+        // Enable tools API
+        settings.add_bool_toggle(
+            L"enable_tools",
+            L"Enable Tools API",
+            m_enable_tools);
+
+        // Enable resources API
+        settings.add_bool_toggle(
+            L"enable_resources",
+            L"Enable Resources API", 
+            m_enable_resources);
+
+        // Transport protocol
+        settings.add_dropdown(
+            L"transport",
+            L"Transport Protocol",
+            m_transport,
+            std::vector<std::pair<std::wstring, std::wstring>>{
+                { L"http", L"HTTP" },
+                { L"stdio", L"Standard I/O" },
+                { L"tcp", L"TCP Socket" }
+            });
+
+        return settings.serialize_to_buffer(buffer, buffer_size);
+    }
+
+    virtual void set_config(const wchar_t* config) override
+    {
+        try
+        {
+            PowerToysSettings::PowerToyValues values =
+                PowerToysSettings::PowerToyValues::from_json_string(config, get_key());
+
+            if (auto port = values.get_int_value(L"port"))
+            {
+                m_port = port.value();
+            }
+
+            if (auto auto_start = values.get_bool_value(L"auto_start"))
+            {
+                m_auto_start = auto_start.value();
+            }
+
+            if (auto enable_tools = values.get_bool_value(L"enable_tools"))
+            {
+                m_enable_tools = enable_tools.value();
+            }
+
+            if (auto enable_resources = values.get_bool_value(L"enable_resources"))
+            {
+                m_enable_resources = enable_resources.value();
+            }
+
+            if (auto transport = values.get_string_value(L"transport"))
+            {
+                m_transport = transport.value();
+            }
+
+            values.save_to_settings_file();
+            
+            // If service is running, restart to apply new configuration
+            if (m_enabled && is_process_running())
+            {
+                StopMCPServer();
+                StartMCPServer();
+            }
+        }
+        catch (std::exception& e)
+        {
+            Logger::error("MCPServer configuration parsing failed: {}", std::string{ e.what() });
+        }
+    }
+
+    virtual void enable() override
+    {
+        Logger::info("MCPServer enabling");
+        m_enabled = true;
+        if (m_auto_start)
+        {
+            StartMCPServer();
+        }
+    }
+
+    virtual void disable() override
+    {
+        Logger::info("MCPServer disabling");
+        m_enabled = false;
+        StopMCPServer();
+    }
+
+    virtual bool is_enabled() override
+    {
+        return m_enabled;
+    }
+
+    virtual void destroy() override
+    {
+        StopMCPServer();
+        delete this;
+    }
+
+    MCPServerModuleInterface()
+    {
+        app_name = L"MCP Server";
+        app_key = NonLocalizable::ModuleKey;
+        m_port = 8080;
+        m_auto_start = true;
+        m_enable_tools = true;
+        m_enable_resources = true;
+        m_transport = L"http";
+        init_settings();
+    }
+
+private:
+    void StartMCPServer()
+    {
+        if (m_hProcess && WaitForSingleObject(m_hProcess, 0) == WAIT_TIMEOUT)
+        {
+            return; // Already running
+        }
+
+        std::wstring executable_args = L"--port=" + std::to_wstring(m_port);
+        
+        if (!m_enable_tools)
+        {
+            executable_args += L" --disable-tools";
+        }
+        
+        if (!m_enable_resources)
+        {
+            executable_args += L" --disable-resources";
+        }
+
+        if (!m_transport.empty())
+        {
+            executable_args += L" --transport=" + m_transport;
+        }
+
+        SHELLEXECUTEINFOW sei{ sizeof(sei) };
+        sei.fMask = { SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI };
+        sei.lpFile = NonLocalizable::ModulePath;
+        sei.nShow = SW_HIDE;
+        sei.lpParameters = executable_args.data();
+        
+        if (ShellExecuteExW(&sei))
+        {
+            m_hProcess = sei.hProcess;
+            Logger::info("MCPServer started successfully on port {} with transport {}", m_port, std::string(m_transport.begin(), m_transport.end()));
+        }
+        else
+        {
+            Logger::error("Failed to start MCPServer");
+            auto message = get_last_error_message(GetLastError());
+            if (message.has_value())
+            {
+                Logger::error(message.value());
+            }
+        }
+    }
+
+    void StopMCPServer()
+    {
+        if (m_hProcess)
+        {
+            TerminateProcess(m_hProcess, 0);
+            CloseHandle(m_hProcess);
+            m_hProcess = nullptr;
+            Logger::info("MCPServer stopped");
+        }
+    }
+
+    bool is_process_running()
+    {
+        return m_hProcess && WaitForSingleObject(m_hProcess, 0) == WAIT_TIMEOUT;
+    }
+
+    void init_settings()
+    {
+        try
+        {
+            PowerToysSettings::PowerToyValues settings =
+                PowerToysSettings::PowerToyValues::load_from_settings_file(get_key());
+
+            if (auto port = settings.get_int_value(L"port"))
+            {
+                m_port = port.value();
+            }
+
+            if (auto auto_start = settings.get_bool_value(L"auto_start"))
+            {
+                m_auto_start = auto_start.value();
+            }
+
+            if (auto enable_tools = settings.get_bool_value(L"enable_tools"))
+            {
+                m_enable_tools = enable_tools.value();
+            }
+
+            if (auto enable_resources = settings.get_bool_value(L"enable_resources"))
+            {
+                m_enable_resources = enable_resources.value();
+            }
+
+            if (auto transport = settings.get_string_value(L"transport"))
+            {
+                m_transport = transport.value();
+            }
+        }
+        catch (std::exception&)
+        {
+            Logger::warn(L"MCPServer settings file not found, using defaults");
+        }
+    }
+
+    std::wstring app_name;
+    std::wstring app_key;
+    bool m_enabled = false;
+    HANDLE m_hProcess = nullptr;
+    int m_port = 8080;
+    bool m_auto_start = true;
+    bool m_enable_tools = true;
+    bool m_enable_resources = true;
+    std::wstring m_transport = L"http";
+};
+
+extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create()
+{
+    return new MCPServerModuleInterface();
+}

src/modules/MCPServer/MCPServerModuleInterface/pch.cpp

@@ -0,0 +1 @@
+#include "pch.h"

src/modules/MCPServer/MCPServerModuleInterface/pch.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "targetver.h"
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+#include <unknwn.h>
+#include <restrictederrorinfo.h>
+#include <hstring.h>
+#include <string>
+#include <vector>

src/modules/MCPServer/MCPServerModuleInterface/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

src/modules/MeasureTool/MeasureToolCore/PowerToys.MeasureToolCore.vcxproj

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" />
+  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.props')" />
   <Import Project="..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.props')" />
   <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" />
   <PropertyGroup Label="Globals">
@@ -147,13 +141,7 @@
     <Import Project="..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" />
+    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.targets')" />
   </ImportGroup>
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
@@ -165,19 +153,7 @@
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.props'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4188\build\Microsoft.Windows.SDK.BuildTools.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.1.8.250907003\build\native\Microsoft.WindowsAppSDK.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets'))" />    
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.props'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.1.7.250513003\build\native\Microsoft.WindowsAppSDK.targets'))" />
   </Target>
 </Project>

src/modules/MeasureTool/MeasureToolCore/packages.config

@@ -4,14 +4,5 @@
   <package id="Microsoft.Windows.CppWinRT" version="2.0.240111.5" targetFramework="native" />
   <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.231216.1" targetFramework="native" />
   <package id="Microsoft.Windows.SDK.BuildTools" version="10.0.26100.4188" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK" version="1.8.250907003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Base" version="1.8.250831001" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Foundation" version="1.8.250906002" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.WinUI" version="1.8.250906003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Runtime" version="1.8.250907003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.DWrite" version="1.8.25090401" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.InteractiveExperiences" version="1.8.250906004" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Widgets" version="1.8.250904007" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.AI" version="1.8.37" targetFramework="native" />
-  <package id="Microsoft.Windows.SDK.BuildTools.MSIX" version="1.7.20250829.1" targetFramework="native" />
+  <package id="Microsoft.WindowsAppSDK" version="1.7.250513003" targetFramework="native" />
 </packages>

src/modules/MouseUtils/MousePointerCrosshairs/dllmain.cpp

@@ -33,7 +33,6 @@ namespace
     const wchar_t JSON_KEY_AUTO_ACTIVATE[] = L"auto_activate";
     const wchar_t JSON_KEY_GLIDE_TRAVEL_SPEED[] = L"gliding_travel_speed";
     const wchar_t JSON_KEY_GLIDE_DELAY_SPEED[] = L"gliding_delay_speed";
-    const wchar_t JSON_KEY_GLIDING_CURSOR_ENABLED[] = L"gliding_cursor_enabled";
 }
 
 extern "C" IMAGE_DOS_HEADER __ImageBase;
@@ -107,9 +106,6 @@ private:
     // Gliding cursor state machine
     std::atomic<int> m_glideState{ 0 }; // 0..4 like the AHK script
 
-    // Gliding cursor enabled state
-    bool m_glidingCursorEnabled = true;
-
     // Timer configuration: 10ms tick, speeds are defined per 200ms base window
     static constexpr int kTimerTickMs = 10;
     static constexpr int kBaseSpeedTickMs = 200; // mapping period for configured pixel counts
@@ -391,11 +387,6 @@ private:
 
     void HandleGlidingHotkey()
     {
-        if (!m_glidingCursorEnabled)
-        {
-            return;
-        }
-        
         auto s = m_state;
         if (!s)
         {
@@ -743,17 +734,6 @@ private:
                     m_state->slowVSpeed = 5;
                 }
             }
-            try
-            {
-                // Parse Gliding Cursor Enabled
-                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_GLIDING_CURSOR_ENABLED);
-                m_glidingCursorEnabled = jsonPropertiesObject.GetNamedBoolean(JSON_KEY_VALUE);
-            }
-            catch (...)
-            {
-                Logger::info("Failed to initialize gliding cursor enabled from settings. Using default true.");
-                m_glidingCursorEnabled = true;
-            }
         }
         else
         {

src/modules/MouseWithoutBorders/App/Class/Common.InitAndCleanup.cs

@@ -0,0 +1,284 @@
+// 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 System.Net.NetworkInformation;
+using System.Security.Cryptography;
+using System.Threading;
+
+// <summary>
+//     Initialization and clean up.
+// </summary>
+// <history>
+//     2008 created by Truong Do (ductdo).
+//     2009-... modified by Truong Do (TruongDo).
+//     2023- Included in PowerToys.
+// </history>
+using Microsoft.Win32;
+using MouseWithoutBorders.Class;
+using MouseWithoutBorders.Core;
+using MouseWithoutBorders.Form;
+using Windows.UI.Input.Preview.Injection;
+
+using Thread = MouseWithoutBorders.Core.Thread;
+
+namespace MouseWithoutBorders
+{
+    internal partial class Common
+    {
+        private static bool initDone;
+        internal static int REOPEN_WHEN_WSAECONNRESET = -10054;
+        internal static int REOPEN_WHEN_HOTKEY = -10055;
+        internal static int PleaseReopenSocket;
+        internal static bool ReopenSocketDueToReadError;
+
+        internal static DateTime LastResumeSuspendTime { get; set; } = DateTime.UtcNow;
+
+        internal static bool InitDone
+        {
+            get => Common.initDone;
+            set => Common.initDone = value;
+        }
+
+        internal static void UpdateMachineTimeAndID()
+        {
+            Common.MachineName = Common.MachineName.Trim();
+            _ = MachineStuff.MachinePool.TryUpdateMachineID(Common.MachineName, Common.MachineID, true);
+        }
+
+        private static void InitializeMachinePoolFromSettings()
+        {
+            try
+            {
+                MachineInf[] info = MachinePoolHelpers.LoadMachineInfoFromMachinePoolStringSetting(Setting.Values.MachinePoolString);
+                for (int i = 0; i < info.Length; i++)
+                {
+                    info[i].Name = info[i].Name.Trim();
+                }
+
+                MachineStuff.MachinePool.Initialize(info);
+                MachineStuff.MachinePool.ResetIPAddressesForDeadMachines(true);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log(ex);
+                MachineStuff.MachinePool.Clear();
+            }
+        }
+
+        internal static void SetupMachineNameAndID()
+        {
+            try
+            {
+                GetMachineName();
+                DesMachineID = MachineStuff.NewDesMachineID = MachineID;
+
+                // MessageBox.Show(machineID.ToString(CultureInfo.CurrentCulture)); // For test
+                InitializeMachinePoolFromSettings();
+
+                Common.MachineName = Common.MachineName.Trim();
+                _ = MachineStuff.MachinePool.LearnMachine(Common.MachineName);
+                _ = MachineStuff.MachinePool.TryUpdateMachineID(Common.MachineName, Common.MachineID, true);
+
+                MachineStuff.UpdateMachinePoolStringSetting();
+            }
+            catch (Exception e)
+            {
+                Logger.Log(e);
+            }
+        }
+
+        internal static void Init()
+        {
+            _ = Helper.GetUserName();
+            Common.GeneratedKey = true;
+
+            try
+            {
+                Common.MyKey = Setting.Values.MyKey;
+                int tmp = Setting.Values.MyKeyDaysToExpire;
+            }
+            catch (FormatException e)
+            {
+                Common.KeyCorrupted = true;
+                Setting.Values.MyKey = Common.MyKey = Common.CreateRandomKey();
+                Logger.Log(e.Message);
+            }
+            catch (CryptographicException e)
+            {
+                Common.KeyCorrupted = true;
+                Setting.Values.MyKey = Common.MyKey = Common.CreateRandomKey();
+                Logger.Log(e.Message);
+            }
+
+            try
+            {
+                InputSimulation.Injector = InputInjector.TryCreate();
+                if (InputSimulation.Injector != null)
+                {
+                    InputSimulation.MoveMouseRelative(0, 0);
+                    NativeMethods.InjectMouseInputAvailable = true;
+                }
+            }
+            catch (EntryPointNotFoundException)
+            {
+                NativeMethods.InjectMouseInputAvailable = false;
+                Logger.Log($"{nameof(NativeMethods.InjectMouseInputAvailable)} = false");
+            }
+
+            bool dummy = Setting.Values.DrawMouseEx;
+            Is64bitOS = IntPtr.Size == 8;
+            tcpPort = Setting.Values.TcpPort;
+            GetScreenConfig();
+            PackageSent = new PackageMonitor(0);
+            PackageReceived = new PackageMonitor(0);
+            SetupMachineNameAndID();
+            InitEncryption();
+            CreateHelperThreads();
+
+            SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);
+            NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkChange_NetworkAvailabilityChanged);
+            SystemEvents.PowerModeChanged += new PowerModeChangedEventHandler(SystemEvents_PowerModeChanged);
+            PleaseReopenSocket = 9;
+            /* TODO: Telemetry for the matrix? */
+        }
+
+        private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        {
+            Helper.WndProcCounter++;
+
+            if (e.Mode is PowerModes.Resume or PowerModes.Suspend)
+            {
+                Logger.TelemetryLogTrace($"{nameof(SystemEvents_PowerModeChanged)}: {e.Mode}", SeverityLevel.Information);
+                LastResumeSuspendTime = DateTime.UtcNow;
+                MachineStuff.SwitchToMultipleMode(false, true);
+            }
+        }
+
+        private static void CreateHelperThreads()
+        {
+            // NOTE(@yuyoyuppe): service crashes while trying to obtain this info, disabling.
+            /*
+            Thread watchDogThread = new(new ThreadStart(WatchDogThread), nameof(WatchDogThread));
+            watchDogThread.Priority = ThreadPriority.Highest;
+            watchDogThread.Start();
+            */
+
+            helper = new Thread(new ThreadStart(Helper.HelperThread), "Helper Thread");
+            helper.SetApartmentState(ApartmentState.STA);
+            helper.Start();
+        }
+
+        private static void AskHelperThreadsToExit(int waitTime)
+        {
+            Helper.signalHelperToExit = true;
+            Helper.signalWatchDogToExit = true;
+            _ = EvSwitch.Set();
+
+            int c = 0;
+            if (helper != null && c < waitTime)
+            {
+                while (Helper.signalHelperToExit)
+                {
+                    Thread.Sleep(1);
+                }
+
+                helper = null;
+            }
+        }
+
+        internal static void Cleanup()
+        {
+            try
+            {
+                SendByeBye();
+
+                // UnhookClipboard();
+                AskHelperThreadsToExit(500);
+                MainForm.NotifyIcon.Visible = false;
+                MainForm.NotifyIcon.Dispose();
+                CloseAllFormsAndHooks();
+
+                DoSomethingInUIThread(() =>
+                {
+                    Sk?.Close(true);
+                });
+            }
+            catch (Exception e)
+            {
+                Logger.Log(e);
+            }
+        }
+
+        private static long lastReleaseAllKeysCall;
+
+        internal static void ReleaseAllKeys()
+        {
+            if (Math.Abs(GetTick() - lastReleaseAllKeysCall) < 2000)
+            {
+                return;
+            }
+
+            lastReleaseAllKeysCall = GetTick();
+
+            KEYBDDATA kd;
+            kd.dwFlags = (int)LLKHF.UP;
+
+            VK[] keys = new VK[]
+            {
+                VK.LSHIFT, VK.LCONTROL, VK.LMENU, VK.LWIN, VK.RSHIFT,
+                VK.RCONTROL, VK.RMENU, VK.RWIN, VK.SHIFT, VK.MENU, VK.CONTROL,
+            };
+
+            Logger.LogDebug("***** ReleaseAllKeys has been called! *****:");
+
+            foreach (VK vk in keys)
+            {
+                if ((NativeMethods.GetAsyncKeyState((IntPtr)vk) & 0x8000) != 0)
+                {
+                    Logger.LogDebug(vk.ToString() + " is down, release it...");
+                    Hook?.ResetLastSwitchKeys(); // Sticky key can turn ALL PC mode on (CtrlCtrlCtrl)
+                    kd.wVk = (int)vk;
+                    InputSimulation.SendKey(kd);
+                    Hook?.ResetLastSwitchKeys();
+                }
+            }
+        }
+
+        private static void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
+        {
+            Logger.LogDebug("NetworkAvailabilityEventArgs.IsAvailable: " + e.IsAvailable.ToString(CultureInfo.InvariantCulture));
+            Helper.WndProcCounter++;
+            ScheduleReopenSocketsDueToNetworkChanges(!e.IsAvailable);
+        }
+
+        private static void ScheduleReopenSocketsDueToNetworkChanges(bool closeSockets = true)
+        {
+            if (closeSockets)
+            {
+                // Slept/hibernated machine may still have the sockets' status as Connected:( (unchanged) so it would not re-connect after a timeout when waking up.
+                // Closing the sockets when it is going to sleep/hibernate will trigger the reconnection faster when it wakes up.
+                DoSomethingInUIThread(
+                    () =>
+                {
+                    SocketStuff s = Sk;
+                    Sk = null;
+                    s?.Close(false);
+                },
+                    true);
+            }
+
+            if (!Common.IsMyDesktopActive())
+            {
+                PleaseReopenSocket = 0;
+            }
+            else if (PleaseReopenSocket != 10)
+            {
+                PleaseReopenSocket = 10;
+            }
+        }
+    }
+}

src/modules/MouseWithoutBorders/App/Class/Common.WinAPI.cs

@@ -36,7 +36,7 @@ namespace MouseWithoutBorders
 
         internal static string ActiveDesktop => Common.activeDesktop;
 
-        internal static void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
+        private static void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
         {
             GetScreenConfig();
         }
@@ -340,7 +340,7 @@ namespace MouseWithoutBorders
                         Setting.Values.LastX = JUST_GOT_BACK_FROM_SCREEN_SAVER;
                         if (cleanupIfExit)
                         {
-                            InitAndCleanup.Cleanup();
+                            Common.Cleanup();
                         }
 
                         Process.GetCurrentProcess().KillProcess();

src/modules/MouseWithoutBorders/App/Class/Common.cs

@@ -33,7 +33,6 @@ using MouseWithoutBorders.Class;
 using MouseWithoutBorders.Core;
 using MouseWithoutBorders.Exceptions;
 
-using Clipboard = MouseWithoutBorders.Core.Clipboard;
 using Thread = MouseWithoutBorders.Core.Thread;
 
 // Log is enough
@@ -91,8 +90,8 @@ namespace MouseWithoutBorders
         private static FrmMatrix matrixForm;
         private static FrmInputCallback inputCallbackForm;
         private static FrmAbout aboutForm;
+        private static Thread helper;
 #pragma warning disable SA1307 // Accessible fields should begin with upper-case letter
-        internal static Thread helper;
         internal static int screenWidth;
         internal static int screenHeight;
 #pragma warning restore SA1307
@@ -122,9 +121,7 @@ namespace MouseWithoutBorders
         internal static int switchCount;
 #pragma warning restore SA1307
         private static long lastReconnectByHotKeyTime;
-#pragma warning disable SA1307 // Accessible fields should begin with upper-case names
-        internal static int tcpPort;
-#pragma warning restore SA1307
+        private static int tcpPort;
         private static bool secondOpenSocketTry;
         private static string binaryName;
 
@@ -213,7 +210,7 @@ namespace MouseWithoutBorders
 
         internal static bool Is64bitOS
         {
-            get; set;
+            get; private set;
 
             // set { Common.is64bitOS = value; }
         }
@@ -614,7 +611,7 @@ namespace MouseWithoutBorders
         }
          * */
 
-        internal static void SendByeBye()
+        private static void SendByeBye()
         {
             Logger.LogDebug($"{nameof(SendByeBye)}");
             SendPackage(ID.ALL, PackageType.ByeBye);
@@ -728,7 +725,7 @@ namespace MouseWithoutBorders
 
         internal static void SendImage(string machine, string file)
         {
-            Clipboard.LastDragDropFile = file;
+            LastDragDropFile = file;
 
             // Send ClipboardCapture
             if (machine.Equals("All", StringComparison.OrdinalIgnoreCase))
@@ -747,7 +744,7 @@ namespace MouseWithoutBorders
 
         internal static void SendImage(ID src, string file)
         {
-            Clipboard.LastDragDropFile = file;
+            LastDragDropFile = file;
 
             // Send ClipboardCapture
             SendPackage(src, PackageType.ClipboardCapture);
@@ -1294,7 +1291,7 @@ namespace MouseWithoutBorders
             });
         }
 
-        internal static string GetMyStorageDir()
+        private static string GetMyStorageDir()
         {
             string st = string.Empty;
 

src/modules/MouseWithoutBorders/App/Class/IClipboardHelper.cs

@@ -28,7 +28,6 @@ using MouseWithoutBorders.Core;
 
 using SystemClipboard = System.Windows.Forms.Clipboard;
 #if !MM_HELPER
-using Clipboard = MouseWithoutBorders.Core.Clipboard;
 using Thread = MouseWithoutBorders.Core.Thread;
 #endif
 
@@ -160,7 +159,7 @@ namespace MouseWithoutBorders
 
         public void SendClipboardData(ByteArrayOrString data, bool isFilePath)
         {
-            _ = Clipboard.CheckClipboardEx(data, isFilePath);
+            _ = Common.CheckClipboardEx(data, isFilePath);
         }
     }
 #endif

src/modules/MouseWithoutBorders/App/Class/InputHook.cs

@@ -579,7 +579,7 @@ namespace MouseWithoutBorders.Class
             {
                 Common.ShowToolTip("Reconnecting...", 2000);
                 Common.LastReconnectByHotKeyTime = Common.GetTick();
-                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_HOTKEY;
+                Common.PleaseReopenSocket = Common.REOPEN_WHEN_HOTKEY;
                 return false;
             }
 
@@ -632,7 +632,7 @@ namespace MouseWithoutBorders.Class
                 {
                     // Common.DoSomethingInUIThread(delegate()
                     {
-                        InitAndCleanup.ReleaseAllKeys();
+                        Common.ReleaseAllKeys();
                     }
 
                     // );

src/modules/MouseWithoutBorders/App/Class/InputSimulation.cs

@@ -407,7 +407,7 @@ namespace MouseWithoutBorders.Class
                     {
                         ResetModifiersState(Setting.Values.HotKeyLockMachine);
                         eatKey = true;
-                        InitAndCleanup.ReleaseAllKeys();
+                        Common.ReleaseAllKeys();
                         _ = NativeMethods.LockWorkStation();
                     }
                 }
@@ -439,7 +439,7 @@ namespace MouseWithoutBorders.Class
                         {
                             ctrlDown = altDown = false;
                             eatKey = true;
-                            InitAndCleanup.ReleaseAllKeys();
+                            Common.ReleaseAllKeys();
                         }
 
                         break;
@@ -449,7 +449,7 @@ namespace MouseWithoutBorders.Class
                         {
                             winDown = false;
                             eatKey = true;
-                            InitAndCleanup.ReleaseAllKeys();
+                            Common.ReleaseAllKeys();
                             uint rv = NativeMethods.LockWorkStation();
                             Logger.LogDebug("LockWorkStation returned " + rv.ToString(CultureInfo.CurrentCulture));
                         }

src/modules/MouseWithoutBorders/App/Class/Program.cs

@@ -235,7 +235,7 @@ namespace MouseWithoutBorders.Class
                 _ = Application.SetHighDpiMode(HighDpiMode.PerMonitorV2);
                 Application.SetCompatibleTextRenderingDefault(false);
 
-                InitAndCleanup.Init();
+                Common.Init();
                 Core.Helper.WndProcCounter++;
 
                 var formScreen = new FrmScreen();
@@ -314,7 +314,7 @@ namespace MouseWithoutBorders.Class
                 MachineStuff.UpdateMachinePoolStringSetting();
 
                 SocketStuff.InvalidKeyFound = false;
-                InitAndCleanup.ReopenSocketDueToReadError = true;
+                Common.ReopenSocketDueToReadError = true;
                 Common.ReopenSockets(true);
                 MachineStuff.SendMachineMatrix();
 
@@ -340,7 +340,7 @@ namespace MouseWithoutBorders.Class
             public void Reconnect()
             {
                 SocketStuff.InvalidKeyFound = false;
-                InitAndCleanup.ReopenSocketDueToReadError = true;
+                Common.ReopenSocketDueToReadError = true;
                 Common.ReopenSockets(true);
 
                 for (int i = 0; i < 10; i++)
@@ -397,7 +397,7 @@ namespace MouseWithoutBorders.Class
             using var asyncFlowControl = ExecutionContext.SuppressFlow();
 
             Common.InputCallbackThreadID = Thread.CurrentThread.ManagedThreadId;
-            while (!InitAndCleanup.InitDone)
+            while (!Common.InitDone)
             {
                 Thread.Sleep(100);
             }

src/modules/MouseWithoutBorders/App/Class/Setting.cs

@@ -118,7 +118,7 @@ namespace MouseWithoutBorders.Class
                         if (shouldReopenSockets)
                         {
                             SocketStuff.InvalidKeyFound = false;
-                            InitAndCleanup.ReopenSocketDueToReadError = true;
+                            Common.ReopenSocketDueToReadError = true;
                             Common.ReopenSockets(true);
                         }
 

src/modules/MouseWithoutBorders/App/Class/SocketStuff.cs

@@ -29,7 +29,6 @@ using MouseWithoutBorders.Core;
 // </history>
 using MouseWithoutBorders.Exceptions;
 
-using Clipboard = MouseWithoutBorders.Core.Clipboard;
 using Thread = MouseWithoutBorders.Core.Thread;
 
 [module: SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Scope = "member", Target = "MouseWithoutBorders.SocketStuff.#SendData(System.Byte[])", Justification = "Dotnet port with style preservation")]
@@ -282,7 +281,7 @@ namespace MouseWithoutBorders.Class
              * */
 
             Common.GetMachineName(); // IPs might have been changed
-            InitAndCleanup.UpdateMachineTimeAndID();
+            Common.UpdateMachineTimeAndID();
 
             Logger.LogDebug("Creating sockets...");
 
@@ -309,7 +308,7 @@ namespace MouseWithoutBorders.Class
                             {
                                 Logger.TelemetryLogTrace("Restarting the service dues to WSAEADDRINUSE.", SeverityLevel.Warning);
                                 Program.StartService();
-                                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_WSAECONNRESET;
+                                Common.PleaseReopenSocket = Common.REOPEN_WHEN_WSAECONNRESET;
                             }
 
                             break;
@@ -1249,7 +1248,7 @@ namespace MouseWithoutBorders.Class
             // WSAECONNRESET
             if (e is ExpectedSocketException se && se.ShouldReconnect)
             {
-                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_WSAECONNRESET;
+                Common.PleaseReopenSocket = Common.REOPEN_WHEN_WSAECONNRESET;
                 Logger.Log($"MainTCPRoutine: {nameof(FlagReopenSocketIfNeeded)}");
             }
         }
@@ -1307,7 +1306,7 @@ namespace MouseWithoutBorders.Class
             }
             catch (ObjectDisposedException e)
             {
-                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_WSAECONNRESET;
+                Common.PleaseReopenSocket = Common.REOPEN_WHEN_WSAECONNRESET;
                 UpdateTcpSockets(currentTcp, SocketStatus.ForceClosed);
                 currentSocket.Close();
                 Logger.Log($"{nameof(MainTCPRoutine)}: The socket could have been closed/disposed by other threads: {e.Message}");
@@ -1354,10 +1353,10 @@ namespace MouseWithoutBorders.Class
                              * In this case, we should give ONE try to reconnect.
                              */
 
-                            if (InitAndCleanup.ReopenSocketDueToReadError)
+                            if (Common.ReopenSocketDueToReadError)
                             {
-                                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_WSAECONNRESET;
-                                InitAndCleanup.ReopenSocketDueToReadError = false;
+                                Common.PleaseReopenSocket = Common.REOPEN_WHEN_WSAECONNRESET;
+                                Common.ReopenSocketDueToReadError = false;
                             }
 
                             break;
@@ -1642,7 +1641,7 @@ namespace MouseWithoutBorders.Class
 
                 bool clientPushData = true;
                 ClipboardPostAction postAction = ClipboardPostAction.Other;
-                bool handShaken = Clipboard.ShakeHand(ref remoteEndPoint, s, out Stream enStream, out Stream deStream, ref clientPushData, ref postAction);
+                bool handShaken = Common.ShakeHand(ref remoteEndPoint, s, out Stream enStream, out Stream deStream, ref clientPushData, ref postAction);
 
                 if (!handShaken)
                 {
@@ -1657,7 +1656,7 @@ namespace MouseWithoutBorders.Class
 
                 if (clientPushData)
                 {
-                    Clipboard.ReceiveAndProcessClipboardData(remoteEndPoint, s, enStream, deStream, $"{postAction}");
+                    Common.ReceiveAndProcessClipboardData(remoteEndPoint, s, enStream, deStream, $"{postAction}");
                 }
                 else
                 {
@@ -1681,23 +1680,23 @@ namespace MouseWithoutBorders.Class
             const int CLOSE_TIMEOUT = 10;
             byte[] header = new byte[1024];
             string headerString = string.Empty;
-            if (Clipboard.LastDragDropFile != null)
+            if (Common.LastDragDropFile != null)
             {
                 string fileName = null;
 
                 if (!Launch.ImpersonateLoggedOnUserAndDoSomething(() =>
                 {
-                    if (!File.Exists(Clipboard.LastDragDropFile))
+                    if (!File.Exists(Common.LastDragDropFile))
                     {
-                        headerString = Directory.Exists(Clipboard.LastDragDropFile)
-                            ? $"{0}*{Clipboard.LastDragDropFile} - Folder is not supported, zip it first!"
-                            : Clipboard.LastDragDropFile.Contains("- File too big")
-                                ? $"{0}*{Clipboard.LastDragDropFile}"
-                                : $"{0}*{Clipboard.LastDragDropFile} not found!";
+                        headerString = Directory.Exists(Common.LastDragDropFile)
+                            ? $"{0}*{Common.LastDragDropFile} - Folder is not supported, zip it first!"
+                            : Common.LastDragDropFile.Contains("- File too big")
+                                ? $"{0}*{Common.LastDragDropFile}"
+                                : $"{0}*{Common.LastDragDropFile} not found!";
                     }
                     else
                     {
-                        fileName = Clipboard.LastDragDropFile;
+                        fileName = Common.LastDragDropFile;
                         headerString = $"{new FileInfo(fileName).Length}*{fileName}";
                     }
                 }))
@@ -1740,11 +1739,11 @@ namespace MouseWithoutBorders.Class
                     Logger.Log(log);
                 }
             }
-            else if (!Clipboard.IsClipboardDataImage && Clipboard.LastClipboardData != null)
+            else if (!Common.IsClipboardDataImage && Common.LastClipboardData != null)
             {
                 try
                 {
-                    byte[] data = Clipboard.LastClipboardData;
+                    byte[] data = Common.LastClipboardData;
 
                     headerString = $"{data.Length}*{"text"}";
                     Common.GetBytesU(headerString).CopyTo(header, 0);
@@ -1774,9 +1773,9 @@ namespace MouseWithoutBorders.Class
                     Logger.Log(log);
                 }
             }
-            else if (Clipboard.LastClipboardData != null && Clipboard.LastClipboardData.Length > 0)
+            else if (Common.LastClipboardData != null && Common.LastClipboardData.Length > 0)
             {
-                byte[] data = Clipboard.LastClipboardData;
+                byte[] data = Common.LastClipboardData;
 
                 headerString = $"{data.Length}*{"image"}";
                 Common.GetBytesU(headerString).CopyTo(header, 0);
@@ -1985,8 +1984,8 @@ namespace MouseWithoutBorders.Class
                             {
                                 tcp = null;
                                 Setting.Values.MachineId = Common.Ran.Next();
-                                InitAndCleanup.UpdateMachineTimeAndID();
-                                InitAndCleanup.PleaseReopenSocket = InitAndCleanup.REOPEN_WHEN_HOTKEY;
+                                Common.UpdateMachineTimeAndID();
+                                Common.PleaseReopenSocket = Common.REOPEN_WHEN_HOTKEY;
 
                                 Logger.TelemetryLogTrace("MachineID conflict.", SeverityLevel.Information);
                             }

src/modules/MouseWithoutBorders/App/Core/DragDrop.cs

@@ -83,7 +83,7 @@ internal static class DragDrop
         if (wParam == Common.WM_RBUTTONUP && IsDropping)
         {
             IsDropping = false;
-            Clipboard.LastIDWithClipboardData = ID.NONE;
+            Common.LastIDWithClipboardData = ID.NONE;
         }
     }
 
@@ -193,7 +193,7 @@ internal static class DragDrop
             {
                 if (!string.IsNullOrEmpty(dragFileName) && (File.Exists(dragFileName) || Directory.Exists(dragFileName)))
                 {
-                    Clipboard.LastDragDropFile = dragFileName;
+                    Common.LastDragDropFile = dragFileName;
                     /*
                      * possibleDropMachineID is used as desID sent in DragDropStep06();
                      * */
@@ -270,7 +270,7 @@ internal static class DragDrop
             else
             {
                 IsDragging = false;
-                Clipboard.LastIDWithClipboardData = ID.NONE;
+                Common.LastIDWithClipboardData = ID.NONE;
             }
         }
     }
@@ -280,7 +280,7 @@ internal static class DragDrop
         Logger.LogDebug("DragDropStep10: Hide the form and get data...");
         IsDropping = false;
         IsDragging = false;
-        Clipboard.LastIDWithClipboardData = ID.NONE;
+        Common.LastIDWithClipboardData = ID.NONE;
 
         Common.DoSomethingInUIThread(() =>
         {
@@ -288,7 +288,7 @@ internal static class DragDrop
         });
 
         PowerToysTelemetry.Log.WriteEvent(new MouseWithoutBorders.Telemetry.MouseWithoutBordersDragAndDropEvent());
-        Clipboard.GetRemoteClipboard("desktop");
+        Common.GetRemoteClipboard("desktop");
     }
 
     internal static void DragDropStep11()
@@ -298,8 +298,8 @@ internal static class DragDrop
         IsDropping = false;
         IsDragging = false;
         DragMachine = (ID)1;
-        Clipboard.LastIDWithClipboardData = ID.NONE;
-        Clipboard.LastDragDropFile = null;
+        Common.LastIDWithClipboardData = ID.NONE;
+        Common.LastDragDropFile = null;
         MouseDown = false;
     }
 
@@ -307,7 +307,7 @@ internal static class DragDrop
     {
         Logger.LogDebug("DragDropStep12: ClipboardDragDropEnd received");
         IsDropping = false;
-        Clipboard.LastIDWithClipboardData = ID.NONE;
+        Common.LastIDWithClipboardData = ID.NONE;
 
         Common.DoSomethingInUIThread(() =>
         {

src/modules/MouseWithoutBorders/App/Core/Event.cs

@@ -78,7 +78,7 @@ internal static class Event
                 // if they are, check that there is no application running in fullscreen mode before switching.
                 if (!p.IsEmpty && Common.IsEasyMouseSwitchAllowed())
                 {
-                    Clipboard.HasSwitchedMachineSinceLastCopy = true;
+                    Common.HasSwitchedMachineSinceLastCopy = true;
 
                     Logger.LogDebug(string.Format(
                         CultureInfo.CurrentCulture,
@@ -218,10 +218,10 @@ internal static class Event
 
                 if (MachineStuff.desMachineID == Common.MachineID)
                 {
-                    if (Common.GetTick() - Clipboard.clipboardCopiedTime < Clipboard.BIG_CLIPBOARD_DATA_TIMEOUT)
+                    if (Common.GetTick() - Common.clipboardCopiedTime < Common.BIG_CLIPBOARD_DATA_TIMEOUT)
                     {
-                        Clipboard.clipboardCopiedTime = 0;
-                        Clipboard.GetRemoteClipboard("PrepareToSwitchToMachine");
+                        Common.clipboardCopiedTime = 0;
+                        Common.GetRemoteClipboard("PrepareToSwitchToMachine");
                     }
                 }
                 else

src/modules/MouseWithoutBorders/App/Core/Helper.cs

@@ -119,7 +119,7 @@ internal static class Helper
 
                 if (MachineStuff.NewDesMachineID == Common.MachineID)
                 {
-                    InitAndCleanup.ReleaseAllKeys();
+                    Common.ReleaseAllKeys();
                 }
             }
         }
@@ -317,7 +317,7 @@ internal static class Helper
                 Common.GetInputDesktop(),
                 0);
 
-            Clipboard.HasSwitchedMachineSinceLastCopy = true;
+            Common.HasSwitchedMachineSinceLastCopy = true;
 
             // Common.CreateLowIntegrityProcess("\"" + Path.GetDirectoryName(Application.ExecutablePath) + "\\MouseWithoutBordersHelper.exe\"", string.Empty, 0, false, 0);
             var processes = Process.GetProcessesByName(HelperProcessName);

src/modules/MouseWithoutBorders/App/Core/InitAndCleanup.cs

@@ -1,278 +0,0 @@
-// 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.Net.NetworkInformation;
-using System.Security.Cryptography;
-using System.Threading;
-
-using Microsoft.Win32;
-using MouseWithoutBorders.Class;
-using Windows.UI.Input.Preview.Injection;
-
-// <summary>
-//     Initialization and clean up.
-// </summary>
-// <history>
-//     2008 created by Truong Do (ductdo).
-//     2009-... modified by Truong Do (TruongDo).
-//     2023- Included in PowerToys.
-// </history>
-namespace MouseWithoutBorders.Core;
-
-internal static class InitAndCleanup
-{
-    private static bool initDone;
-    internal static int REOPEN_WHEN_WSAECONNRESET = -10054;
-    internal static int REOPEN_WHEN_HOTKEY = -10055;
-    internal static int PleaseReopenSocket;
-    internal static bool ReopenSocketDueToReadError;
-
-    private static DateTime LastResumeSuspendTime { get; set; } = DateTime.UtcNow;
-
-    internal static bool InitDone
-    {
-        get => InitAndCleanup.initDone;
-        set => InitAndCleanup.initDone = value;
-    }
-
-    internal static void UpdateMachineTimeAndID()
-    {
-        Common.MachineName = Common.MachineName.Trim();
-        _ = MachineStuff.MachinePool.TryUpdateMachineID(Common.MachineName, Common.MachineID, true);
-    }
-
-    private static void InitializeMachinePoolFromSettings()
-    {
-        try
-        {
-            MachineInf[] info = MachinePoolHelpers.LoadMachineInfoFromMachinePoolStringSetting(Setting.Values.MachinePoolString);
-            for (int i = 0; i < info.Length; i++)
-            {
-                info[i].Name = info[i].Name.Trim();
-            }
-
-            MachineStuff.MachinePool.Initialize(info);
-            MachineStuff.MachinePool.ResetIPAddressesForDeadMachines(true);
-        }
-        catch (Exception ex)
-        {
-            Logger.Log(ex);
-            MachineStuff.MachinePool.Clear();
-        }
-    }
-
-    private static void SetupMachineNameAndID()
-    {
-        try
-        {
-            Common.GetMachineName();
-            Common.DesMachineID = MachineStuff.NewDesMachineID = Common.MachineID;
-
-            // MessageBox.Show(machineID.ToString(CultureInfo.CurrentCulture)); // For test
-            InitializeMachinePoolFromSettings();
-
-            Common.MachineName = Common.MachineName.Trim();
-            _ = MachineStuff.MachinePool.LearnMachine(Common.MachineName);
-            _ = MachineStuff.MachinePool.TryUpdateMachineID(Common.MachineName, Common.MachineID, true);
-
-            MachineStuff.UpdateMachinePoolStringSetting();
-        }
-        catch (Exception e)
-        {
-            Logger.Log(e);
-        }
-    }
-
-    internal static void Init()
-    {
-        _ = Helper.GetUserName();
-        Common.GeneratedKey = true;
-
-        try
-        {
-            Common.MyKey = Setting.Values.MyKey;
-            int tmp = Setting.Values.MyKeyDaysToExpire;
-        }
-        catch (FormatException e)
-        {
-            Common.KeyCorrupted = true;
-            Setting.Values.MyKey = Common.MyKey = Common.CreateRandomKey();
-            Logger.Log(e.Message);
-        }
-        catch (CryptographicException e)
-        {
-            Common.KeyCorrupted = true;
-            Setting.Values.MyKey = Common.MyKey = Common.CreateRandomKey();
-            Logger.Log(e.Message);
-        }
-
-        try
-        {
-            InputSimulation.Injector = InputInjector.TryCreate();
-            if (InputSimulation.Injector != null)
-            {
-                InputSimulation.MoveMouseRelative(0, 0);
-                NativeMethods.InjectMouseInputAvailable = true;
-            }
-        }
-        catch (EntryPointNotFoundException)
-        {
-            NativeMethods.InjectMouseInputAvailable = false;
-            Logger.Log($"{nameof(NativeMethods.InjectMouseInputAvailable)} = false");
-        }
-
-        bool dummy = Setting.Values.DrawMouseEx;
-        Common.Is64bitOS = IntPtr.Size == 8;
-        Common.tcpPort = Setting.Values.TcpPort;
-        Common.GetScreenConfig();
-        Common.PackageSent = new PackageMonitor(0);
-        Common.PackageReceived = new PackageMonitor(0);
-        SetupMachineNameAndID();
-        Common.InitEncryption();
-        CreateHelperThreads();
-
-        SystemEvents.DisplaySettingsChanged += new EventHandler(Common.SystemEvents_DisplaySettingsChanged);
-        NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkChange_NetworkAvailabilityChanged);
-        SystemEvents.PowerModeChanged += new PowerModeChangedEventHandler(SystemEvents_PowerModeChanged);
-        PleaseReopenSocket = 9;
-        /* TODO: Telemetry for the matrix? */
-    }
-
-    private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
-    {
-        Helper.WndProcCounter++;
-
-        if (e.Mode is PowerModes.Resume or PowerModes.Suspend)
-        {
-            Logger.TelemetryLogTrace($"{nameof(SystemEvents_PowerModeChanged)}: {e.Mode}", SeverityLevel.Information);
-            LastResumeSuspendTime = DateTime.UtcNow;
-            MachineStuff.SwitchToMultipleMode(false, true);
-        }
-    }
-
-    private static void CreateHelperThreads()
-    {
-        // NOTE(@yuyoyuppe): service crashes while trying to obtain this info, disabling.
-        /*
-        Thread watchDogThread = new(new ThreadStart(WatchDogThread), nameof(WatchDogThread));
-        watchDogThread.Priority = ThreadPriority.Highest;
-        watchDogThread.Start();
-        */
-
-        Common.helper = new Thread(new ThreadStart(Helper.HelperThread), "Helper Thread");
-        Common.helper.SetApartmentState(ApartmentState.STA);
-        Common.helper.Start();
-    }
-
-    private static void AskHelperThreadsToExit(int waitTime)
-    {
-        Helper.signalHelperToExit = true;
-        Helper.signalWatchDogToExit = true;
-        _ = Common.EvSwitch.Set();
-
-        int c = 0;
-        if (Common.helper != null && c < waitTime)
-        {
-            while (Helper.signalHelperToExit)
-            {
-                Thread.Sleep(1);
-            }
-
-            Common.helper = null;
-        }
-    }
-
-    internal static void Cleanup()
-    {
-        try
-        {
-            Common.SendByeBye();
-
-            // UnhookClipboard();
-            AskHelperThreadsToExit(500);
-            Common.MainForm.NotifyIcon.Visible = false;
-            Common.MainForm.NotifyIcon.Dispose();
-            Common.CloseAllFormsAndHooks();
-
-            Common.DoSomethingInUIThread(() =>
-            {
-                Common.Sk?.Close(true);
-            });
-        }
-        catch (Exception e)
-        {
-            Logger.Log(e);
-        }
-    }
-
-    private static long lastReleaseAllKeysCall;
-
-    internal static void ReleaseAllKeys()
-    {
-        if (Math.Abs(Common.GetTick() - lastReleaseAllKeysCall) < 2000)
-        {
-            return;
-        }
-
-        lastReleaseAllKeysCall = Common.GetTick();
-
-        KEYBDDATA kd;
-        kd.dwFlags = (int)Common.LLKHF.UP;
-
-        VK[] keys = new VK[]
-        {
-            VK.LSHIFT, VK.LCONTROL, VK.LMENU, VK.LWIN, VK.RSHIFT,
-            VK.RCONTROL, VK.RMENU, VK.RWIN, VK.SHIFT, VK.MENU, VK.CONTROL,
-        };
-
-        Logger.LogDebug("***** ReleaseAllKeys has been called! *****:");
-
-        foreach (VK vk in keys)
-        {
-            if ((NativeMethods.GetAsyncKeyState((IntPtr)vk) & 0x8000) != 0)
-            {
-                Logger.LogDebug(vk.ToString() + " is down, release it...");
-                Common.Hook?.ResetLastSwitchKeys(); // Sticky key can turn ALL PC mode on (CtrlCtrlCtrl)
-                kd.wVk = (int)vk;
-                InputSimulation.SendKey(kd);
-                Common.Hook?.ResetLastSwitchKeys();
-            }
-        }
-    }
-
-    private static void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
-    {
-        Logger.LogDebug("NetworkAvailabilityEventArgs.IsAvailable: " + e.IsAvailable.ToString(CultureInfo.InvariantCulture));
-        Helper.WndProcCounter++;
-        ScheduleReopenSocketsDueToNetworkChanges(!e.IsAvailable);
-    }
-
-    private static void ScheduleReopenSocketsDueToNetworkChanges(bool closeSockets = true)
-    {
-        if (closeSockets)
-        {
-            // Slept/hibernated machine may still have the sockets' status as Connected:( (unchanged) so it would not re-connect after a timeout when waking up.
-            // Closing the sockets when it is going to sleep/hibernate will trigger the reconnection faster when it wakes up.
-            Common.DoSomethingInUIThread(
-                () =>
-            {
-                SocketStuff s = Common.Sk;
-                Common.Sk = null;
-                s?.Close(false);
-            },
-                true);
-        }
-
-        if (!Common.IsMyDesktopActive())
-        {
-            PleaseReopenSocket = 0;
-        }
-        else if (PleaseReopenSocket != 10)
-        {
-            PleaseReopenSocket = 10;
-        }
-    }
-}

src/modules/MouseWithoutBorders/App/Core/Logger.cs

@@ -247,24 +247,22 @@ internal static class Logger
 
     internal static void DumpStaticTypes(StringBuilder sb, int level)
     {
-        var staticTypes = new List<Type>
-        {
-            typeof(Clipboard),
-            typeof(DragDrop),
-            typeof(Event),
-            typeof(InitAndCleanup),
-            typeof(Helper),
-            typeof(Launch),
-            typeof(Logger),
-            typeof(MachineStuff),
-            typeof(Receiver),
-            typeof(Service),
-        };
-        foreach (var staticType in staticTypes)
-        {
-            sb.AppendLine(CultureInfo.InvariantCulture, $"[{staticType.Name}]\r\n===============");
-            Logger.DumpType(sb, staticType, 0, level);
-        }
+        sb.AppendLine($"[{nameof(DragDrop)}]\r\n===============");
+        Logger.DumpType(sb, typeof(DragDrop), 0, level);
+        sb.AppendLine($"[{nameof(Event)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Event), 0, level);
+        sb.AppendLine($"[{nameof(Helper)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Helper), 0, level);
+        sb.AppendLine($"[{nameof(Launch)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Launch), 0, level);
+        sb.AppendLine($"[{nameof(Logger)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Logger), 0, level);
+        sb.AppendLine($"[{nameof(MachineStuff)}]\r\n===============");
+        Logger.DumpType(sb, typeof(MachineStuff), 0, level);
+        sb.AppendLine($"[{nameof(Receiver)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Receiver), 0, level);
+        sb.AppendLine($"[{nameof(Service)}]\r\n===============");
+        Logger.DumpType(sb, typeof(Service), 0, level);
     }
 
     internal static bool PrivateDump(StringBuilder sb, object obj, string objName, int level, int maxLevel, bool stop)

src/modules/MouseWithoutBorders/App/Core/MachineStuff.cs

@@ -992,7 +992,7 @@ internal static class MachineStuff
                 Setting.Values.MatrixOneRow = !((package.Type & PackageType.MatrixTwoRowFlag) == PackageType.MatrixTwoRowFlag);
                 MachineMatrix = MachineMatrix; // Save
 
-                InitAndCleanup.ReopenSocketDueToReadError = true;
+                Common.ReopenSocketDueToReadError = true;
 
                 UpdateClientSockets("UpdateMachineMatrix");
 
@@ -1044,7 +1044,7 @@ internal static class MachineStuff
             Common.MoveMouseToCenter();
         }
 
-        InitAndCleanup.ReleaseAllKeys();
+        Common.ReleaseAllKeys();
 
         Common.UpdateMultipleModeIconAndMenu();
     }

src/modules/MouseWithoutBorders/App/Core/Receiver.cs

@@ -157,7 +157,7 @@ internal static class Receiver
 
                             if (!p.IsEmpty)
                             {
-                                Clipboard.HasSwitchedMachineSinceLastCopy = true;
+                                Common.HasSwitchedMachineSinceLastCopy = true;
 
                                 Logger.LogDebug(string.Format(
                                     CultureInfo.CurrentCulture,
@@ -274,7 +274,7 @@ internal static class Receiver
                 Common.PackageReceived.Clipboard++;
                 if (!Common.RunOnLogonDesktop && !Common.RunOnScrSaverDesktop)
                 {
-                    Clipboard.clipboardCopiedTime = Common.GetTick();
+                    Common.clipboardCopiedTime = Common.GetTick();
                     GetNameOfMachineWithClipboardData(package);
                     SignalBigClipboardData();
                 }
@@ -282,10 +282,10 @@ internal static class Receiver
                 break;
 
             case PackageType.MachineSwitched:
-                if (Common.GetTick() - Clipboard.clipboardCopiedTime < Clipboard.BIG_CLIPBOARD_DATA_TIMEOUT && (package.Des == Common.MachineID))
+                if (Common.GetTick() - Common.clipboardCopiedTime < Common.BIG_CLIPBOARD_DATA_TIMEOUT && (package.Des == Common.MachineID))
                 {
-                    Clipboard.clipboardCopiedTime = 0;
-                    Clipboard.GetRemoteClipboard("PackageType.MachineSwitched");
+                    Common.clipboardCopiedTime = 0;
+                    Common.GetRemoteClipboard("PackageType.MachineSwitched");
                 }
 
                 break;
@@ -297,7 +297,7 @@ internal static class Receiver
                     if (package.Des == Common.MachineID || package.Des == ID.ALL)
                     {
                         GetNameOfMachineWithClipboardData(package);
-                        Clipboard.GetRemoteClipboard("mspaint," + Clipboard.LastMachineWithClipboardData);
+                        Common.GetRemoteClipboard("mspaint," + Common.LastMachineWithClipboardData);
                     }
                 }
 
@@ -326,10 +326,10 @@ internal static class Receiver
                             Thread.UpdateThreads(thread);
 
                             string remoteMachine = package.MachineName;
-                            System.Net.Sockets.TcpClient client = Clipboard.ConnectToRemoteClipboardSocket(remoteMachine);
+                            System.Net.Sockets.TcpClient client = Common.ConnectToRemoteClipboardSocket(remoteMachine);
                             bool clientPushData = true;
 
-                            if (Clipboard.ShakeHand(ref remoteMachine, client.Client, out Stream enStream, out Stream deStream, ref clientPushData, ref package.PostAction))
+                            if (Common.ShakeHand(ref remoteMachine, client.Client, out Stream enStream, out Stream deStream, ref clientPushData, ref package.PostAction))
                             {
                                 SocketStuff.SendClipboardData(client.Client, enStream);
                             }
@@ -360,7 +360,7 @@ internal static class Receiver
 
             case PackageType.ClipboardText:
             case PackageType.ClipboardImage:
-                Clipboard.clipboardCopiedTime = 0;
+                Common.clipboardCopiedTime = 0;
                 if (package.Type == PackageType.ClipboardImage)
                 {
                     Common.PackageReceived.ClipboardImage++;
@@ -372,7 +372,7 @@ internal static class Receiver
 
                 if (tcp != null)
                 {
-                    Clipboard.ReceiveClipboardDataUsingTCP(
+                    Common.ReceiveClipboardDataUsingTCP(
                         package,
                         package.Type == PackageType.ClipboardImage,
                         tcp);
@@ -381,10 +381,10 @@ internal static class Receiver
                 break;
 
             case PackageType.HideMouse:
-                Clipboard.HasSwitchedMachineSinceLastCopy = true;
+                Common.HasSwitchedMachineSinceLastCopy = true;
                 Common.HideMouseCursor(true);
                 Helper.MainFormDotEx(false);
-                InitAndCleanup.ReleaseAllKeys();
+                Common.ReleaseAllKeys();
                 break;
 
             default:
@@ -405,11 +405,11 @@ internal static class Receiver
 
     internal static void GetNameOfMachineWithClipboardData(DATA package)
     {
-        Clipboard.LastIDWithClipboardData = package.Src;
-        List<MachineInf> matchingMachines = MachineStuff.MachinePool.TryFindMachineByID(Clipboard.LastIDWithClipboardData);
+        Common.LastIDWithClipboardData = package.Src;
+        List<MachineInf> matchingMachines = MachineStuff.MachinePool.TryFindMachineByID(Common.LastIDWithClipboardData);
         if (matchingMachines.Count >= 1)
         {
-            Clipboard.LastMachineWithClipboardData = matchingMachines[0].Name.Trim();
+            Common.LastMachineWithClipboardData = matchingMachines[0].Name.Trim();
         }
 
         /*

src/modules/MouseWithoutBorders/App/Form/Settings/SetupPage3a.cs

@@ -84,7 +84,7 @@ namespace MouseWithoutBorders
                 if ((connectedClientSocket = Common.GetConnectedClientSocket()) != null)
                 {
                     ShowStatus($"Connected from local IP Address: {connectedClientSocket.Address}.");
-                    InitAndCleanup.UpdateMachineTimeAndID();
+                    Common.UpdateMachineTimeAndID();
 
                     Common.MMSleep(1);
                     connected = true;

src/modules/MouseWithoutBorders/App/Form/frmMatrix.cs

@@ -22,8 +22,6 @@ using Microsoft.PowerToys.Telemetry;
 // </history>
 using MouseWithoutBorders.Class;
 using MouseWithoutBorders.Core;
-
-using Clipboard = MouseWithoutBorders.Core.Clipboard;
 using Timer = System.Windows.Forms.Timer;
 
 [module: SuppressMessage("Microsoft.Globalization", "CA1300:SpecifyMessageBoxOptions", Scope = "member", Target = "MouseWithoutBorders.frmMatrix.#buttonOK_Click(System.Object,System.EventArgs)", Justification = "Dotnet port with style preservation")]
@@ -112,7 +110,7 @@ namespace MouseWithoutBorders
             {
                 SocketStuff.InvalidKeyFound = false;
                 showInvalidKeyMessage = false;
-                InitAndCleanup.ReopenSocketDueToReadError = true;
+                Common.ReopenSocketDueToReadError = true;
                 Common.ReopenSockets(true);
 
                 for (int i = 0; i < 10; i++)
@@ -782,7 +780,7 @@ namespace MouseWithoutBorders
 
             ShowUpdateMessage();
 
-            Clipboard.HasSwitchedMachineSinceLastCopy = true;
+            Common.HasSwitchedMachineSinceLastCopy = true;
         }
 
         private void CheckBoxDisableCAD_CheckedChanged(object sender, EventArgs e)

src/modules/MouseWithoutBorders/App/Form/frmScreen.cs

@@ -139,13 +139,13 @@ namespace MouseWithoutBorders
             {
                 if (cleanup)
                 {
-                    InitAndCleanup.Cleanup();
+                    Common.Cleanup();
                 }
 
                 Helper.WndProcCounter++;
                 if (!Common.RunOnScrSaverDesktop)
                 {
-                    InitAndCleanup.ReleaseAllKeys();
+                    Common.ReleaseAllKeys();
                 }
 
                 Helper.RunDDHelper(true);
@@ -412,7 +412,7 @@ namespace MouseWithoutBorders
 
                         count = 0;
 
-                        InitAndCleanup.InitDone = true;
+                        Common.InitDone = true;
 #if SHOW_ON_WINLOGON
                         if (Common.RunOnLogonDesktop)
                         {
@@ -423,39 +423,39 @@ namespace MouseWithoutBorders
 
                     if ((count % 2) == 0)
                     {
-                        if (InitAndCleanup.PleaseReopenSocket == 10 || (InitAndCleanup.PleaseReopenSocket > 0 && count > 0 && count % 300 == 0))
+                        if (Common.PleaseReopenSocket == 10 || (Common.PleaseReopenSocket > 0 && count > 0 && count % 300 == 0))
                         {
-                            if (!Common.AtLeastOneSocketEstablished() || InitAndCleanup.PleaseReopenSocket == 10)
+                            if (!Common.AtLeastOneSocketEstablished() || Common.PleaseReopenSocket == 10)
                             {
                                 Thread.Sleep(1000);
-                                if (InitAndCleanup.PleaseReopenSocket > 0)
+                                if (Common.PleaseReopenSocket > 0)
                                 {
-                                    InitAndCleanup.PleaseReopenSocket--;
+                                    Common.PleaseReopenSocket--;
                                 }
 
                                 // Double check.
                                 if (!Common.AtLeastOneSocketEstablished())
                                 {
                                     Common.GetMachineName();
-                                    Logger.LogDebug("Common.pleaseReopenSocket: " + InitAndCleanup.PleaseReopenSocket.ToString(CultureInfo.InvariantCulture));
+                                    Logger.LogDebug("Common.pleaseReopenSocket: " + Common.PleaseReopenSocket.ToString(CultureInfo.InvariantCulture));
                                     Common.ReopenSockets(false);
                                     MachineStuff.NewDesMachineID = Common.DesMachineID = Common.MachineID;
                                 }
                             }
                             else
                             {
-                                InitAndCleanup.PleaseReopenSocket = 0;
+                                Common.PleaseReopenSocket = 0;
                             }
                         }
 
-                        if (InitAndCleanup.PleaseReopenSocket == InitAndCleanup.REOPEN_WHEN_HOTKEY)
+                        if (Common.PleaseReopenSocket == Common.REOPEN_WHEN_HOTKEY)
                         {
-                            InitAndCleanup.PleaseReopenSocket = 0;
+                            Common.PleaseReopenSocket = 0;
                             Common.ReopenSockets(true);
                         }
-                        else if (InitAndCleanup.PleaseReopenSocket == InitAndCleanup.REOPEN_WHEN_WSAECONNRESET)
+                        else if (Common.PleaseReopenSocket == Common.REOPEN_WHEN_WSAECONNRESET)
                         {
-                            InitAndCleanup.PleaseReopenSocket = 0;
+                            Common.PleaseReopenSocket = 0;
                             Thread.Sleep(1000);
                             MachineStuff.UpdateClientSockets("REOPEN_WHEN_WSAECONNRESET");
                         }

src/modules/MouseWithoutBorders/MouseWithoutBorders.UnitTests/Core/Logger.PrivateDump.expected.txt

@@ -4,6 +4,28 @@
 [Other Logs]
 ===============
  = MouseWithoutBorders.Common
+Comma = System.Char[]
+--System.Char[] = System.Char[]: N/A
+Star = System.Char[]
+--System.Char[] = System.Char[]: N/A
+NullSeparator = System.Char[]
+--System.Char[] = System.Char[]: N/A
+lastClipboardEventTime = 0
+clipboardCopiedTime = 0
+<LastIDWithClipboardData>k__BackingField = NONE
+<NextClipboardViewer>k__BackingField = 0
+<IsClipboardDataImage>k__BackingField = False
+lastClipboardObject = 
+<HasSwitchedMachineSinceLastCopy>k__BackingField = False
+ClipboardThreadOldLock = Lock
+--_owningThreadId = 0
+--_state = 0
+--_recursionCount = 0
+--_spinCount = 22
+--_waiterStartTimeMs = 0
+--s_contentionCount = 0
+--s_maxSpinCount = 22
+--s_minSpinCountForAdaptiveSpin = -100
 screenWidth = 0
 screenHeight = 0
 lastX = 0
@@ -77,6 +99,17 @@ LegalKeyDictionary = Concurrent.ConcurrentDictionary`2[System.String,System.Byte
 --_budget = ????????????
 --_growLockArray = True
 --_comparerIsDefaultForClasses = False
+initDone = False
+REOPEN_WHEN_WSAECONNRESET = -10054
+REOPEN_WHEN_HOTKEY = -10055
+PleaseReopenSocket = 0
+ReopenSocketDueToReadError = False
+<LastResumeSuspendTime>k__BackingField = ????????????
+--_dateData = ????????????
+--MinValue = 01/01/0001 00:00:00
+--MaxValue = 31/12/9999 23:59:59
+--UnixEpoch = 01/01/1970 00:00:00
+lastReleaseAllKeysCall = 0
 PackageSent = MouseWithoutBorders.PackageMonitor
 --Keyboard = 0
 --Mouse = 0
@@ -120,6 +153,12 @@ p = {X=0,Y=0}
 --y = 0
 --Empty = {X=0,Y=0}
 <IpcChannelCreated>k__BackingField = False
+BIG_CLIPBOARD_DATA_TIMEOUT = 30000
+MAX_CLIPBOARD_DATA_SIZE_CAN_BE_SENT_INSTANTLY_TCP = 1048576
+MAX_CLIPBOARD_FILE_SIZE_CAN_BE_SENT = 104857600
+TEXT_HEADER_SIZE = 12
+DATA_SIZE = 48
+TEXT_TYPE_SEP = {4CFF57F7-BEDD-43d5-AE8F-27A61E886F2F}
 TOGGLE_ICONS_SIZE = 4
 ICON_ONE = 0
 ICON_ALL = 1
@@ -156,36 +195,6 @@ WM_KEYDOWN = 256
 WM_KEYUP = 257
 WM_SYSKEYDOWN = 260
 WM_SYSKEYUP = 261
-[Clipboard]
-===============
-Comma = System.Char[]
---System.Char[] = System.Char[]: N/A
-Star = System.Char[]
---System.Char[] = System.Char[]: N/A
-NullSeparator = System.Char[]
---System.Char[] = System.Char[]: N/A
-lastClipboardEventTime = 0
-clipboardCopiedTime = 0
-<LastIDWithClipboardData>k__BackingField = NONE
-<NextClipboardViewer>k__BackingField = 0
-<IsClipboardDataImage>k__BackingField = False
-lastClipboardObject = 
-<HasSwitchedMachineSinceLastCopy>k__BackingField = False
-ClipboardThreadOldLock = Lock
---_owningThreadId = 0
---_state = 0
---_recursionCount = 0
---_spinCount = 22
---_waiterStartTimeMs = 0
---s_contentionCount = 0
---s_maxSpinCount = 22
---s_minSpinCountForAdaptiveSpin = -100
-BIG_CLIPBOARD_DATA_TIMEOUT = 30000
-MAX_CLIPBOARD_DATA_SIZE_CAN_BE_SENT_INSTANTLY_TCP = 1048576
-MAX_CLIPBOARD_FILE_SIZE_CAN_BE_SENT = 104857600
-TEXT_HEADER_SIZE = 12
-DATA_SIZE = 48
-TEXT_TYPE_SEP = {4CFF57F7-BEDD-43d5-AE8F-27A61E886F2F}
 [DragDrop]
 ===============
 isDragging = False
@@ -240,19 +249,6 @@ actualLastPos = {X=0,Y=0}
 --Empty = {X=0,Y=0}
 myLastX = 0
 myLastY = 0
-[InitAndCleanup]
-===============
-initDone = False
-REOPEN_WHEN_WSAECONNRESET = -10054
-REOPEN_WHEN_HOTKEY = -10055
-PleaseReopenSocket = 0
-ReopenSocketDueToReadError = False
-<LastResumeSuspendTime>k__BackingField = ????????????
---_dateData = ????????????
---MinValue = 01/01/0001 00:00:00
---MaxValue = 31/12/9999 23:59:59
---UnixEpoch = 01/01/1970 00:00:00
-lastReleaseAllKeysCall = 0
 [Helper]
 ===============
 signalHelperToExit = False

src/modules/ZoomIt/ZoomIt/ZoomIt.rc

@@ -121,8 +121,8 @@ FONT 8, "MS Shell Dlg", 0, 0, 0x0
 BEGIN
     DEFPUSHBUTTON   "OK",IDOK,166,306,50,14
     PUSHBUTTON      "Cancel",IDCANCEL,223,306,50,14
-    LTEXT           "ZoomIt v9.01",IDC_VERSION,42,7,73,10
-    LTEXT           "Copyright © 2006-2025 Mark Russinovich",IDC_COPYRIGHT,42,17,166,8
+    LTEXT           "ZoomIt v9.0",IDC_VERSION,42,7,73,10
+    LTEXT           "Copyright <EFBFBD> 2006-2024 Mark Russinovich",IDC_COPYRIGHT,42,17,166,8
     CONTROL         "<a HREF=""https://www.sysinternals.com"">Sysinternals - www.sysinternals.com</a>",IDC_LINK,
                     "SysLink",WS_TABSTOP,42,26,150,9
     ICON            "APPICON",IDC_STATIC,12,9,20,20

src/modules/awake/Awake/Awake.csproj

@@ -1,102 +1,103 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <!-- Look at Directory.Build.props in root for common stuff as well -->
-  <Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
-  <Import Project="..\..\..\Common.SelfContained.props" />
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+	<Import Project="..\..\..\Common.SelfContained.props" />
 
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <OutputPath>..\..\..\..\$(Platform)\$(Configuration)</OutputPath>
-    <Nullable>enable</Nullable>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
-    <UseWindowsForms>False</UseWindowsForms>
-    <!--Per documentation: https://learn.microsoft.com/dotnet/core/compatibility/windows-forms/5.0/automatically-infer-winexe-output-type#outputtype-set-to-winexe-for-wpf-and-winforms-apps -->
-    <DisableWinExeOutputInference>true</DisableWinExeOutputInference>
-    <AssemblyName>PowerToys.Awake</AssemblyName>
-    
-    <ApplicationIcon>Assets\Awake\Awake.ico</ApplicationIcon>
-    <PackageProjectUrl>https://awake.den.dev</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/microsoft/powertoys</RepositoryUrl>
-    <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
-  </PropertyGroup>
+	<PropertyGroup>
+		<OutputType>WinExe</OutputType>
+		<OutputPath>..\..\..\..\$(Platform)\$(Configuration)</OutputPath>
+		<Nullable>enable</Nullable>
+		<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+		<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+		<UseWindowsForms>False</UseWindowsForms>
+		<!--Per documentation: https://learn.microsoft.com/dotnet/core/compatibility/windows-forms/5.0/automatically-infer-winexe-output-type#outputtype-set-to-winexe-for-wpf-and-winforms-apps -->
+		<DisableWinExeOutputInference>true</DisableWinExeOutputInference>
+		<AssemblyName>PowerToys.Awake</AssemblyName>
 
-  <!-- See https://learn.microsoft.com/windows/apps/develop/platform/csharp-winrt/net-projection-from-cppwinrt-component for more info -->
-  <PropertyGroup>
-    <CsWinRTIncludes>PowerToys.GPOWrapper</CsWinRTIncludes>
-    <CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
-    <ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-  </PropertyGroup>
+		<ApplicationIcon>Assets\Awake\Awake.ico</ApplicationIcon>
+		<PackageProjectUrl>https://awake.den.dev</PackageProjectUrl>
+		<RepositoryUrl>https://github.com/microsoft/powertoys</RepositoryUrl>
+		<GenerateAssemblyInfo>true</GenerateAssemblyInfo>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <None Remove="Assets\Awake\Awake.ico" />
-    <None Remove="Assets\Awake\disabled.ico" />
-    <None Remove="Assets\Awake\expirable.ico" />
-    <None Remove="Assets\Awake\indefinite.ico" />
-    <None Remove="Assets\Awake\normal.ico" />
-    <None Remove="Assets\Awake\scheduled.ico" />
-    <None Remove="Assets\Awake\timed.ico" />
-  </ItemGroup>
+	<!-- See https://learn.microsoft.com/windows/apps/develop/platform/csharp-winrt/net-projection-from-cppwinrt-component for more info -->
+	<PropertyGroup>
+		<CsWinRTIncludes>PowerToys.GPOWrapper</CsWinRTIncludes>
+		<CsWinRTGeneratedFilesDir>$(OutDir)</CsWinRTGeneratedFilesDir>
+		<ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
+		<ApplicationManifest>app.manifest</ApplicationManifest>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="System.CommandLine" />
-    <PackageReference Include="System.Reactive" />
-    <PackageReference Include="System.Runtime.Caching" />
-  </ItemGroup>
+	<ItemGroup>
+		<None Remove="Assets\Awake\Awake.ico" />
+		<None Remove="Assets\Awake\disabled.ico" />
+		<None Remove="Assets\Awake\expirable.ico" />
+		<None Remove="Assets\Awake\indefinite.ico" />
+		<None Remove="Assets\Awake\normal.ico" />
+		<None Remove="Assets\Awake\scheduled.ico" />
+		<None Remove="Assets\Awake\timed.ico" />
+	</ItemGroup>
+	
+	<ItemGroup>
+		<PackageReference Include="System.CommandLine" />
+		<PackageReference Include="System.Reactive" />
+		<PackageReference Include="System.Runtime.Caching" />
+		<PackageReference Include="Microsoft.Data.Sqlite" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\common\GPOWrapper\GPOWrapper.vcxproj" />
-    <ProjectReference Include="..\..\..\common\interop\PowerToys.Interop.vcxproj" />
-    <ProjectReference Include="..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
-    <ProjectReference Include="..\..\..\settings-ui\Settings.UI.Library\Settings.UI.Library.csproj" />
-  </ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\common\GPOWrapper\GPOWrapper.vcxproj" />
+		<ProjectReference Include="..\..\..\common\interop\PowerToys.Interop.vcxproj" />
+		<ProjectReference Include="..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+		<ProjectReference Include="..\..\..\settings-ui\Settings.UI.Library\Settings.UI.Library.csproj" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <Compile Update="Program.cs">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </Compile>
-    <Compile Update="Properties\Resources.Designer.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-  </ItemGroup>
+	<ItemGroup>
+		<Compile Update="Program.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+		<Compile Update="Properties\Resources.Designer.cs">
+			<DesignTime>True</DesignTime>
+			<AutoGen>True</AutoGen>
+			<DependentUpon>Resources.resx</DependentUpon>
+		</Compile>
+	</ItemGroup>
 
-  <ItemGroup>
-    <Content Include="Assets\Awake\Awake.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\disabled.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\expirable.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\indefinite.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\normal.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\scheduled.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Assets\Awake\timed.ico">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
+	<ItemGroup>
+		<Content Include="Assets\Awake\Awake.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\disabled.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\expirable.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\indefinite.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\normal.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\scheduled.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+		<Content Include="Assets\Awake\timed.ico">
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+	</ItemGroup>
 
-  <ItemGroup>
-    <EmbeddedResource Update="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-  </ItemGroup>
+	<ItemGroup>
+		<EmbeddedResource Update="Properties\Resources.resx">
+			<Generator>ResXFileCodeGenerator</Generator>
+			<LastGenOutput>Resources.Designer.cs</LastGenOutput>
+		</EmbeddedResource>
+	</ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Update="Microsoft.CodeAnalysis.NetAnalyzers">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-</Project>
+	<ItemGroup>
+		<PackageReference Update="Microsoft.CodeAnalysis.NetAnalyzers">
+			<PrivateAssets>all</PrivateAssets>
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+	</ItemGroup>
+</Project>

src/modules/awake/Awake/AwakeAutomation.cs

@@ -0,0 +1,33 @@
+// 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;
+
+namespace Awake
+{
+    /// <summary>
+    /// Automation object exposed via the Running Object Table. Intentionally minimal; methods may expand in future.
+    /// </summary>
+    [ComVisible(true)]
+    [ClassInterface(ClassInterfaceType.None)]
+    [Guid("4F1C3769-8D28-4A2D-8A6A-AB2F4C0F5F11")]
+    public sealed class AwakeAutomation : IAwakeAutomation
+    {
+        public string Ping() => "pong";
+
+        public void SetIndefinite() => Logger.LogInfo("Automation: SetIndefinite");
+
+        public void SetTimed(int seconds) => Logger.LogInfo($"Automation: SetTimed {seconds}s");
+
+        public void SetExpirable(int minutes) => Logger.LogInfo($"Automation: SetExpirable {minutes}m");
+
+        public void SetPassive() => Logger.LogInfo("Automation: SetPassive");
+
+        public void Cancel() => Logger.LogInfo("Automation: Cancel");
+
+        public string GetStatusJson() => "{\"ok\":true}";
+    }
+}

src/modules/awake/Awake/Core/AwakeHttpHandler.cs

@@ -0,0 +1,402 @@
+// 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.Net;
+using System.Threading.Tasks;
+using ManagedCommon;
+using Microsoft.PowerToys.Settings.UI.Library;
+
+namespace Awake.Core
+{
+    /// <summary>
+    /// HTTP request handler for Awake module functionality.
+    /// </summary>
+    internal sealed class AwakeHttpHandler : IHttpRequestHandler
+    {
+        public string ModuleName => "awake";
+
+        public string[] GetAvailableEndpoints()
+        {
+            return new[]
+            {
+                "GET /awake/status - Get current Awake status",
+                "GET /awake/config - Get current Awake configuration",
+                "POST /awake/indefinite - Set indefinite keep-awake (body: {\"keepDisplayOn\": true, \"processId\": 0})",
+                "POST /awake/timed - Set timed keep-awake (body: {\"seconds\": 3600, \"keepDisplayOn\": true})",
+                "POST /awake/expirable - Set expirable keep-awake (body: {\"expireAt\": \"2024-12-31T23:59:59Z\", \"keepDisplayOn\": true})",
+                "POST /awake/activity - Set activity-based keep-awake (body: {\"cpuThresholdPercent\": 50, \"memThresholdPercent\": 50, \"netThresholdKBps\": 10, \"sampleIntervalSeconds\": 30, \"inactivityTimeoutSeconds\": 300, \"keepDisplayOn\": true})",
+                "POST /awake/passive - Set passive mode (no keep-awake)",
+                "POST /awake/display/toggle - Toggle display setting",
+                "GET /awake/settings - Get current PowerToys settings",
+            };
+        }
+
+        public async Task HandleRequestAsync(HttpListenerContext context, string path)
+        {
+            var request = context.Request;
+            var response = context.Response;
+            var method = request.HttpMethod.ToUpperInvariant();
+            var pathLower = path.ToLowerInvariant();
+
+            try
+            {
+                switch ((method, pathLower))
+                {
+                    case ("GET", "status"):
+                        await HandleGetStatusAsync(response);
+                        break;
+
+                    case ("GET", "config"):
+                        await HandleGetConfigAsync(response);
+                        break;
+
+                    case ("POST", "indefinite"):
+                        await HandleSetIndefiniteAwakeAsync(request, response);
+                        break;
+
+                    case ("POST", "timed"):
+                        await HandleSetTimedAwakeAsync(request, response);
+                        break;
+
+                    case ("POST", "expirable"):
+                        await HandleSetExpirableAwakeAsync(request, response);
+                        break;
+
+                    case ("POST", "activity"):
+                        await HandleSetActivityBasedAwakeAsync(request, response);
+                        break;
+
+                    case ("POST", "passive"):
+                        await HandleSetPassiveAwakeAsync(response);
+                        break;
+
+                    case ("POST", "display/toggle"):
+                        await HandleToggleDisplayAsync(response);
+                        break;
+
+                    case ("GET", "settings"):
+                        await HandleGetSettingsAsync(response);
+                        break;
+
+                    default:
+                        await HandleNotFoundAsync(response, path);
+                        break;
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Error handling Awake request {method} /{path}: {ex.Message}");
+                await HandleErrorAsync(response, 500, $"Internal server error: {ex.Message}");
+            }
+        }
+
+        private async Task HandleGetStatusAsync(HttpListenerResponse response)
+        {
+            var status = new
+            {
+                Module = "Awake",
+                Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version?.ToString(),
+                Status = "Running",
+                UsingPowerToysConfig = Manager.IsUsingPowerToysConfig,
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            await WriteJsonResponseAsync(response, status);
+        }
+
+        private async Task HandleGetConfigAsync(HttpListenerResponse response)
+        {
+            var config = Manager.GetCurrentConfig();
+            await WriteJsonResponseAsync(response, config);
+        }
+
+        private async Task HandleSetIndefiniteAwakeAsync(HttpListenerRequest request, HttpListenerResponse response)
+        {
+            var requestData = await ReadJsonRequestAsync<IndefiniteAwakeRequest>(request);
+
+            Manager.SetIndefiniteKeepAwake(
+                requestData?.KeepDisplayOn ?? true,
+                requestData?.ProcessId ?? 0,
+                "HttpServer");
+
+            var result = new
+            {
+                Success = true,
+                Mode = "Indefinite",
+                KeepDisplayOn = requestData?.KeepDisplayOn ?? true,
+                ProcessId = requestData?.ProcessId ?? 0,
+            };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleSetTimedAwakeAsync(HttpListenerRequest request, HttpListenerResponse response)
+        {
+            var requestData = await ReadJsonRequestAsync<TimedAwakeRequest>(request);
+
+            if (requestData?.Seconds == null || requestData.Seconds <= 0)
+            {
+                await HandleErrorAsync(response, 400, "Invalid or missing 'seconds' parameter. Must be a positive integer.");
+                return;
+            }
+
+            Manager.SetTimedKeepAwake(
+                requestData.Seconds,
+                requestData.KeepDisplayOn ?? true,
+                "HttpServer");
+
+            var result = new
+            {
+                Success = true,
+                Mode = "Timed",
+                Seconds = requestData.Seconds,
+                KeepDisplayOn = requestData.KeepDisplayOn ?? true,
+            };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleSetExpirableAwakeAsync(HttpListenerRequest request, HttpListenerResponse response)
+        {
+            var requestData = await ReadJsonRequestAsync<ExpirableAwakeRequest>(request);
+
+            if (requestData?.ExpireAt == null)
+            {
+                await HandleErrorAsync(response, 400, "Missing 'expireAt' parameter. Expected ISO 8601 format (e.g., '2024-12-31T23:59:59Z').");
+                return;
+            }
+
+            if (requestData.ExpireAt <= DateTimeOffset.Now)
+            {
+                await HandleErrorAsync(response, 400, "Expiration time must be in the future.");
+                return;
+            }
+
+            Manager.SetExpirableKeepAwake(
+                requestData.ExpireAt,
+                requestData.KeepDisplayOn ?? true,
+                "HttpServer");
+
+            var result = new
+            {
+                Success = true,
+                Mode = "Expirable",
+                ExpireAt = requestData.ExpireAt,
+                KeepDisplayOn = requestData.KeepDisplayOn ?? true,
+            };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleSetActivityBasedAwakeAsync(HttpListenerRequest request, HttpListenerResponse response)
+        {
+            var requestData = await ReadJsonRequestAsync<ActivityBasedAwakeRequest>(request);
+
+            if (requestData == null)
+            {
+                await HandleErrorAsync(response, 400, "Invalid or missing request body. Expected JSON with cpuThresholdPercent, memThresholdPercent, netThresholdKBps, sampleIntervalSeconds, inactivityTimeoutSeconds, and optional keepDisplayOn.");
+                return;
+            }
+
+            // Validate required parameters
+            if (requestData.CpuThresholdPercent > 100)
+            {
+                await HandleErrorAsync(response, 400, "Invalid cpuThresholdPercent. Must be between 0 and 100.");
+                return;
+            }
+
+            if (requestData.MemThresholdPercent > 100)
+            {
+                await HandleErrorAsync(response, 400, "Invalid memThresholdPercent. Must be between 0 and 100.");
+                return;
+            }
+
+            if (requestData.SampleIntervalSeconds == 0)
+            {
+                await HandleErrorAsync(response, 400, "Invalid sampleIntervalSeconds. Must be greater than 0.");
+                return;
+            }
+
+            if (requestData.InactivityTimeoutSeconds == 0)
+            {
+                await HandleErrorAsync(response, 400, "Invalid inactivityTimeoutSeconds. Must be greater than 0.");
+                return;
+            }
+
+            Manager.SetActivityBasedKeepAwake(
+                requestData.CpuThresholdPercent,
+                requestData.MemThresholdPercent,
+                requestData.NetThresholdKBps,
+                requestData.SampleIntervalSeconds,
+                requestData.InactivityTimeoutSeconds,
+                requestData.KeepDisplayOn ?? true,
+                "HttpServer");
+
+            var result = new
+            {
+                Success = true,
+                Mode = "Activity-based",
+                CpuThresholdPercent = requestData.CpuThresholdPercent,
+                MemThresholdPercent = requestData.MemThresholdPercent,
+                NetThresholdKBps = requestData.NetThresholdKBps,
+                SampleIntervalSeconds = requestData.SampleIntervalSeconds,
+                InactivityTimeoutSeconds = requestData.InactivityTimeoutSeconds,
+                KeepDisplayOn = requestData.KeepDisplayOn ?? true,
+            };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleSetPassiveAwakeAsync(HttpListenerResponse response)
+        {
+            Manager.SetPassiveKeepAwake(true, "HttpServer");
+
+            var result = new { Success = true, Mode = "Passive" };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleToggleDisplayAsync(HttpListenerResponse response)
+        {
+            Manager.SetDisplay("HttpServer");
+
+            var result = new { Success = true, Action = "Display setting toggled" };
+            await WriteJsonResponseAsync(response, result);
+        }
+
+        private async Task HandleGetSettingsAsync(HttpListenerResponse response)
+        {
+            try
+            {
+                if (Manager.ModuleSettings != null)
+                {
+                    var settings = Manager.ModuleSettings.GetSettings<AwakeSettings>(Constants.AppName);
+                    await WriteJsonResponseAsync(response, settings);
+                }
+                else
+                {
+                    await HandleErrorAsync(response, 500, "Settings module not available");
+                }
+            }
+            catch (Exception ex)
+            {
+                await HandleErrorAsync(response, 500, $"Error retrieving settings: {ex.Message}");
+            }
+        }
+
+        private async Task HandleNotFoundAsync(HttpListenerResponse response, string path)
+        {
+            var errorResponse = new
+            {
+                Error = $"Awake endpoint '/{path}' not found",
+                AvailableEndpoints = GetAvailableEndpoints(),
+                Module = ModuleName,
+                Timestamp = DateTimeOffset.Now,
+            };
+
+            response.StatusCode = 404;
+            await WriteJsonResponseAsync(response, errorResponse);
+        }
+
+        private async Task HandleErrorAsync(HttpListenerResponse response, int statusCode, string message)
+        {
+            response.StatusCode = statusCode;
+            var errorResponse = new
+            {
+                Error = message,
+                StatusCode = statusCode,
+                Module = ModuleName,
+                Timestamp = DateTimeOffset.Now,
+            };
+            await WriteJsonResponseAsync(response, errorResponse);
+        }
+
+        private async Task WriteJsonResponseAsync(HttpListenerResponse response, object data)
+        {
+            // Use HttpServer utility method via static access or DI - for now, replicate the functionality
+            response.ContentType = "application/json";
+            response.ContentEncoding = System.Text.Encoding.UTF8;
+
+#pragma warning disable CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+            var json = System.Text.Json.JsonSerializer.Serialize(
+                data, new System.Text.Json.JsonSerializerOptions
+            {
+                PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase,
+                WriteIndented = true,
+            });
+#pragma warning restore CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+            var buffer = System.Text.Encoding.UTF8.GetBytes(json);
+
+            response.ContentLength64 = buffer.Length;
+            await response.OutputStream.WriteAsync(buffer);
+            response.Close();
+        }
+
+        private async Task<T?> ReadJsonRequestAsync<T>(HttpListenerRequest request)
+            where T : class
+        {
+            if (!request.HasEntityBody)
+            {
+                return null;
+            }
+
+            using var reader = new System.IO.StreamReader(request.InputStream, System.Text.Encoding.UTF8);
+            var body = await reader.ReadToEndAsync();
+
+            if (string.IsNullOrWhiteSpace(body))
+            {
+                return null;
+            }
+
+            try
+            {
+#pragma warning disable CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+                return System.Text.Json.JsonSerializer.Deserialize<T>(body, new System.Text.Json.JsonSerializerOptions
+                {
+                    PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase,
+                });
+#pragma warning restore CA1869 // Cache and reuse 'JsonSerializerOptions' instances
+            }
+            catch (System.Text.Json.JsonException ex)
+            {
+                Logger.LogError($"Error deserializing request body: {ex.Message}");
+                return null;
+            }
+        }
+
+        // Request DTOs
+        private sealed class IndefiniteAwakeRequest
+        {
+            public bool? KeepDisplayOn { get; set; }
+
+            public int? ProcessId { get; set; }
+        }
+
+        private sealed class TimedAwakeRequest
+        {
+            public uint Seconds { get; set; }
+
+            public bool? KeepDisplayOn { get; set; }
+        }
+
+        private sealed class ExpirableAwakeRequest
+        {
+            public DateTimeOffset ExpireAt { get; set; }
+
+            public bool? KeepDisplayOn { get; set; }
+        }
+
+        private sealed class ActivityBasedAwakeRequest
+        {
+            public uint CpuThresholdPercent { get; set; }
+
+            public uint MemThresholdPercent { get; set; }
+
+            public uint NetThresholdKBps { get; set; }
+
+            public uint SampleIntervalSeconds { get; set; }
+
+            public uint InactivityTimeoutSeconds { get; set; }
+
+            public bool? KeepDisplayOn { get; set; }
+        }
+    }
+}

src/modules/awake/Awake/Core/Manager.cs

@@ -9,6 +9,7 @@ using System.Diagnostics;
 using System.Drawing;
 using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Reactive.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -17,6 +18,9 @@ using System.Text.Json;
 using System.Threading;
 using Awake.Core.Models;
 using Awake.Core.Native;
+
+// New usage tracking namespace
+using Awake.Core.Usage;
 using Awake.Properties;
 using ManagedCommon;
 using Microsoft.PowerToys.Settings.UI.Library;
@@ -56,9 +60,26 @@ namespace Awake.Core
         private static readonly BlockingCollection<ExecutionState> _stateQueue;
         private static CancellationTokenSource _tokenSource;
 
+        // Foreground usage tracker instance (lifecycle managed by Program)
+        internal static ForegroundUsageTracker? UsageTracker { get; set; }
+
+        private static PowerSchemeManager powerSchemeManager;
+
+        // Power scheme auto-switch (activity mode)
+        private static string? _originalPowerSchemeGuid;
+        private static bool _powerSchemeSwitched;
+
+        // Process monitoring fields
+        private static List<string> _processMonitoringList = [];
+        private static bool _processMonitoringActive;
+        private static IDisposable? _processMonitoringSubscription;
+        private static uint _processCheckInterval;
+        private static bool _processKeepDisplay;
+
         static Manager()
         {
             _tokenSource = new CancellationTokenSource();
+            powerSchemeManager = new PowerSchemeManager();
             _stateQueue = [];
             ModuleSettings = new SettingsUtils();
         }
@@ -123,6 +144,19 @@ namespace Awake.Core
                 : ExecutionState.ES_SYSTEM_REQUIRED | ExecutionState.ES_CONTINUOUS;
         }
 
+        // Activity mode state
+        private static bool _activityActive;
+        private static DateTimeOffset _activityLastHigh;
+        private static uint _activityCpu;
+        private static uint _activityMem;
+        private static uint _activityNetKBps;
+        private static uint _activitySample;
+        private static uint _activityTimeout;
+        private static bool _activityKeepDisplay;
+        private static PerformanceCounter? _cpuCounter;
+        private static PerformanceCounter? _memCounter;
+        private static List<PerformanceCounter>? _netCounters;
+
         internal static void CancelExistingThread()
         {
             Logger.LogInfo("Ensuring the thread is properly cleaned up...");
@@ -130,6 +164,10 @@ namespace Awake.Core
             // Reset the thread state and handle cancellation.
             _stateQueue.Add(ExecutionState.ES_CONTINUOUS);
 
+            // Clean up process monitoring subscription if active
+            _processMonitoringSubscription?.Dispose();
+            _processMonitoringSubscription = null;
+
             if (_tokenSource != null)
             {
                 _tokenSource.Cancel();
@@ -174,6 +212,15 @@ namespace Awake.Core
                     iconText = $"{Constants.FullAppName} [{Resources.AWAKE_TRAY_TEXT_TIMED}][{ScreenStateString}]";
                     icon = TrayHelper.TimedIcon;
                     break;
+                case AwakeMode.ACTIVITY:
+                    iconText = $"{Constants.FullAppName} [{Resources.AWAKE_TRAY_TEXT_ACTIVITY}][{ScreenStateString}]";
+                    icon = TrayHelper.IndefiniteIcon; // Placeholder icon
+                    break;
+                case AwakeMode.PROCESS:
+                    string processesText = _processMonitoringList.Count > 0 ? string.Join(", ", _processMonitoringList) : "None";
+                    iconText = $"{Constants.FullAppName} [Process Monitor][{ScreenStateString}][{processesText}]";
+                    icon = TrayHelper.IndefiniteIcon; // Use same icon as indefinite for now
+                    break;
             }
 
             TrayHelper.SetShellIcon(
@@ -183,6 +230,94 @@ namespace Awake.Core
                 forceAdd ? TrayIconAction.Add : TrayIconAction.Update);
         }
 
+        private static void CaptureOriginalPowerScheme()
+        {
+            try
+            {
+                powerSchemeManager.RefreshSchemes();
+                _originalPowerSchemeGuid = powerSchemeManager
+                    .GetAllSchemes()
+                    .FirstOrDefault(s => s.IsActive)?.PSGuid;
+                Logger.LogInfo($"Captured original power scheme: {_originalPowerSchemeGuid ?? "UNKNOWN"}");
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning($"Failed to capture original power scheme: {ex.Message}");
+            }
+        }
+
+        private static void SwitchToHighestPerformanceIfNeeded()
+        {
+            if (_powerSchemeSwitched)
+            {
+                return;
+            }
+
+            try
+            {
+                powerSchemeManager.RefreshSchemes();
+                var highest = powerSchemeManager.GetHighestPerformanceScheme();
+                if (highest == null)
+                {
+                    Logger.LogInfo("No power schemes found when attempting high performance switch.");
+                    return;
+                }
+
+                if (highest.IsActive)
+                {
+                    Logger.LogInfo("Already on highest performance scheme – no switch needed.");
+                    return;
+                }
+
+                if (_originalPowerSchemeGuid == null)
+                {
+                    CaptureOriginalPowerScheme();
+                }
+
+                if (powerSchemeManager.SwitchScheme(highest.PSGuid))
+                {
+                    _powerSchemeSwitched = true;
+                    Logger.LogInfo($"Switched to highest performance scheme: {highest.Name} ({highest.PSGuid})");
+                }
+                else
+                {
+                    Logger.LogWarning($"Failed to switch to highest performance scheme: {highest.Name} ({highest.PSGuid})");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning($"Exception while attempting to switch power scheme: {ex.Message}");
+            }
+        }
+
+        private static void RestoreOriginalPowerSchemeIfNeeded()
+        {
+            if (!_powerSchemeSwitched || string.IsNullOrWhiteSpace(_originalPowerSchemeGuid))
+            {
+                return;
+            }
+
+            try
+            {
+                if (powerSchemeManager.SwitchScheme(_originalPowerSchemeGuid))
+                {
+                    Logger.LogInfo($"Restored original power scheme: {_originalPowerSchemeGuid}");
+                }
+                else
+                {
+                    Logger.LogWarning($"Failed to restore original power scheme: {_originalPowerSchemeGuid}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning($"Exception restoring original power scheme: {ex.Message}");
+            }
+            finally
+            {
+                _powerSchemeSwitched = false;
+            }
+        }
+
         internal static void SetIndefiniteKeepAwake(bool keepDisplayOn = false, int processId = 0, [CallerMemberName] string callerName = "")
         {
             PowerToysTelemetry.Log.WriteEvent(new Telemetry.AwakeIndefinitelyKeepAwakeEvent());
@@ -400,18 +535,24 @@ namespace Awake.Core
         internal static void CompleteExit(int exitCode)
         {
             SetPassiveKeepAwake(updateSettings: false);
-
+            RestoreOriginalPowerSchemeIfNeeded();
             if (TrayHelper.WindowHandle != IntPtr.Zero)
             {
-                // Delete the icon.
                 TrayHelper.SetShellIcon(TrayHelper.WindowHandle, string.Empty, null, TrayIconAction.Delete);
-
-                // Close the message window that we used for the tray.
                 Bridge.SendMessage(TrayHelper.WindowHandle, Native.Constants.WM_CLOSE, 0, 0);
-
                 Bridge.DestroyWindow(TrayHelper.WindowHandle);
             }
 
+            // Dispose usage tracker (flushes data)
+            try
+            {
+                UsageTracker?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning($"Failed disposing UsageTracker: {ex.Message}");
+            }
+
             Bridge.PostQuitMessage(exitCode);
             Environment.Exit(exitCode);
         }
@@ -500,6 +641,275 @@ namespace Awake.Core
             SetModeShellIcon();
         }
 
+        internal static void SetActivityBasedKeepAwake(
+            uint cpuThresholdPercent,
+            uint memThresholdPercent,
+            uint netThresholdKBps,
+            uint sampleIntervalSeconds,
+            uint inactivityTimeoutSeconds,
+            bool keepDisplayOn,
+            [CallerMemberName] string callerName = "")
+        {
+            Logger.LogInfo($"Activity-based keep-awake invoked by {callerName}. CPU>={cpuThresholdPercent}%, MEM>={memThresholdPercent}%, NET>={netThresholdKBps}KB/s sample={sampleIntervalSeconds}s timeout={inactivityTimeoutSeconds}s display={keepDisplayOn}.");
+
+            CancelExistingThread();
+
+            if (IsUsingPowerToysConfig)
+            {
+                try
+                {
+                    AwakeSettings currentSettings = ModuleSettings!.GetSettings<AwakeSettings>(Constants.AppName) ?? new AwakeSettings();
+                    bool settingsChanged =
+                        currentSettings.Properties.Mode != AwakeMode.ACTIVITY ||
+                        currentSettings.Properties.ActivityCpuThresholdPercent != cpuThresholdPercent ||
+                        currentSettings.Properties.ActivityMemoryThresholdPercent != memThresholdPercent ||
+                        currentSettings.Properties.ActivityNetworkThresholdKBps != netThresholdKBps ||
+                        currentSettings.Properties.ActivitySampleIntervalSeconds != sampleIntervalSeconds ||
+                        currentSettings.Properties.ActivityInactivityTimeoutSeconds != inactivityTimeoutSeconds ||
+                        currentSettings.Properties.KeepDisplayOn != keepDisplayOn;
+
+                    if (settingsChanged)
+                    {
+                        currentSettings.Properties.Mode = AwakeMode.ACTIVITY;
+                        currentSettings.Properties.ActivityCpuThresholdPercent = cpuThresholdPercent;
+                        currentSettings.Properties.ActivityMemoryThresholdPercent = memThresholdPercent;
+                        currentSettings.Properties.ActivityNetworkThresholdKBps = netThresholdKBps;
+                        currentSettings.Properties.ActivitySampleIntervalSeconds = sampleIntervalSeconds;
+                        currentSettings.Properties.ActivityInactivityTimeoutSeconds = inactivityTimeoutSeconds;
+                        currentSettings.Properties.KeepDisplayOn = keepDisplayOn;
+                        ModuleSettings!.SaveSettings(JsonSerializer.Serialize(currentSettings), Constants.AppName);
+                        return; // Settings will be processed triggering this again
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError($"Failed to persist activity mode settings: {ex.Message}");
+                }
+            }
+
+            // Initialize performance counters
+            try
+            {
+                _cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
+                _memCounter = new PerformanceCounter("Memory", "% Committed Bytes In Use");
+                _netCounters = PerformanceCounterCategory.GetCategories()
+                    .FirstOrDefault(c => c.CategoryName == "Network Interface")?
+                    .GetInstanceNames()
+                    .Select(n => new PerformanceCounter("Network Interface", "Bytes Total/sec", n))
+                    .ToList() ?? new List<PerformanceCounter>();
+                _cpuCounter.NextValue(); // Prime CPU counter
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Failed to initialize performance counters for activity mode: {ex.Message}");
+                return;
+            }
+
+            _activityCpu = cpuThresholdPercent;
+            _activityMem = memThresholdPercent;
+            _activityNetKBps = netThresholdKBps;
+            _activitySample = Math.Max(1, sampleIntervalSeconds);
+            _activityTimeout = Math.Max(5, inactivityTimeoutSeconds);
+            _activityKeepDisplay = keepDisplayOn;
+            _activityLastHigh = DateTimeOffset.Now;
+            _activityActive = true;
+
+            CurrentOperatingMode = AwakeMode.ACTIVITY;
+            IsDisplayOn = keepDisplayOn;
+            SetModeShellIcon();
+
+            // Capture original scheme before any switch
+            CaptureOriginalPowerScheme();
+
+            TimeSpan sampleInterval = TimeSpan.FromSeconds(_activitySample);
+
+            Observable.Interval(sampleInterval).Subscribe(
+                _ =>
+                {
+                    if (!_activityActive)
+                    {
+                        return;
+                    }
+
+                    float cpu = 0;
+                    float mem = 0;
+                    double netKBps = 0;
+
+                    try
+                    {
+                        cpu = _cpuCounter?.NextValue() ?? 0;
+                        mem = _memCounter?.NextValue() ?? 0;
+                        if (_netCounters != null && _netCounters.Count > 0)
+                        {
+                            netKBps = _netCounters.Sum(c => c.NextValue()) / 1024.0;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.LogError($"Performance counter read failure: {ex.Message}");
+                    }
+
+                    bool above =
+                        (_activityCpu == 0 || cpu >= _activityCpu) ||
+                        (_activityMem == 0 || mem >= _activityMem) ||
+                        (_activityNetKBps == 0 || netKBps >= _activityNetKBps);
+
+                    if (above)
+                    {
+                        _activityLastHigh = DateTimeOffset.Now;
+                        _stateQueue.Add(ComputeAwakeState(_activityKeepDisplay));
+                        SwitchToHighestPerformanceIfNeeded();
+                    }
+
+                    TrayHelper.SetShellIcon(
+                        TrayHelper.WindowHandle,
+                        $"{Constants.FullAppName} [Activity][{ScreenStateString}][CPU {cpu:0.#}% | MEM {mem:0.#}% | NET {netKBps:0.#}KB/s]",
+                        TrayHelper.IndefiniteIcon,
+                        TrayIconAction.Update);
+
+                    if ((DateTimeOffset.Now - _activityLastHigh).TotalSeconds >= _activityTimeout)
+                    {
+                        Logger.LogInfo("Activity thresholds not met within timeout window. Ending activity mode.");
+                        _activityActive = false;
+                        CancelExistingThread();
+                        RestoreOriginalPowerSchemeIfNeeded();
+
+                        if (IsUsingPowerToysConfig)
+                        {
+                            SetPassiveKeepAwake();
+                        }
+                        else
+                        {
+                            CompleteExit(Environment.ExitCode);
+                        }
+                    }
+                },
+                ex =>
+                {
+                    Logger.LogError($"Activity mode observable failure: {ex.Message}");
+                },
+                _tokenSource.Token);
+        }
+
+        internal static void SetProcessBasedKeepAwake(
+            List<string> processNames,
+            uint checkIntervalSeconds,
+            bool keepDisplayOn,
+            [CallerMemberName] string callerName = "")
+        {
+            Logger.LogInfo($"Process-based keep-awake invoked by {callerName}. Processes: [{string.Join(", ", processNames)}], CheckInterval: {checkIntervalSeconds}s, Display: {keepDisplayOn}.");
+
+            CancelExistingThread();
+
+            if (IsUsingPowerToysConfig)
+            {
+                try
+                {
+                    AwakeSettings currentSettings = ModuleSettings!.GetSettings<AwakeSettings>(Constants.AppName) ?? new AwakeSettings();
+                    bool settingsChanged =
+                        currentSettings.Properties.Mode != AwakeMode.PROCESS ||
+                        !currentSettings.Properties.ProcessMonitoringList.SequenceEqual(processNames) ||
+                        currentSettings.Properties.ProcessCheckIntervalSeconds != checkIntervalSeconds ||
+                        currentSettings.Properties.KeepDisplayOn != keepDisplayOn;
+
+                    if (settingsChanged)
+                    {
+                        currentSettings.Properties.Mode = AwakeMode.PROCESS;
+                        currentSettings.Properties.ProcessMonitoringList = new List<string>(processNames);
+                        currentSettings.Properties.ProcessCheckIntervalSeconds = checkIntervalSeconds;
+                        currentSettings.Properties.KeepDisplayOn = keepDisplayOn;
+                        ModuleSettings!.SaveSettings(JsonSerializer.Serialize(currentSettings), Constants.AppName);
+                        return; // Settings will be processed triggering this again
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError($"Failed to persist process monitoring settings: {ex.Message}");
+                }
+            }
+
+            _processMonitoringList = [.. processNames];
+            _processCheckInterval = Math.Max(1, checkIntervalSeconds);
+            _processKeepDisplay = keepDisplayOn;
+            _processMonitoringActive = true;
+
+            CurrentOperatingMode = AwakeMode.PROCESS;
+            IsDisplayOn = keepDisplayOn;
+            SetModeShellIcon();
+
+            TimeSpan checkInterval = TimeSpan.FromSeconds(_processCheckInterval);
+
+            Observable.Interval(checkInterval).Subscribe(
+                _ =>
+                {
+                    if (!_processMonitoringActive)
+                    {
+                        return;
+                    }
+
+                    bool anyTargetProcessRunning = false;
+                    List<string> runningProcesses = new();
+
+                    try
+                    {
+                        foreach (string processName in _processMonitoringList)
+                        {
+                            if (string.IsNullOrWhiteSpace(processName))
+                            {
+                                continue;
+                            }
+
+                            // Remove .exe extension if present for process name comparison
+                            string processNameWithoutExt = processName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
+                                ? processName.Substring(0, processName.Length - 4)
+                                : processName;
+
+                            Process[] processes = Process.GetProcessesByName(processNameWithoutExt);
+                            if (processes.Length > 0)
+                            {
+                                anyTargetProcessRunning = true;
+                                runningProcesses.Add(processNameWithoutExt);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.LogError($"Process monitoring check failure: {ex.Message}");
+                    }
+
+                    if (anyTargetProcessRunning)
+                    {
+                        _stateQueue.Add(ComputeAwakeState(_processKeepDisplay));
+
+                        TrayHelper.SetShellIcon(
+                            TrayHelper.WindowHandle,
+                            $"{Constants.FullAppName} [Process Monitor][{ScreenStateString}][Running: {string.Join(", ", runningProcesses)}]",
+                            TrayHelper.IndefiniteIcon,
+                            TrayIconAction.Update);
+                    }
+                    else
+                    {
+                        Logger.LogInfo("No target processes running. Ending process monitoring mode.");
+                        _processMonitoringActive = false;
+                        CancelExistingThread();
+
+                        if (IsUsingPowerToysConfig)
+                        {
+                            SetPassiveKeepAwake();
+                        }
+                        else
+                        {
+                            CompleteExit(Environment.ExitCode);
+                        }
+                    }
+                },
+                ex =>
+                {
+                    Logger.LogError($"Process monitoring observable failure: {ex.Message}");
+                },
+                _tokenSource.Token);
+        }
+
         /// <summary>
         /// Sets the display settings.
         /// </summary>
@@ -533,6 +943,100 @@ namespace Awake.Core
             }
         }
 
+        /// <summary>
+        /// Gets the current Awake configuration status.
+        /// </summary>
+        /// <returns>Current configuration status information.</returns>
+        public static object GetCurrentConfig()
+        {
+            try
+            {
+                AwakeSettings currentSettings = ModuleSettings?.GetSettings<AwakeSettings>(Constants.AppName) ?? new AwakeSettings();
+
+                var baseConfig = new
+                {
+                    mode = CurrentOperatingMode.ToString(),
+                    keepDisplayOn = IsDisplayOn,
+                    processId = ProcessId,
+                    isUsingPowerToysConfig = IsUsingPowerToysConfig,
+                };
+
+                // Return different parameters based on the current mode
+                return CurrentOperatingMode switch
+                {
+                    AwakeMode.PASSIVE => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    AwakeMode.INDEFINITE => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    AwakeMode.TIMED => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        timeRemaining = TimeRemaining,
+                        intervalHours = currentSettings.Properties.IntervalHours,
+                        intervalMinutes = currentSettings.Properties.IntervalMinutes,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    AwakeMode.EXPIRABLE => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        expireAt = ExpireAt == DateTimeOffset.MinValue ? (DateTimeOffset?)null : ExpireAt,
+                        expirationDateTime = currentSettings.Properties.ExpirationDateTime,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    AwakeMode.ACTIVITY => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        cpuThresholdPercent = currentSettings.Properties.ActivityCpuThresholdPercent,
+                        memoryThresholdPercent = currentSettings.Properties.ActivityMemoryThresholdPercent,
+                        networkThresholdKBps = currentSettings.Properties.ActivityNetworkThresholdKBps,
+                        sampleIntervalSeconds = currentSettings.Properties.ActivitySampleIntervalSeconds,
+                        inactivityTimeoutSeconds = currentSettings.Properties.ActivityInactivityTimeoutSeconds,
+                        activityActive = _activityActive,
+                        lastHighActivity = _activityLastHigh,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    AwakeMode.PROCESS => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        processMonitoringList = currentSettings.Properties.ProcessMonitoringList,
+                        processCheckIntervalSeconds = currentSettings.Properties.ProcessCheckIntervalSeconds,
+                        processMonitoringActive = _processMonitoringActive,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                    },
+                    _ => new
+                    {
+                        baseConfig.mode,
+                        baseConfig.keepDisplayOn,
+                        baseConfig.processId,
+                        baseConfig.isUsingPowerToysConfig,
+                        error = "Unknown mode",
+                    },
+                };
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Failed to get current config: {ex.Message}");
+                return new { error = "Failed to get current configuration", message = ex.Message };
+            }
+        }
+
         public static Process? GetParentProcess()
         {
             return GetParentProcess(Process.GetCurrentProcess().Handle);

src/modules/awake/Awake/Core/Models/TrayCommands.cs

@@ -10,6 +10,7 @@ namespace Awake.Core.Models
         TC_MODE_PASSIVE = Native.Constants.WM_USER + 0x3,
         TC_MODE_INDEFINITE = Native.Constants.WM_USER + 0x4,
         TC_MODE_EXPIRABLE = Native.Constants.WM_USER + 0x5,
+        TC_MODE_ACTIVITY = Native.Constants.WM_USER + 0x6,
         TC_EXIT = Native.Constants.WM_USER + 0x64,
         TC_TIME = Native.Constants.WM_USER + 0x65,
     }

src/modules/awake/Awake/Core/Native/IdleTime.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;
+using System.Runtime.InteropServices;
+
+namespace Awake.Core.Native
+{
+    internal static class IdleTime
+    {
+        // Keep original native field names but suppress StyleCop (interop requires exact names).
+        [StructLayout(LayoutKind.Sequential)]
+        private struct LASTINPUTINFO
+        {
+#pragma warning disable SA1307 // Interop field naming
+            public uint cbSize;
+            public uint dwTime;
+#pragma warning restore SA1307
+        }
+
+        [DllImport("user32.dll")]
+        private static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
+
+        public static TimeSpan GetIdleTime()
+        {
+            LASTINPUTINFO info = new()
+            {
+                cbSize = (uint)Marshal.SizeOf<LASTINPUTINFO>(),
+            };
+
+            if (!GetLastInputInfo(ref info))
+            {
+                return TimeSpan.Zero;
+            }
+
+            // Calculate elapsed milliseconds since last input considering Environment.TickCount wrap.
+            uint lastInputTicks = info.dwTime;
+            uint nowTicks = (uint)Environment.TickCount;
+            uint delta = nowTicks >= lastInputTicks ? nowTicks - lastInputTicks : (uint.MaxValue - lastInputTicks) + nowTicks + 1;
+            return TimeSpan.FromMilliseconds(delta);
+        }
+    }
+}

src/modules/awake/Awake/Core/PowerSchemeManager.cs

@@ -0,0 +1,136 @@
+// 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.Text.RegularExpressions;
+
+namespace Awake.Core
+{
+    public class PowerSchemeManager
+    {
+        private readonly List<PowerScheme> _schemes = new();
+
+        public PowerSchemeManager()
+        {
+            RefreshSchemes();
+        }
+
+        public void RefreshSchemes()
+        {
+            _schemes.Clear();
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "powercfg",
+                    Arguments = "/L",
+                    RedirectStandardOutput = true,
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                },
+            };
+            process.Start();
+            string output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit();
+
+            var matches = Regex.Matches(output, @"Power Scheme GUID: ([a-fA-F0-9\-]+)\s+\((.+?)\)(\s+\*)?");
+            foreach (Match match in matches)
+            {
+                _schemes.Add(new PowerScheme
+                {
+                    PSGuid = match.Groups[1].Value,
+                    Name = match.Groups[2].Value,
+                    IsActive = match.Groups[3].Value.Contains('*'),
+                });
+            }
+
+            // Rank schemes by performance (descending)
+            _schemes.Sort((a, b) => GetScore(b).CompareTo(GetScore(a)));
+        }
+
+        /// <summary>
+        /// Returns all power schemes sorted by performance (highest first).
+        /// </summary>
+        public IReadOnlyList<PowerScheme> GetAllSchemes() => _schemes;
+
+        /// <summary>
+        /// Returns the highest performance scheme currently available (may already be active).
+        /// </summary>
+        public PowerScheme? GetHighestPerformanceScheme()
+        {
+            if (_schemes.Count == 0)
+            {
+                RefreshSchemes();
+            }
+
+            return _schemes.Count == 0 ? null : _schemes[0];
+        }
+
+        public bool SwitchScheme(string psGuid)
+        {
+            try
+            {
+                var process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "powercfg",
+                        Arguments = $"/setactive {psGuid}",
+                        UseShellExecute = false,
+                        CreateNoWindow = true,
+                    },
+                };
+                process.Start();
+                process.WaitForExit();
+                RefreshSchemes();
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private static int GetScore(PowerScheme scheme)
+        {
+            // Heuristic based on name (multi-language basic keywords).
+            string name = scheme.Name.ToLowerInvariant();
+
+            // High performance indicators
+            if (name.Contains("ultimate") || name.Contains("ultra"))
+            {
+                return 380;
+            }
+
+            if (name.Contains("high"))
+            {
+                return 310;
+            }
+
+            if (name.Contains("balanced"))
+            {
+                return 200;
+            }
+
+            if (name.Contains("saver"))
+            {
+                return 120;
+            }
+
+            // Default for unknown custom plans.
+            return 180;
+        }
+
+        public class PowerScheme
+        {
+            public string PSGuid { get; set; } = string.Empty;
+
+            public string Name { get; set; } = string.Empty;
+
+            public bool IsActive { get; set; }
+        }
+    }
+}

src/modules/awake/Awake/Core/TrayHelper.cs

@@ -306,6 +306,19 @@ namespace Awake.Core
                                 break;
                             }
 
+                        case (uint)TrayCommands.TC_MODE_ACTIVITY:
+                            {
+                                AwakeSettings settings = Manager.ModuleSettings!.GetSettings<AwakeSettings>(Constants.AppName);
+                                Manager.SetActivityBasedKeepAwake(
+                                    settings.Properties.ActivityCpuThresholdPercent,
+                                    settings.Properties.ActivityMemoryThresholdPercent,
+                                    settings.Properties.ActivityNetworkThresholdKBps,
+                                    settings.Properties.ActivitySampleIntervalSeconds,
+                                    settings.Properties.ActivityInactivityTimeoutSeconds,
+                                    settings.Properties.KeepDisplayOn);
+                                break;
+                            }
+
                         case (uint)TrayCommands.TC_MODE_PASSIVE:
                             {
                                 Manager.SetPassiveKeepAwake();
@@ -455,6 +468,7 @@ namespace Awake.Core
             InsertMenuItem(0, TrayCommands.TC_MODE_PASSIVE, Resources.AWAKE_OFF, mode == AwakeMode.PASSIVE);
             InsertMenuItem(0, TrayCommands.TC_MODE_INDEFINITE, Resources.AWAKE_KEEP_INDEFINITELY, mode == AwakeMode.INDEFINITE);
             InsertMenuItem(0, TrayCommands.TC_MODE_EXPIRABLE, Resources.AWAKE_KEEP_UNTIL_EXPIRATION, mode == AwakeMode.EXPIRABLE, true);
+            InsertMenuItem(0, TrayCommands.TC_MODE_ACTIVITY, Resources.AWAKE_KEEP_ON_ACTIVITY, mode == AwakeMode.ACTIVITY);
         }
     }
 }

src/modules/awake/Awake/Core/Usage/ForegroundUsageTracker.cs

@@ -0,0 +1,364 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+using System.Timers;
+using Awake.Core.Native;
+using Awake.Core.Usage.Models;
+using ManagedCommon;
+using Microsoft.PowerToys.Settings.UI.Library;
+
+namespace Awake.Core.Usage
+{
+    internal sealed class ForegroundUsageTracker : IDisposable
+    {
+        private const uint EventSystemForeground = 0x0003;
+        private const uint WinEventOutOfContext = 0x0000;
+        private const double CommitThresholdSeconds = 0.25;
+
+        private static readonly JsonSerializerOptions LegacySerializer = new()
+        {
+            WriteIndented = true,
+        };
+
+        private delegate void WinEventDelegate(
+            IntPtr hWinEventHook,
+            uint eventType,
+            IntPtr hwnd,
+            int idObject,
+            int idChild,
+            uint dwEventThread,
+            uint dwmsEventTime);
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr SetWinEventHook(
+            uint eventMin,
+            uint eventMax,
+            IntPtr hmodWinEventProc,
+            WinEventDelegate lpfnWinEventProc,
+            uint idProcess,
+            uint idThread,
+            uint dwFlags);
+
+        [DllImport("user32.dll")]
+        private static extern bool UnhookWinEvent(IntPtr hWinEventHook);
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr GetForegroundWindow();
+
+        [DllImport("user32.dll")]
+        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+
+        private readonly object _lock = new();
+        private readonly string _legacyJsonPath;
+        private readonly string _dbPath;
+        private readonly Timer _flushTimer;
+        private readonly Timer _pollTimer;
+        private readonly TimeSpan _idleThreshold = TimeSpan.FromSeconds(60);
+        private readonly Dictionary<string, AppUsageRecord> _sessionCache = new(StringComparer.OrdinalIgnoreCase);
+
+        private IUsageStore _store;
+
+        private string? _activeProcess;
+        private DateTime _activeSince;
+        private IntPtr _hook;
+        private WinEventDelegate? _hookDelegate;
+        private IntPtr _lastHwnd;
+        private int _retentionDays;
+        private bool _disposed;
+
+        internal bool Enabled { get; private set; }
+
+        public ForegroundUsageTracker(string legacyJsonPath, int retentionDays)
+        {
+            _legacyJsonPath = legacyJsonPath;
+            _dbPath = Path.Combine(Path.GetDirectoryName(legacyJsonPath)!, "usage.sqlite");
+            _retentionDays = retentionDays;
+            _store = new SqliteUsageStore(_dbPath);
+
+            _flushTimer = new Timer(5000)
+            {
+                AutoReset = true,
+            };
+            _flushTimer.Elapsed += (_, _) => FlushInternal();
+
+            _pollTimer = new Timer(1000)
+            {
+                AutoReset = true,
+            };
+            _pollTimer.Elapsed += (_, _) => PollForeground();
+
+            TryImportLegacy();
+        }
+
+        private void TryImportLegacy()
+        {
+            try
+            {
+                if (!File.Exists(_legacyJsonPath))
+                {
+                    return;
+                }
+
+                string json = File.ReadAllText(_legacyJsonPath);
+                List<AppUsageRecord> list = JsonSerializer.Deserialize<List<AppUsageRecord>>(json, LegacySerializer) ?? new();
+                foreach (AppUsageRecord r in list)
+                {
+                    _store.AddSpan(r.ProcessName, r.TotalSeconds, r.FirstSeenUtc, r.LastUpdatedUtc, _retentionDays);
+                }
+
+                Logger.LogInfo("[AwakeUsage] Imported legacy usage.json into SQLite. Deleting old file.");
+                File.Delete(_legacyJsonPath);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning("[AwakeUsage] Legacy import failed: " + ex.Message);
+            }
+        }
+
+        public void Configure(bool enabled, int retentionDays)
+        {
+            _retentionDays = Math.Max(1, retentionDays);
+            if (enabled == Enabled)
+            {
+                return;
+            }
+
+            Enabled = enabled;
+            if (Enabled)
+            {
+                _activeSince = DateTime.UtcNow;
+                _hookDelegate = WinEventCallback;
+                _hook = SetWinEventHook(EventSystemForeground, EventSystemForeground, IntPtr.Zero, _hookDelegate, 0, 0, WinEventOutOfContext);
+                Logger.LogInfo(_hook != IntPtr.Zero ? "[AwakeUsage] WinEvent hook installed." : "[AwakeUsage] WinEvent hook failed (poll fallback)");
+                CaptureInitialForeground();
+                _flushTimer.Start();
+                _pollTimer.Start();
+                Logger.LogInfo("[AwakeUsage] Tracking enabled (5s flush, sqlite store).");
+            }
+            else
+            {
+                _flushTimer.Stop();
+                _pollTimer.Stop();
+                if (_hook != IntPtr.Zero)
+                {
+                    UnhookWinEvent(_hook);
+                    _hook = IntPtr.Zero;
+                }
+
+                CommitActiveSpan();
+                FlushInternal(force: true);
+                Logger.LogInfo("[AwakeUsage] Tracking disabled.");
+            }
+        }
+
+        private void WinEventCallback(
+            IntPtr hWinEventHook,
+            uint evt,
+            IntPtr hwnd,
+            int idObj,
+            int idChild,
+            uint thread,
+            uint time)
+        {
+            if (_disposed || !Enabled || evt != EventSystemForeground)
+            {
+                return;
+            }
+
+            HandleForegroundChange(hwnd, "hook");
+        }
+
+        private void PollForeground()
+        {
+            if (_disposed || !Enabled)
+            {
+                return;
+            }
+
+            IntPtr hwnd = GetForegroundWindow();
+            if (hwnd == IntPtr.Zero || hwnd == _lastHwnd)
+            {
+                return;
+            }
+
+            HandleForegroundChange(hwnd, "poll");
+        }
+
+        private void CaptureInitialForeground()
+        {
+            IntPtr hwnd = GetForegroundWindow();
+            if (hwnd == IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (TryResolveProcess(hwnd, out string? name))
+            {
+                _activeProcess = name;
+                _activeSince = DateTime.UtcNow;
+                _lastHwnd = hwnd;
+            }
+        }
+
+        private bool TryResolveProcess(IntPtr hwnd, out string? name)
+        {
+            name = null;
+            try
+            {
+                uint pid;
+                uint tid = GetWindowThreadProcessId(hwnd, out pid);
+                if (tid == 0 || pid == 0)
+                {
+                    return false;
+                }
+
+                using Process p = Process.GetProcessById((int)pid);
+                name = SafeProcessName(p);
+                return !string.IsNullOrWhiteSpace(name);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private static string SafeProcessName(Process p)
+        {
+            try
+            {
+                return Path.GetFileName(p.MainModule?.FileName) ?? p.ProcessName;
+            }
+            catch
+            {
+                return p.ProcessName;
+            }
+        }
+
+        private void HandleForegroundChange(IntPtr hwnd, string source)
+        {
+            try
+            {
+                CommitActiveSpan();
+                if (!TryResolveProcess(hwnd, out string? name))
+                {
+                    _activeProcess = null;
+                    return;
+                }
+
+                _activeProcess = name;
+                _activeSince = DateTime.UtcNow;
+                _lastHwnd = hwnd;
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning("[AwakeUsage] FG change failed: " + ex.Message);
+            }
+        }
+
+        private void CommitActiveSpan()
+        {
+            if (string.IsNullOrEmpty(_activeProcess))
+            {
+                return;
+            }
+
+            if (IdleTime.GetIdleTime() > _idleThreshold)
+            {
+                _activeProcess = null;
+                return;
+            }
+
+            double secs = (DateTime.UtcNow - _activeSince).TotalSeconds;
+            if (secs < CommitThresholdSeconds)
+            {
+                return;
+            }
+
+            lock (_lock)
+            {
+                if (!_sessionCache.TryGetValue(_activeProcess!, out AppUsageRecord? rec))
+                {
+                    rec = new AppUsageRecord
+                    {
+                        ProcessName = _activeProcess!,
+                        FirstSeenUtc = DateTime.UtcNow,
+                        LastUpdatedUtc = DateTime.UtcNow,
+                        TotalSeconds = 0,
+                    };
+                    _sessionCache[_activeProcess!] = rec;
+                }
+
+                rec.TotalSeconds += secs;
+                rec.LastUpdatedUtc = DateTime.UtcNow;
+            }
+
+            _activeSince = DateTime.UtcNow;
+        }
+
+        private void FlushInternal(bool force = false)
+        {
+            try
+            {
+                CommitActiveSpan();
+
+                Dictionary<string, AppUsageRecord> snapshot;
+                lock (_lock)
+                {
+                    snapshot = _sessionCache.ToDictionary(k => k.Key, v => v.Value);
+                    _sessionCache.Clear();
+                }
+
+                foreach (AppUsageRecord rec in snapshot.Values)
+                {
+                    _store.AddSpan(rec.ProcessName, rec.TotalSeconds, rec.FirstSeenUtc, rec.LastUpdatedUtc, _retentionDays);
+                }
+
+                if (force)
+                {
+                    _store.Prune(_retentionDays);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning("[AwakeUsage] Flush failed: " + ex.Message);
+            }
+        }
+
+        public IReadOnlyList<AppUsageRecord> GetSummary(int top, int days)
+        {
+            CommitActiveSpan();
+            FlushInternal();
+            try
+            {
+                return _store.Query(top, days);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning("[AwakeUsage] Query failed: " + ex.Message);
+                return Array.Empty<AppUsageRecord>();
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+            Configure(false, _retentionDays);
+            _store.Dispose();
+            _flushTimer.Dispose();
+            _pollTimer.Dispose();
+        }
+    }
+}

src/modules/awake/Awake/Core/Usage/IUsageStore.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.
+
+#pragma warning disable SA1516, SA1636
+using System;
+using System.Collections.Generic;
+using Awake.Core.Usage.Models;
+
+namespace Awake.Core.Usage
+{
+    internal interface IUsageStore : IDisposable
+    {
+        void AddSpan(string processName, double seconds, DateTime firstSeenUtc, DateTime lastUpdatedUtc, int retentionDays);
+
+        IReadOnlyList<AppUsageRecord> Query(int top, int days);
+
+        void Prune(int retentionDays);
+    }
+}
+#pragma warning restore SA1516, SA1636

src/modules/awake/Awake/Core/Usage/Models/AppUsageRecord.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.
+
+using System;
+using System.Text.Json.Serialization;
+
+namespace Awake.Core.Usage.Models
+{
+    internal sealed class AppUsageRecord
+    {
+        [JsonPropertyName("process")]
+        public string ProcessName { get; set; } = string.Empty;
+
+        [JsonPropertyName("totalSeconds")]
+        public double TotalSeconds { get; set; }
+
+        [JsonPropertyName("lastUpdatedUtc")]
+        public DateTime LastUpdatedUtc { get; set; }
+
+        [JsonPropertyName("firstSeenUtc")]
+        public DateTime FirstSeenUtc { get; set; }
+    }
+}

src/modules/awake/Awake/Core/Usage/SqliteUsageStore.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.
+
+#pragma warning disable SA1516, SA1210, SA1636
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using Awake.Core.Usage.Models;
+using ManagedCommon;
+using Microsoft.Data.Sqlite;
+
+namespace Awake.Core.Usage
+{
+    internal sealed class SqliteUsageStore : IUsageStore
+    {
+        private readonly string _dbPath;
+        private readonly string _connectionString;
+
+        public SqliteUsageStore(string dbPath)
+        {
+            _dbPath = dbPath;
+            Directory.CreateDirectory(Path.GetDirectoryName(dbPath)!);
+            _connectionString = new SqliteConnectionStringBuilder
+            {
+                DataSource = _dbPath,
+                Mode = SqliteOpenMode.ReadWriteCreate,
+            }.ToString();
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            using SqliteConnection conn = new(_connectionString);
+            conn.Open();
+            using SqliteCommand cmd = conn.CreateCommand();
+            cmd.CommandText = @"CREATE TABLE IF NOT EXISTS process_usage (
+                process_name TEXT NOT NULL,
+                day_utc TEXT NOT NULL,
+                total_seconds REAL NOT NULL,
+                first_seen_utc TEXT NOT NULL,
+                last_updated_utc TEXT NOT NULL,
+                PRIMARY KEY(process_name, day_utc)
+            );";
+            cmd.ExecuteNonQuery();
+        }
+
+        public void AddSpan(string processName, double seconds, DateTime firstSeenUtc, DateTime lastUpdatedUtc, int retentionDays)
+        {
+            if (seconds <= 0)
+            {
+                return;
+            }
+
+            string day = DateTime.UtcNow.ToString("yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
+            using SqliteConnection conn = new(_connectionString);
+            conn.Open();
+            using SqliteTransaction tx = conn.BeginTransaction();
+            using (SqliteCommand cmd = conn.CreateCommand())
+            {
+                cmd.Transaction = tx;
+                cmd.CommandText = @"INSERT INTO process_usage(process_name, day_utc, total_seconds, first_seen_utc, last_updated_utc)
+VALUES($p,$d,$s,$f,$l)
+ON CONFLICT(process_name,day_utc) DO UPDATE SET 
+  total_seconds = total_seconds + excluded.total_seconds,
+  last_updated_utc = excluded.last_updated_utc;";
+                cmd.Parameters.AddWithValue("$p", processName);
+                cmd.Parameters.AddWithValue("$d", day);
+                cmd.Parameters.AddWithValue("$s", seconds);
+                cmd.Parameters.AddWithValue("$f", firstSeenUtc.ToString("o"));
+                cmd.Parameters.AddWithValue("$l", lastUpdatedUtc.ToString("o"));
+                cmd.ExecuteNonQuery();
+            }
+
+            using (SqliteCommand prune = conn.CreateCommand())
+            {
+                prune.Transaction = tx;
+                prune.CommandText = @"DELETE FROM process_usage WHERE day_utc < date('now', @retention);";
+                prune.Parameters.AddWithValue("@retention", $"-{Math.Max(1, retentionDays)} days");
+                prune.ExecuteNonQuery();
+            }
+
+            tx.Commit();
+        }
+
+        public IReadOnlyList<AppUsageRecord> Query(int top, int days)
+        {
+            List<AppUsageRecord> result = new();
+            int safeDays = Math.Max(1, days);
+            using SqliteConnection conn = new(_connectionString);
+            conn.Open();
+            using SqliteCommand cmd = conn.CreateCommand();
+            cmd.CommandText = @"SELECT process_name, SUM(total_seconds) AS total_seconds, MIN(first_seen_utc) AS first_seen_utc, MAX(last_updated_utc) AS last_updated_utc
+FROM process_usage
+WHERE day_utc >= date('now', @cutoff)
+GROUP BY process_name
+ORDER BY total_seconds DESC
+LIMIT @top;";
+            cmd.Parameters.AddWithValue("@cutoff", $"-{safeDays} days");
+            cmd.Parameters.AddWithValue("@top", top);
+            using SqliteDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
+            while (reader.Read())
+            {
+                try
+                {
+                    string name = reader.GetString(0);
+                    double secs = reader.GetDouble(1);
+                    DateTime first = DateTime.Parse(reader.GetString(2), null, System.Globalization.DateTimeStyles.RoundtripKind);
+                    DateTime last = DateTime.Parse(reader.GetString(3), null, System.Globalization.DateTimeStyles.RoundtripKind);
+                    result.Add(new AppUsageRecord
+                    {
+                        ProcessName = name,
+                        TotalSeconds = secs,
+                        FirstSeenUtc = first,
+                        LastUpdatedUtc = last,
+                    });
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogWarning("[AwakeUsage][SQLite] Row parse failed: " + ex.Message);
+                }
+            }
+
+            return result;
+        }
+
+        public void Prune(int retentionDays)
+        {
+            using SqliteConnection conn = new(_connectionString);
+            conn.Open();
+            using SqliteCommand cmd = conn.CreateCommand();
+            cmd.CommandText = "DELETE FROM process_usage WHERE day_utc < date('now', @cutoff);";
+            cmd.Parameters.AddWithValue("@cutoff", $"-{Math.Max(1, retentionDays)} days");
+            cmd.ExecuteNonQuery();
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}
+
+#pragma warning restore SA1516, SA1210, SA1636

src/modules/awake/Awake/IAwakeAutomation.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;
+using System.Runtime.InteropServices;
+
+namespace Awake
+{
+    /// <summary>
+    /// COM automation interface exposed via ROT for controlling Awake.
+    /// </summary>
+    [ComVisible(true)]
+    [Guid("5CA92C1D-9D7E-4F6D-9B06-5B7B28BF4E21")]
+    public interface IAwakeAutomation
+    {
+        string Ping();
+
+        void SetIndefinite();
+
+        void SetTimed(int seconds);
+
+        void SetExpirable(int minutes);
+
+        void SetPassive();
+
+        void Cancel();
+
+        string GetStatusJson();
+    }
+}

src/modules/awake/Awake/Program.cs

@@ -18,6 +18,9 @@ using System.Threading.Tasks;
 using Awake.Core;
 using Awake.Core.Models;
 using Awake.Core.Native;
+
+// Usage tracking
+using Awake.Core.Usage;
 using Awake.Properties;
 using ManagedCommon;
 using Microsoft.PowerToys.Settings.UI.Library;
@@ -33,12 +36,22 @@ namespace Awake
         private static readonly string[] _aliasesPidOption = ["--pid", "-p"];
         private static readonly string[] _aliasesExpireAtOption = ["--expire-at", "-e"];
         private static readonly string[] _aliasesParentPidOption = ["--use-parent-pid", "-u"];
+        private static readonly string[] _aliasesHttpServerOption = ["--http-server", "-s"];
+        private static readonly string[] _aliasesHttpPortOption = ["--http-port"];
+        private static readonly string[] _aliasesActivityOption = ["--activity", "-a"];
+        private static readonly string[] _aliasesActivityCpuOption = ["--act-cpu"];
+        private static readonly string[] _aliasesActivityMemOption = ["--act-mem"];
+        private static readonly string[] _aliasesActivityNetOption = ["--act-net"];
+        private static readonly string[] _aliasesActivitySampleOption = ["--act-sample"];
+        private static readonly string[] _aliasesActivityTimeoutOption = ["--act-timeout"];
 
         private static readonly JsonSerializerOptions _serializerOptions = new() { IncludeFields = true };
         private static readonly ETWTrace _etwTrace = new();
 
         private static FileSystemWatcher? _watcher;
         private static SettingsUtils? _settingsUtils;
+        private static ManagedCommon.HttpServer? _httpServer;
+        private static AwakeHttpHandler? _awakeHttpHandler;
 
         private static bool _startedFromPowerToys;
 
@@ -71,7 +84,11 @@ namespace Awake
             }
 
             await TrayHelper.InitializeTray(TrayHelper.DefaultAwakeIcon, Core.Constants.FullAppName);
-            AppDomain.CurrentDomain.ProcessExit += (_, _) => TrayHelper.RunOnMainThread(() => LockMutex?.ReleaseMutex());
+            AppDomain.CurrentDomain.ProcessExit += (_, _) => TrayHelper.RunOnMainThread(() =>
+            {
+                _httpServer?.Dispose();
+                LockMutex?.ReleaseMutex();
+            });
             AppDomain.CurrentDomain.UnhandledException += AwakeUnhandledExceptionCatcher;
 
             if (!instantiated)
@@ -96,6 +113,12 @@ namespace Awake
                     Logger.LogInfo($"OS: {Environment.OSVersion}");
                     Logger.LogInfo($"OS Build: {Manager.GetOperatingSystemBuild()}");
 
+                    // Start background COM automation host (ROT) so any startup path exposes the automation surface.
+                    // Uses default moniker; could be extended with a --rotname parameter if needed later.
+                    var rotHost = new RotSingletonHost("Awake.Automation", () => new AwakeAutomation(), "AwakeAutomationRotThread");
+                    rotHost.Start();
+                    AppDomain.CurrentDomain.ProcessExit += (_, _) => rotHost.Stop();
+
                     TaskScheduler.UnobservedTaskException += (sender, args) =>
                     {
                         Trace.WriteLine($"Task scheduler error: {args.Exception.Message}"); // somebody forgot to check!
@@ -145,6 +168,50 @@ namespace Awake
                         IsRequired = false,
                     };
 
+                    Option<bool> httpServerOption = new(_aliasesHttpServerOption, () => true, "Enable HTTP server for remote control")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+
+                    Option<int> httpPortOption = new(_aliasesHttpPortOption, () => 8080, "HTTP server port (default: 8080)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+
+                    // Activity-based keep-awake options
+                    Option<bool> activityOption = new(_aliasesActivityOption, () => false, "Enable activity-based keep awake mode (CPU / Memory / Network)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+                    Option<uint> activityCpuOption = new(_aliasesActivityCpuOption, () => 20, "Activity mode CPU threshold percent (0-100, 0 to ignore)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+                    Option<uint> activityMemOption = new(_aliasesActivityMemOption, () => 50, "Activity mode Memory usage threshold percent (0-100, 0 to ignore)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+                    Option<uint> activityNetOption = new(_aliasesActivityNetOption, () => 100, "Activity mode total network throughput threshold KB/s (0 to ignore)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+                    Option<uint> activitySampleOption = new(_aliasesActivitySampleOption, () => 5, "Activity mode sampling interval in seconds (min 1)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+                    Option<uint> activityTimeoutOption = new(_aliasesActivityTimeoutOption, () => 60, "Activity mode inactivity timeout in seconds before reverting (min 5)")
+                    {
+                        Arity = ArgumentArity.ZeroOrOne,
+                        IsRequired = false,
+                    };
+
                     timeOption.AddValidator(result =>
                     {
                         if (result.Tokens.Count != 0 && !uint.TryParse(result.Tokens[0].Value, out _))
@@ -175,6 +242,16 @@ namespace Awake
                         }
                     });
 
+                    httpPortOption.AddValidator(result =>
+                    {
+                        if (result.Tokens.Count != 0 && (!int.TryParse(result.Tokens[0].Value, out int port) || port < 1 || port > 65535))
+                        {
+                            string errorMessage = $"HTTP port value could not be parsed correctly or is out of range (1-65535). Value used: {result.Tokens[0].Value}.";
+                            Logger.LogError(errorMessage);
+                            result.ErrorMessage = errorMessage;
+                        }
+                    });
+
                     RootCommand? rootCommand =
                     [
                         configOption,
@@ -183,10 +260,56 @@ namespace Awake
                         pidOption,
                         expireAtOption,
                         parentPidOption,
+                        httpServerOption,
+                        httpPortOption,
+                        activityOption,
+                        activityCpuOption,
+                        activityMemOption,
+                        activityNetOption,
+                        activitySampleOption,
+                        activityTimeoutOption,
                     ];
 
                     rootCommand.Description = Core.Constants.AppName;
-                    rootCommand.SetHandler(HandleCommandLineArguments, configOption, displayOption, timeOption, pidOption, expireAtOption, parentPidOption);
+
+                    // NOTE: The strongly-typed SetHandler overloads have an upper limit on the number of symbols
+                    // they accept. We exceed that limit with the new activity-mode parameters. Switch to a context
+                    // based handler and manually extract option values from the ParseResult.
+                    rootCommand.SetHandler(context =>
+                    {
+                        var pr = context.ParseResult;
+
+                        bool usePtConfig = pr.GetValueForOption(configOption);
+                        bool displayOn = pr.GetValueForOption(displayOption);
+                        uint timeLimit = pr.GetValueForOption(timeOption);
+                        int pid = pr.GetValueForOption(pidOption);
+                        string expireAt = pr.GetValueForOption(expireAtOption) ?? string.Empty;
+                        bool useParentPid = pr.GetValueForOption(parentPidOption);
+                        bool enableHttpServer = pr.GetValueForOption(httpServerOption);
+                        int httpPort = pr.GetValueForOption(httpPortOption);
+                        bool activityMode = pr.GetValueForOption(activityOption);
+                        uint actCpu = pr.GetValueForOption(activityCpuOption);
+                        uint actMem = pr.GetValueForOption(activityMemOption);
+                        uint actNet = pr.GetValueForOption(activityNetOption);
+                        uint actSample = pr.GetValueForOption(activitySampleOption);
+                        uint actTimeout = pr.GetValueForOption(activityTimeoutOption);
+
+                        HandleCommandLineArguments(
+                            usePtConfig,
+                            displayOn,
+                            timeLimit,
+                            pid,
+                            expireAt,
+                            useParentPid,
+                            enableHttpServer,
+                            httpPort,
+                            activityMode,
+                            actCpu,
+                            actMem,
+                            actNet,
+                            actSample,
+                            actTimeout);
+                    });
 
                     return rootCommand.InvokeAsync(args).Result;
                 }
@@ -211,12 +334,13 @@ namespace Awake
 
         private static void Exit(string message, int exitCode)
         {
+            _httpServer?.Dispose();
             _etwTrace?.Dispose();
             Logger.LogInfo(message);
             Manager.CompleteExit(exitCode);
         }
 
-        private static void HandleCommandLineArguments(bool usePtConfig, bool displayOn, uint timeLimit, int pid, string expireAt, bool useParentPid)
+        private static void HandleCommandLineArguments(bool usePtConfig, bool displayOn, uint timeLimit, int pid, string expireAt, bool useParentPid, bool enableHttpServer, int httpPort, bool activityMode, uint actCpu, uint actMem, uint actNet, uint actSample, uint actTimeout)
         {
             if (pid == 0 && !useParentPid)
             {
@@ -235,6 +359,35 @@ namespace Awake
             Logger.LogInfo($"The value for --pid is: {pid}");
             Logger.LogInfo($"The value for --expire-at is: {expireAt}");
             Logger.LogInfo($"The value for --use-parent-pid is: {useParentPid}");
+            Logger.LogInfo($"The value for --http-server is: {enableHttpServer}");
+            Logger.LogInfo($"The value for --http-port is: {httpPort}");
+            Logger.LogInfo($"The value for --activity is: {activityMode}");
+            if (activityMode)
+            {
+                Logger.LogInfo($"Activity thresholds CPU={actCpu}% MEM={actMem}% NET={actNet}KB/s SAMPLE={actSample}s TIMEOUT={actTimeout}s");
+            }
+
+            // Initialize HTTP server if requested
+            if (enableHttpServer)
+            {
+                try
+                {
+                    string prefix = $"http://localhost:{httpPort}/";
+                    _httpServer = new ManagedCommon.HttpServer(prefix);
+
+                    // Register Awake-specific handler
+                    _awakeHttpHandler = new AwakeHttpHandler();
+                    _httpServer.RegisterHandler(_awakeHttpHandler);
+
+                    _httpServer.Start();
+                    Logger.LogInfo($"HTTP server started on {prefix}");
+                    Logger.LogInfo($"Available endpoints: GET {prefix}status, GET {prefix}awake/...");
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError($"Failed to start HTTP server: {ex.Message}");
+                }
+            }
 
             // Start the monitor thread that will be used to track the current state.
             Manager.StartMonitor();
@@ -285,6 +438,11 @@ namespace Awake
                     Logger.LogError($"There was a problem with the configuration file. Make sure it exists. {ex.Message}");
                 }
             }
+            else if (!usePtConfig && activityMode)
+            {
+                Logger.LogInfo("Starting activity-based keep-awake mode (CLI override).");
+                Manager.SetActivityBasedKeepAwake(actCpu, actMem, actNet, actSample, actTimeout, displayOn);
+            }
             else if (pid != 0 || useParentPid)
             {
                 // Second, we snap to process-based execution. Because this is something that
@@ -342,6 +500,33 @@ namespace Awake
                     }
                 }
             }
+
+            // Initialize usage tracking
+            InitializeUsageTracking();
+        }
+
+        private static void InitializeUsageTracking()
+        {
+            try
+            {
+                string settingsPath = _settingsUtils!.GetSettingsFilePath(Core.Constants.AppName);
+                string directory = Path.GetDirectoryName(settingsPath)!;
+                string usageFile = Path.Combine(directory, "usage.json");
+
+                AwakeSettings settings = _settingsUtils.GetSettings<AwakeSettings>(Core.Constants.AppName) ?? new AwakeSettings();
+
+                if (Manager.UsageTracker == null)
+                {
+                    Manager.UsageTracker = new ForegroundUsageTracker(usageFile, settings.Properties.UsageRetentionDays);
+                }
+
+                Manager.UsageTracker.Configure(settings.Properties.TrackUsageEnabled, settings.Properties.UsageRetentionDays);
+                Logger.LogInfo($"Usage tracking configured (enabled={settings.Properties.TrackUsageEnabled}, retentionDays={settings.Properties.UsageRetentionDays}).");
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning($"Failed to initialize usage tracking: {ex.Message}");
+            }
         }
 
         private static void AllocateLocalConsole()
@@ -361,6 +546,7 @@ namespace Awake
                 SetupFileSystemWatcher(settingsPath);
                 InitializeSettings();
                 ProcessSettings();
+                InitializeUsageTracking(); // after initial settings load
             }
             catch (Exception ex)
             {
@@ -406,6 +592,7 @@ namespace Awake
             {
                 Logger.LogInfo("Detected a settings file change. Updating configuration...");
                 ProcessSettings();
+                InitializeUsageTracking(); // re-evaluate usage tracking on config change
             }
             catch (Exception e)
             {
@@ -448,6 +635,22 @@ namespace Awake
 
                         Manager.SetExpirableKeepAwake(settings.Properties.ExpirationDateTime, settings.Properties.KeepDisplayOn);
                         break;
+                    case AwakeMode.ACTIVITY:
+                        Manager.SetActivityBasedKeepAwake(
+                            settings.Properties.ActivityCpuThresholdPercent,
+                            settings.Properties.ActivityMemoryThresholdPercent,
+                            settings.Properties.ActivityNetworkThresholdKBps,
+                            settings.Properties.ActivitySampleIntervalSeconds,
+                            settings.Properties.ActivityInactivityTimeoutSeconds,
+                            settings.Properties.KeepDisplayOn);
+                        break;
+
+                    case AwakeMode.PROCESS:
+                        Manager.SetProcessBasedKeepAwake(
+                            settings.Properties.ProcessMonitoringList,
+                            settings.Properties.ProcessCheckIntervalSeconds,
+                            settings.Properties.KeepDisplayOn);
+                        break;
 
                     default:
                         Logger.LogError("Unknown mode of operation. Check config file.");

src/modules/awake/Awake/Properties/Resources.Designer.cs

@@ -213,6 +213,15 @@ namespace Awake.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Keep awake on activity (CPU / Memory / Network).
+        /// </summary>
+        internal static string AWAKE_KEEP_ON_ACTIVITY {
+            get {
+                return ResourceManager.GetString("AWAKE_KEEP_ON_ACTIVITY", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to d.
         /// </summary>
@@ -339,6 +348,15 @@ namespace Awake.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Activity.
+        /// </summary>
+        internal static string AWAKE_TRAY_TEXT_ACTIVITY {
+            get {
+                return ResourceManager.GetString("AWAKE_TRAY_TEXT_ACTIVITY", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Unchecked.
         /// </summary>

src/modules/awake/Awake/Properties/Resources.resx

@@ -146,6 +146,10 @@
     <value>Keep awake until expiration date and time</value>
     <comment>Keep the system awake until expiration date and time</comment>
   </data>
+  <data name="AWAKE_KEEP_ON_ACTIVITY" xml:space="preserve">
+    <value>Keep awake on activity (CPU / Memory / Network)</value>
+    <comment>Keep the system awake while resource activity is above configured thresholds</comment>
+  </data>
   <data name="AWAKE_MINUTE" xml:space="preserve">
     <value>{0} minute</value>
     <comment>{0} shouldn't be removed. It will be replaced by the number 1 at runtime by the application. Used for defining a period to keep the PC awake.</comment>
@@ -197,6 +201,9 @@
   <data name="AWAKE_TRAY_TEXT_TIMED" xml:space="preserve">
     <value>Interval</value>
   </data>
+  <data name="AWAKE_TRAY_TEXT_ACTIVITY" xml:space="preserve">
+    <value>Activity</value>
+  </data>
   <data name="AWAKE_LABEL_DAYS" xml:space="preserve">
     <value>d</value>
     <comment>Used to display number of days in the system tray tooltip.</comment>

src/modules/awake/scripts/AwakeRotMini.ps1

@@ -0,0 +1,131 @@
+<#
+  AwakeRotMini.ps1  —  Minimal ROT client for the Awake COM automation object.
+
+  Supported actions:
+    ping            -> Calls Ping(), prints  PING=pong
+    status          -> Calls GetStatusJson(), prints JSON
+    cancel          -> Calls Cancel(), prints CANCEL_OK
+    timed:<m>       -> Calls SetTimed(<m * 60 seconds>), prints TIMED_OK  (minutes input)
+
+  Assumptions:
+    - Server registered object in ROT via CreateItemMoniker("!", logicalName)
+    - We only need late binding (IDispatch InvokeMember) – no type library.
+
+  Exit codes:
+    0 = success
+    2 = object not found in ROT
+    4 = call/parse error
+
+  NOTE: This script intentionally stays dependency‑light and fast to start.
+#>
+param(
+  [string]$MonikerName = 'Awake.Automation',
+  [string]$Action = 'ping'
+)
+
+# ---------------------------------------------------------------------------
+# Inline C# (single public class) – handles:
+#   * ROT lookup via CreateItemMoniker("!", logicalName)
+#   * Late bound InvokeMember calls
+#   * Lightweight action dispatch
+# ---------------------------------------------------------------------------
+if (-not ('AwakeRotMiniClient' -as [type])) {
+  $code = @'
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+
+public static class AwakeRotMiniClient
+{
+    // P/Invoke -------------------------------------------------------------
+    [DllImport("ole32.dll")] private static extern int GetRunningObjectTable(int reserved, out IRunningObjectTable rot);
+    [DllImport("ole32.dll")] private static extern int CreateBindCtx(int reserved, out IBindCtx ctx);
+    [DllImport("ole32.dll", CharSet = CharSet.Unicode)] private static extern int CreateItemMoniker(string delimiter, string item, out IMoniker mk);
+
+    // Internal helpers -----------------------------------------------------
+    private static void Open(out IRunningObjectTable rot, out IBindCtx ctx)
+    {
+        GetRunningObjectTable(0, out rot);
+        CreateBindCtx(0, out ctx);
+    }
+
+    private static object BindLogical(string logical)
+    {
+        Open(out var rot, out var ctx);
+        if (CreateItemMoniker("!", logical, out var mk) == 0)
+        {
+            try
+            {
+                rot.GetObject(mk, out var obj);
+                return obj;
+            }
+            catch
+            {
+                // Swallow – treated as not found below.
+            }
+        }
+        return null;
+    }
+
+    private static object Call(object obj, string name, params object[] args)
+    {
+        var t = obj.GetType(); // System.__ComObject
+        return t.InvokeMember(
+            name,
+            System.Reflection.BindingFlags.InvokeMethod |
+            System.Reflection.BindingFlags.Public |
+            System.Reflection.BindingFlags.Instance,
+            null,
+            obj,
+            (args == null || args.Length == 0) ? null : args);
+    }
+
+    // Public entry ---------------------------------------------------------
+    public static string Exec(string logical, string action)
+    {
+        var obj = BindLogical(logical);
+        if (obj == null)
+            return "__NOT_FOUND__";
+
+        if (string.IsNullOrEmpty(action) || action == "ping")
+        {
+            try { return "PING=" + Call(obj, "Ping"); } catch (Exception ex) { return Err(ex); }
+        }
+        try
+        {
+            if (action == "status")
+                return (string)Call(obj, "GetStatusJson");
+            if (action == "cancel")
+            {
+                Call(obj, "Cancel");
+                return "CANCEL_OK";
+            }
+            if (action.StartsWith("timed:", StringComparison.OrdinalIgnoreCase))
+            {
+                var slice = action.Substring(6);
+                if (!int.TryParse(slice, out var minutes) || minutes < 0)
+                    return "__ERR=Format:Invalid minutes";
+                Call(obj, "SetTimed", minutes * 60);
+                return "TIMED_OK";
+            }
+            return "UNKNOWN_ACTION";
+        }
+        catch (Exception ex)
+        {
+            return Err(ex);
+        }
+    }
+
+    private static string Err(Exception ex) => "__ERR=" + ex.GetType().Name + ":" + ex.Message;
+}
+'@
+  Add-Type -TypeDefinition $code -ErrorAction Stop | Out-Null
+}
+
+$result = [AwakeRotMiniClient]::Exec($MonikerName, $Action)
+
+switch ($result) {
+  '__NOT_FOUND__' { exit 2 }
+  { $_ -like '__ERR=*' } { $host.UI.WriteErrorLine($result); exit 4 }
+  default { Write-Output $result; exit 0 }
+}

src/modules/awake/scripts/AwakeRotTest.ps1

@@ -0,0 +1,187 @@
+<#
+Minimal ROT test script for the runtime‑registered Awake automation object.
+
+Usage:
+  .\AwakeRotTest.ps1 [-MonikerName Awake.Automation] -Action <action>
+
+Actions:
+    ping            -> PING=pong
+    status          -> Returns JSON from GetStatusJson (placeholder now)
+    cancel          -> Calls Cancel
+    timed:<m>       -> Calls SetTimed(int minutes)
+    pingdbg         -> Diagnostic: shows type info and invocation paths
+
+Exit codes:
+  0 = success
+  2 = moniker not found
+  3 = (reserved for bind failure – not currently used)
+  4 = method invocation failure
+
+Notes:
+  - The automation object is registered with display name pattern: !<MonikerName>
+  - We late-bind via IDispatch InvokeMember because the object is surfaced as System.__ComObject.
+  - Keep this script self‑contained; avoid multiple Add-Type blocks to prevent type cache issues.
+#>
+param(
+  [string]$MonikerName = 'Awake.Automation',
+  [string]$Action
+)
+
+# ----------------------------
+# Constants (exit codes)
+# ----------------------------
+Set-Variable -Name EXIT_OK -Value 0 -Option Constant
+Set-Variable -Name EXIT_NOT_FOUND -Value 2 -Option Constant
+Set-Variable -Name EXIT_CALL_FAIL -Value 4 -Option Constant
+
+Write-Host '[AwakeRotTest] Start' -ForegroundColor Cyan
+
+# ----------------------------
+# C# helper (enumerate + bind + invoke)
+# ----------------------------
+if (-not ('AwakeRot.Client' -as [type])) {
+  $code = @'
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Collections.Generic;
+using System.Text;
+
+public static class AwakeRotClient
+{
+    [DllImport("ole32.dll")] private static extern int GetRunningObjectTable(int reserved, out IRunningObjectTable rot);
+    [DllImport("ole32.dll")] private static extern int CreateBindCtx(int reserved, out IBindCtx ctx);
+
+    private static (IRunningObjectTable rot, IBindCtx ctx) Open()
+    {
+        GetRunningObjectTable(0, out var rot);
+        CreateBindCtx(0, out var ctx);
+        return (rot, ctx);
+    }
+
+    // (Enumeration removed for simplification – list action no longer supported.)
+
+    // Direct bind using CreateItemMoniker fast-path (avoids full enumeration).
+    [DllImport("ole32.dll", CharSet = CharSet.Unicode)] private static extern int CreateItemMoniker(string lpszDelim, string lpszItem, out IMoniker ppmk);
+
+    private static object Bind(string display)
+    {
+        var (rot, ctx) = Open();
+        if (display.Length > 1 && display[0] == '!')
+        {
+            string logical = display.Substring(1);
+            if (CreateItemMoniker("!", logical, out var mk) == 0 && mk != null)
+            {
+                try
+                {
+                    rot.GetObject(mk, out var directObj);
+                    return directObj; // may be null if not found
+                }
+                catch { return null; }
+            }
+        }
+        return null; // No fallback enumeration (intentionally removed for simplicity/perf determinism)
+    }
+
+    // Strong-typed interface (early binding) – mirrors server's IAwakeAutomation definition.
+    // GUIDs copied from IAwakeAutomation / AwakeAutomation server code.
+    [ComImport]
+    [Guid("5CA92C1D-9D7E-4F6D-9B06-5B7B28BF4E21")] // interface GUID
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IAwakeAutomation
+    {
+        [PreserveSig] string Ping();
+        void SetIndefinite();
+        void SetTimed(int seconds);
+        void SetExpirable(int minutes);
+        void SetPassive();
+        void Cancel();
+        [PreserveSig] string GetStatusJson();
+    }
+
+    // Fallback late-binding helper (kept for diagnostic / if cast fails)
+    private static object CallLate(object obj, string name, params object[] args)
+    {
+        var t = obj.GetType();
+        return t.InvokeMember(
+            name,
+            System.Reflection.BindingFlags.InvokeMethod |
+            System.Reflection.BindingFlags.Public |
+            System.Reflection.BindingFlags.Instance,
+            binder: null,
+            target: obj,
+            args: (args == null || args.Length == 0) ? null : args);
+    }
+
+    public static string Exec(string logical, string action)
+    {
+        string display = "!" + logical;
+        var obj = Bind(display);
+        if (obj == null)
+            return "__NOT_FOUND__";
+
+        var t = obj.GetType();
+        try
+        {
+            // Try strong-typed cast first.
+            IAwakeAutomation api = obj as IAwakeAutomation;
+            bool typed = api != null;
+
+            if (action == "pingdbg")
+            {
+                var sb = new StringBuilder();
+                sb.AppendLine("TYPE=" + t.FullName);
+                sb.AppendLine("StrongTypedCast=" + typed);
+                if (typed)
+                {
+                    try { sb.AppendLine("TypedPing=" + api.Ping()); } catch (Exception ex) { sb.AppendLine("TypedPingErr=" + ex.Message); }
+                }
+                else
+                {
+                    try { sb.AppendLine("LatePing=" + CallLate(obj, "Ping")); } catch (Exception ex) { sb.AppendLine("LatePingErr=" + ex.Message); }
+                }
+                return sb.ToString();
+            }
+
+            if (string.IsNullOrEmpty(action) || action == "demo")
+            {
+                var ping = typed ? api.Ping() : (string)CallLate(obj, "Ping");
+                return $"DEMO Ping={ping}";
+            }
+            if (action == "ping") return "PING=" + (typed ? api.Ping() : (string)CallLate(obj, "Ping"));
+            if (action == "status") return typed ? api.GetStatusJson() : (string)CallLate(obj, "GetStatusJson");
+            if (action == "cancel") { if (typed) api.Cancel(); else CallLate(obj, "Cancel"); return "CANCEL_OK"; }
+            if (action != null && action.StartsWith("timed:"))
+            {
+                var m = int.Parse(action.Substring(6));
+                // NOTE: Server SetTimed expects seconds (per interface). Action timed:<m> originally treated value as minutes -> semantic mismatch.
+                // For now keep behavior (treat number as minutes -> convert to seconds for strong typed call) to avoid breaking existing usage.
+                if (typed) api.SetTimed(m * 60); else CallLate(obj, "SetTimed", m * 60);
+                return "TIMED_OK";
+            }
+            return "UNKNOWN_ACTION";
+        }
+        catch (Exception ex)
+        {
+            return "__CALL_ERROR__" + ex.GetType().Name + ":" + ex.Message;
+        }
+    }
+}
+'@
+
+  Add-Type -TypeDefinition $code -ErrorAction Stop | Out-Null
+}
+
+# Quick list fast-path
+if ($Action -eq 'list') {
+  [AwakeRotClient]::List() | ForEach-Object { $_ }
+  exit $EXIT_OK
+}
+
+$result = [AwakeRotClient]::Exec($MonikerName, $Action)
+
+switch ($result) {
+  '__NOT_FOUND__' { Write-Host "Moniker !$MonikerName not found." -ForegroundColor Red; [Environment]::Exit($EXIT_NOT_FOUND) }
+  { $_ -like '__CALL_ERROR__*' } { Write-Host "Call failed: $result" -ForegroundColor Red; [Environment]::Exit($EXIT_CALL_FAIL) }
+  default { Write-Host $result -ForegroundColor Green; [Environment]::Exit($EXIT_OK) }
+}

src/modules/cmdpal/.editorconfig

@@ -2,44 +2,28 @@
 # You can modify the rules from these initially generated values to suit your own policies.
 # You can learn more about editorconfig here: https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference.
 
-##################################################
-# Global settings
-##################################################
-
-[*.{cs,vb}]
-tab_width = 4
-indent_size = 4
-end_of_line = crlf
-indent_style = space
-insert_final_newline = true
-file_header_template = Copyright (c) Microsoft Corporation\nThe Microsoft Corporation licenses this file to you under the MIT license.\nSee the LICENSE file in the project root for more information.
-
-##################################################
-# C# specific formatting
-##################################################
-
 [*.cs]
-# ----------------------------------------------
-# Core editorconfig formatting - indentation
-# ----------------------------------------------
+
+file_header_template = Copyright (c) Microsoft Corporation\r\nThe Microsoft Corporation licenses this file to you under the MIT license.\r\nSee the LICENSE file in the project root for more information.
+
+#Core editorconfig formatting - indentation
+
+#use soft tabs (spaces) for indentation
+indent_style = space
+
+#Formatting - new line options
 
 #place else statements on a new line
 csharp_new_line_before_else = true
 #require braces to be on a new line for lambdas, methods, control_blocks, types, properties, and accessors (also known as "Allman" style)
 csharp_new_line_before_open_brace = all
 
-# ----------------------------------------------
-# Formatting - organize using options
-# ----------------------------------------------
+#Formatting - organize using options
 
-# sort System.* using directives alphabetically, and place them before other usings
+#sort System.* using directives alphabetically, and place them before other usings
 dotnet_sort_system_directives_first = true
-# Do not place System.* using directives before other using directives.
-dotnet_separate_import_directive_groups = false
 
-# ----------------------------------------------
-# Formatting - spacing options
-# ----------------------------------------------
+#Formatting - spacing options
 
 #require NO space between a cast and the value
 csharp_space_after_cast = false
@@ -60,29 +44,17 @@ csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
 #place a space character after the opening parenthesis and before the closing parenthesis of a method declaration parameter list.
 csharp_space_between_method_declaration_parameter_list_parentheses = false
 
-# ----------------------------------------------
-# Formatting - wrapping options
-# ----------------------------------------------
+#Formatting - wrapping options
 
 #leave code block on separate lines
 csharp_preserve_single_line_blocks = true
-#put each statement on a separate line
-csharp_preserve_single_line_statements = false
 
-##################################################
-# C# style rules
-##################################################
-
-# ----------------------------------------------
-# Style - Code block preferences
-# ----------------------------------------------
+#Style - Code block preferences
 
 #prefer curly braces even for one line of code
 csharp_prefer_braces = true:suggestion
 
-# ----------------------------------------------
-# Style - expression bodied member options
-# ----------------------------------------------
+#Style - expression bodied member options
 
 #prefer expression bodies for accessors
 csharp_style_expression_bodied_accessors = true:warning
@@ -93,73 +65,55 @@ csharp_style_expression_bodied_methods = when_on_single_line:silent
 #prefer expression-bodied members for properties
 csharp_style_expression_bodied_properties = true:warning
 
-# ----------------------------------------------
-# Style - expression level options
-# ----------------------------------------------
+#Style - expression level options
 
 #prefer out variables to be declared before the method call
 csharp_style_inlined_variable_declaration = false:suggestion
 #prefer the language keyword for member access expressions, instead of the type name, for types that have a keyword to represent them
 dotnet_style_predefined_type_for_member_access = true:suggestion
 
-# ----------------------------------------------
-# Style - Expression-level  preferences
-# ----------------------------------------------
+#Style - Expression-level  preferences
 
 #prefer default over default(T)
 csharp_prefer_simple_default_expression = true:suggestion
 #prefer objects to be initialized using object initializers when possible
 dotnet_style_object_initializer = true:suggestion
 
-# ----------------------------------------------
-# Style - implicit and explicit types
-# ----------------------------------------------
+#Style - implicit and explicit types
 
 #prefer var over explicit type in all cases, unless overridden by another code style rule
 csharp_style_var_elsewhere = true:suggestion
 #prefer var is used to declare variables with built-in system types such as int
-csharp_style_var_for_built_in_types = true:warning
+csharp_style_var_for_built_in_types = true:suggestion
 #prefer var when the type is already mentioned on the right-hand side of a declaration expression
 csharp_style_var_when_type_is_apparent = true:suggestion
 
-# ----------------------------------------------
-# Style - language keyword and framework type options
-# ----------------------------------------------
+#Style - language keyword and framework type options
 
 #prefer the language keyword for local variables, method parameters, and class members, instead of the type name, for types that have a keyword to represent them
 dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
 
-# ----------------------------------------------
-# Style - Language rules
-# ----------------------------------------------
-
+#Style - Language rules
 csharp_style_implicit_object_creation_when_type_is_apparent = true:warning
+csharp_style_var_for_built_in_types = true:warning
 
-# ----------------------------------------------
-# Style - modifier options
-# ----------------------------------------------
+#Style - modifier options
 
 #prefer accessibility modifiers to be declared except for public interface members. This will currently not differ from always and will act as future proofing for if C# adds default interface methods.
 dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
 
-# ----------------------------------------------
-# Style - Modifier preferences
-# ----------------------------------------------
+#Style - Modifier preferences
 
 #when this rule is set to a list of modifiers, prefer the specified ordering.
 csharp_preferred_modifier_order = public,private,protected,internal,static,async,readonly,override,sealed,abstract,virtual:warning
 dotnet_style_readonly_field = true:warning
 
-# ----------------------------------------------
-# Style - Pattern matching
-# ----------------------------------------------
+#Style - Pattern matching
 
 #prefer pattern matching instead of is expression with type casts
 csharp_style_pattern_matching_over_as_with_null_check = true:warning
 
-# ----------------------------------------------
-# Style - qualification options
-# ----------------------------------------------
+#Style - qualification options
 
 #prefer events not to be prefaced with this. or Me. in Visual Basic
 dotnet_style_qualification_for_event = false:suggestion
@@ -169,26 +123,20 @@ dotnet_style_qualification_for_field = false:suggestion
 dotnet_style_qualification_for_method = false:suggestion
 #prefer properties not to be prefaced with this. or Me. in Visual Basic
 dotnet_style_qualification_for_property = false:suggestion
-
-# ----------------------------------------------
-# Style - expression bodies
-# ----------------------------------------------
+csharp_indent_labels = one_less_than_current
+csharp_using_directive_placement = outside_namespace:silent
+csharp_prefer_simple_using_statement = true:warning
+csharp_style_namespace_declarations = file_scoped:warning
 csharp_style_expression_bodied_operators = false:silent
 csharp_style_expression_bodied_indexers = true:silent
 csharp_style_expression_bodied_lambdas = true:silent
 csharp_style_expression_bodied_local_functions = false:silent
 
-# ----------------------------------------------
-# Style - Miscellaneous preferences
-# ----------------------------------------------
-
-csharp_indent_labels = one_less_than_current
-csharp_using_directive_placement = outside_namespace:silent
-csharp_prefer_simple_using_statement = true:warning
-csharp_style_namespace_declarations = file_scoped:warning
-
 [*.{cs,vb}]
 dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+indent_size = 4
+end_of_line = crlf
 dotnet_style_coalesce_expression = true:suggestion
 dotnet_style_null_propagation = true:suggestion
 dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
@@ -198,13 +146,12 @@ dotnet_style_collection_initializer = true:suggestion
 dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
 dotnet_style_prefer_conditional_expression_over_assignment = true:silent
 dotnet_style_prefer_conditional_expression_over_return = true:silent
+[*.{cs,vb}]
+
+#Style - Unnecessary code rules
 csharp_style_unused_value_assignment_preference = discard_variable:warning
 
-##################################################
-# Naming rules
-##################################################
-
-[*.{cs,vb}]
+#### Naming styles ####
 
 # Naming rules
 
@@ -256,11 +203,7 @@ dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
 dotnet_style_prefer_compound_assignment = true:warning
 dotnet_style_prefer_simplified_interpolation = true:suggestion
 
+# Diagnostic configuration
 
-##################################################
-# Diagnostics
-##################################################
-
-[*.{cs,vb}]
 # CS8305: Type is for evaluation purposes only and is subject to change or removal in future updates.
 dotnet_diagnostic.CS8305.severity = suggestion

src/modules/cmdpal/ExtensionTemplate/TemplateCmdPalExtension/Directory.Packages.props

@@ -9,7 +9,7 @@
     <PackageVersion Include="Microsoft.Windows.CsWin32" Version="0.3.183" />
     <PackageVersion Include="Microsoft.Windows.CsWinRT" Version="2.2.0" />
     <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.4188" />
-    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.8.250907003" />
+    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.7.250513003" />
     <PackageVersion Include="Shmuelie.WinRTServer" Version="2.1.1" />
     <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
     <PackageVersion Include="System.Text.Json" Version="9.0.8" />

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/ContextMenuViewModel.cs

@@ -5,7 +5,6 @@
 using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Messaging;
-using ManagedCommon;
 using Microsoft.CmdPal.Core.ViewModels.Messages;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
@@ -118,46 +117,36 @@ public partial class ContextMenuViewModel : ObservableObject,
     /// Generates a mapping of key -> command item for this particular item's
     /// MoreCommands. (This won't include the primary Command, but it will
     /// include the secondary one). This map can be used to quickly check if a
-    /// shortcut key was pressed. In case there are duplicate keybindings, the first
-    /// one is used and the rest are ignored.
+    /// shortcut key was pressed
     /// </summary>
     /// <returns>a dictionary of KeyChord -> Context commands, for all commands
     /// that have a shortcut key set.</returns>
-    private Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
+    public Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
     {
-        var result = new Dictionary<KeyChord, CommandContextItemViewModel>();
-
-        var menu = CurrentContextMenu;
-        if (menu is null)
+        if (CurrentContextMenu is null)
         {
-            return result;
+            return [];
         }
 
-        foreach (var item in menu)
-        {
-            if (item is CommandContextItemViewModel cmd && cmd.HasRequestedShortcut)
-            {
-                var key = cmd.RequestedShortcut ?? new KeyChord(0, 0, 0);
-                var added = result.TryAdd(key, cmd);
-                if (!added)
-                {
-                    Logger.LogWarning($"Ignoring duplicate keyboard shortcut {KeyChordHelpers.FormatForDebug(key)} on command '{cmd.Title ?? cmd.Name ?? "(unknown)"}'");
-                }
-            }
-        }
-
-        return result;
+        return CurrentContextMenu
+            .OfType<CommandContextItemViewModel>()
+            .Where(c => c.HasRequestedShortcut)
+            .ToDictionary(
+            c => c.RequestedShortcut ?? new KeyChord(0, 0, 0),
+            c => c);
     }
 
     public ContextKeybindingResult? CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
     {
         var keybindings = Keybindings();
-
-        // Does the pressed key match any of the keybindings?
-        var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
-        if (keybindings.TryGetValue(pressedKeyChord, out var item))
+        if (keybindings is not null)
         {
-            return InvokeCommand(item);
+            // Does the pressed key match any of the keybindings?
+            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
+            if (keybindings.TryGetValue(pressedKeyChord, out var item))
+            {
+                return InvokeCommand(item);
+            }
         }
 
         return null;

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/ExtensionObjectViewModel.cs

@@ -51,36 +51,6 @@ public abstract partial class ExtensionObjectViewModel : ObservableObject
         DoOnUiThread(() => OnPropertyChanged(propertyName));
     }
 
-    protected void UpdateProperty(string propertyName1, string propertyName2)
-    {
-        DoOnUiThread(() =>
-        {
-            OnPropertyChanged(propertyName1);
-            OnPropertyChanged(propertyName2);
-        });
-    }
-
-    protected void UpdateProperty(string propertyName1, string propertyName2, string propertyName3)
-    {
-        DoOnUiThread(() =>
-        {
-            OnPropertyChanged(propertyName1);
-            OnPropertyChanged(propertyName2);
-            OnPropertyChanged(propertyName3);
-        });
-    }
-
-    protected void UpdateProperty(params string[] propertyNames)
-    {
-        DoOnUiThread(() =>
-        {
-            foreach (var propertyName in propertyNames)
-            {
-                OnPropertyChanged(propertyName);
-            }
-        });
-    }
-
     protected void ShowException(Exception ex, string? extensionHint = null)
     {
         if (PageContext.TryGetTarget(out var pageContext))

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/FiltersViewModel.cs

@@ -2,6 +2,7 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using CommunityToolkit.Mvvm.ComponentModel;
 using Microsoft.CmdPal.Core.ViewModels.Models;
 using Microsoft.CommandPalette.Extensions;
 
@@ -9,11 +10,14 @@ namespace Microsoft.CmdPal.Core.ViewModels;
 
 public partial class FiltersViewModel : ExtensionObjectViewModel
 {
-    private readonly ExtensionObject<IFilters> _filtersModel;
+    private readonly ExtensionObject<IFilters> _filtersModel = new(null);
 
-    public string CurrentFilterId { get; private set; } = string.Empty;
+    [ObservableProperty]
+    public partial string CurrentFilterId { get; set; } = string.Empty;
 
-    public IFilterItemViewModel[] Filters { get; private set; } = [];
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShouldShowFilters))]
+    public partial IFilterItemViewModel[] Filters { get; set; } = [];
 
     public bool ShouldShowFilters => Filters.Length > 0;
 
@@ -30,11 +34,23 @@ public partial class FiltersViewModel : ExtensionObjectViewModel
             if (_filtersModel.Unsafe is not null)
             {
                 var filters = _filtersModel.Unsafe.GetFilters();
-                Filters = BuildFilters(filters ?? []);
-                UpdateProperty(nameof(Filters), nameof(ShouldShowFilters));
+                Filters = filters.Select<IFilterItem, IFilterItemViewModel>(filter =>
+                {
+                    var filterItem = filter as IFilter;
+                    if (filterItem != null)
+                    {
+                        var filterVM = new FilterItemViewModel(filterItem!, PageContext);
+                        filterVM.InitializeProperties();
 
-                CurrentFilterId = _filtersModel.Unsafe.CurrentFilterId ?? string.Empty;
-                UpdateProperty(nameof(CurrentFilterId));
+                        return filterVM;
+                    }
+                    else
+                    {
+                        return new SeparatorViewModel();
+                    }
+                }).ToArray();
+
+                CurrentFilterId = _filtersModel.Unsafe.CurrentFilterId;
 
                 return;
             }
@@ -45,27 +61,7 @@ public partial class FiltersViewModel : ExtensionObjectViewModel
         }
 
         Filters = [];
-        UpdateProperty(nameof(Filters), nameof(ShouldShowFilters));
-
         CurrentFilterId = string.Empty;
-        UpdateProperty(nameof(CurrentFilterId));
-    }
-
-    private IFilterItemViewModel[] BuildFilters(IFilterItem[] filters)
-    {
-        return [..filters.Select<IFilterItem, IFilterItemViewModel>(filter =>
-        {
-            if (filter is IFilter filterItem)
-            {
-                var filterItemViewModel = new FilterItemViewModel(filterItem!, PageContext);
-                filterItemViewModel.InitializeProperties();
-                return filterItemViewModel;
-            }
-            else
-            {
-                return new SeparatorViewModel();
-            }
-        })];
     }
 
     public override void SafeCleanup()
@@ -74,9 +70,9 @@ public partial class FiltersViewModel : ExtensionObjectViewModel
 
         foreach (var filter in Filters)
         {
-            if (filter is FilterItemViewModel filterItemViewModel)
+            if (filter is FilterItemViewModel filterVM)
             {
-                filterItemViewModel.SafeCleanup();
+                filterVM.SafeCleanup();
             }
         }
 

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/Messages/UpdateCommandBarMessage.cs

@@ -3,9 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.ComponentModel;
-using ManagedCommon;
 using Microsoft.CommandPalette.Extensions;
-using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Core.ViewModels.Messages;
 
@@ -34,28 +32,12 @@ public interface IContextMenuContext : INotifyPropertyChanged
     /// that have a shortcut key set.</returns>
     public Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
     {
-        var result = new Dictionary<KeyChord, CommandContextItemViewModel>();
-
-        var menu = MoreCommands;
-        if (menu is null)
-        {
-            return result;
-        }
-
-        foreach (var item in menu)
-        {
-            if (item is CommandContextItemViewModel cmd && cmd.HasRequestedShortcut)
-            {
-                var key = cmd.RequestedShortcut ?? new KeyChord(0, 0, 0);
-                var added = result.TryAdd(key, cmd);
-                if (!added)
-                {
-                    Logger.LogWarning($"Ignoring duplicate keyboard shortcut {KeyChordHelpers.FormatForDebug(key)} on command '{cmd.Title ?? cmd.Name ?? "(unknown)"}'");
-                }
-            }
-        }
-
-        return result;
+        return MoreCommands
+            .OfType<CommandContextItemViewModel>()
+            .Where(c => c.HasRequestedShortcut)
+            .ToDictionary(
+            c => c.RequestedShortcut ?? new KeyChord(0, 0, 0),
+            c => c);
     }
 }
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Microsoft.CmdPal.UI.ViewModels.csproj

@@ -94,4 +94,16 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
   </ItemGroup>
+
+  <!-- Just mark it as AOT compatible. Do not publish with AOT now. We need fully test before we really publish it as AOT enabled-->
+  <!--<PropertyGroup>
+    <SelfContained>true</SelfContained>
+    <WindowsAppSDKSelfContained>true</WindowsAppSDKSelfContained>
+    <PublishTrimmed>true</PublishTrimmed>
+    <PublishSingleFile>true</PublishSingleFile>
+    --><!-- <DisableRuntimeMarshalling>true</DisableRuntimeMarshalling> --><!--
+    <PublishAot>true</PublishAot>
+	<EnableMsixTooling>true</EnableMsixTooling>
+  </PropertyGroup>-->
+
 </Project>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/FiltersDropDown.xaml

@@ -59,7 +59,7 @@
                 <Rectangle
                     Height="1"
                     Margin="-16,-12,-12,-12"
-                    Fill="{ThemeResource MenuFlyoutSeparatorBackground}" />
+                    Fill="{ThemeResource MenuFlyoutSeparatorThemeBrush}" />
             </DataTemplate>
 
         </ResourceDictionary>
@@ -68,14 +68,11 @@
     <ComboBox
         Name="FiltersComboBox"
         x:Uid="FiltersComboBox"
-        MinWidth="200"
         VerticalAlignment="Center"
         ItemTemplateSelector="{StaticResource FilterTemplateSelector}"
         ItemsSource="{x:Bind ViewModel.Filters, Mode=OneWay}"
         PlaceholderText="Filters"
         PreviewKeyDown="FiltersComboBox_PreviewKeyDown"
-        SelectedValue="{x:Bind ViewModel.CurrentFilterId, Mode=OneWay}"
-        SelectedValuePath="Id"
         SelectionChanged="FiltersComboBox_SelectionChanged"
         Style="{StaticResource ComboBoxStyle}"
         Visibility="{x:Bind ViewModel.ShouldShowFilters, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}">

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/IconMarginConverter.cs

@@ -1,20 +0,0 @@
-// 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.UI.Xaml;
-using Microsoft.UI.Xaml.Data;
-
-namespace Microsoft.CmdPal.UI.Controls;
-
-public sealed partial class IconMarginConverter : IValueConverter
-{
-    public object Convert(object value, Type targetType, object parameter, string language)
-    {
-        // Only include a margin if there is text to separate from the icon.
-        var text = value as string;
-        return string.IsNullOrEmpty(text) ? new Thickness(0) : new Thickness(0, 0, 4, 0);
-    }
-
-    public object ConvertBack(object value, Type targetType, object parameter, string language) => throw new NotImplementedException();
-}

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

@@ -131,11 +131,6 @@ public sealed partial class SearchBar : UserControl,
             WeakReferenceMessenger.Default.Send<OpenContextMenuMessage>(new OpenContextMenuMessage(null, null, null, ContextMenuFilterLocation.Bottom));
             e.Handled = true;
         }
-        else if (ctrlPressed && e.Key == VirtualKey.I)
-        {
-            // Today you learned that Ctrl+I in a TextBox will insert a tab
-            e.Handled = true;
-        }
         else if (e.Key == VirtualKey.Escape)
         {
             if (string.IsNullOrEmpty(FilterBox.Text))

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/Tag.xaml

@@ -27,8 +27,6 @@
     <Thickness x:Key="TagPadding">4,2,4,2</Thickness>
     <Thickness x:Key="TagBorderThickness">1</Thickness>
 
-    <local:IconMarginConverter x:Key="IconMarginConverter" />
-
     <Style BasedOn="{StaticResource DefaultTagStyle}" TargetType="local:Tag" />
 
     <Style x:Key="DefaultTagStyle" TargetType="local:Tag">
@@ -73,7 +71,7 @@
                                 x:Name="PART_Icon"
                                 Grid.Column="0"
                                 Height="12"
-                                Margin="{Binding Text, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource IconMarginConverter}}"
+                                Margin="0,0,4,0"
                                 SourceKey="{TemplateBinding Icon}" />
                             <TextBlock
                                 Grid.Column="1"

src/modules/cmdpal/Microsoft.CmdPal.UI/Converters/FilterTemplateSelector.cs

@@ -2,7 +2,6 @@
 // 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.CodeAnalysis;
 using Microsoft.CmdPal.Core.ViewModels;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
@@ -15,7 +14,6 @@ internal sealed partial class FilterTemplateSelector : DataTemplateSelector
 
     public DataTemplate? Separator { get; set; }
 
-    [DynamicDependency(DynamicallyAccessedMemberTypes.All, "Microsoft.UI.Xaml.Controls.ComboBoxItem", "Microsoft.WinUI")]
     protected override DataTemplate? SelectTemplateCore(object item, DependencyObject dependencyObject)
     {
         DataTemplate? dataTemplate = Default;

src/modules/cmdpal/Microsoft.CmdPal.UI/Microsoft.CmdPal.UI.csproj

@@ -39,8 +39,6 @@
 
   <PropertyGroup Condition="'$(CIBuild)'=='true'">
     <GenerateAppxPackageOnBuild>true</GenerateAppxPackageOnBuild>
-    <AppxBundle>Never</AppxBundle>
-    <AppxPackageTestDir>$(OutputPath)\AppPackages\Microsoft.CmdPal.UI_$(Version)_Test\</AppxPackageTestDir>
   </PropertyGroup>
 
   <PropertyGroup>

src/modules/cmdpal/Microsoft.CmdPal.UI/Pages/ShellPage.xaml

@@ -327,6 +327,11 @@
                         x:Name="FiltersDropDown"
                         HorizontalAlignment="Right"
                         CurrentPageViewModel="{x:Bind ViewModel.CurrentPage, Mode=OneWay}" />
+                    <Grid.Transitions>
+                        <TransitionCollection>
+                            <RepositionThemeTransition />
+                        </TransitionCollection>
+                    </Grid.Transitions>
                 </Grid>
             </Grid>
 

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

@@ -3,15 +3,9 @@
   <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" />
   <PropertyGroup>
     <PathToRoot>..\..\..\..\</PathToRoot>
-    <WasdkNuget>$(PathToRoot)packages\Microsoft.WindowsAppSDK.1.8.250907003</WasdkNuget>
+    <WasdkNuget>$(PathToRoot)packages\Microsoft.WindowsAppSDK.1.7.250513003</WasdkNuget>
   </PropertyGroup>
   <Import Project="$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.props" Condition="Exists('$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props')" />
-  <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" />
   <PropertyGroup Label="Globals">
     <CppWinRTOptimized>true</CppWinRTOptimized>
     <CppWinRTRootNamespaceAutoMerge>true</CppWinRTRootNamespaceAutoMerge>
@@ -206,12 +200,6 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
     <Import Project="$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.targets" Condition="Exists('$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets" Condition="Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets" Condition="Exists('$(MSBuildThisFileDirectory)..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets')" />
@@ -222,18 +210,6 @@
     </PropertyGroup>
     <Error Condition="!Exists('$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.props')" Text="$([System.String]::Format('$(ErrorText)', '$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.props'))" />
     <Error Condition="!Exists('$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(WasdkNuget)\build\native\Microsoft.WindowsAppSDK.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Base.1.8.250831001\build\native\Microsoft.WindowsAppSDK.Base.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Foundation.1.8.250906002\build\native\Microsoft.WindowsAppSDK.Foundation.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.WinUI.1.8.250906003\build\native\Microsoft.WindowsAppSDK.WinUI.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.Runtime.1.8.250907003\build\native\Microsoft.WindowsAppSDK.Runtime.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.DWrite.1.8.25090401\build\Microsoft.WindowsAppSDK.DWrite.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.WindowsAppSDK.InteractiveExperiences.1.8.250906004\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets')" Text="$([System.String]::Format('$(ErrorText)', 'Microsoft.Windows.ImplementationLibrary.1.0.231216.1\build\native\Microsoft.Windows.ImplementationLibrary.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props'))" />

src/modules/cmdpal/Microsoft.Terminal.UI/packages.config

@@ -4,14 +4,4 @@
   <package id="Microsoft.Web.WebView2" version="1.0.2903.40" targetFramework="native" />
   <package id="Microsoft.Windows.CppWinRT" version="2.0.240111.5" targetFramework="native" />
   <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.231216.1" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK" version="1.8.250907003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Base" version="1.8.250831001" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Foundation" version="1.8.250906002" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.WinUI" version="1.8.250906003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Runtime" version="1.8.250907003" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.DWrite" version="1.8.25090401" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.InteractiveExperiences" version="1.8.250906004" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.Widgets" version="1.8.250904007" targetFramework="native" />
-  <package id="Microsoft.WindowsAppSDK.AI" version="1.8.37" targetFramework="native" />
-  <package id="Microsoft.Windows.SDK.BuildTools.MSIX" version="1.7.20250829.1" targetFramework="native" />
 </packages>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V16.5C16 17.3284 15.3284 18 14.5 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H14.5C14.7761 17 15 16.7761 15 16.5V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V16.5C16 17.3284 15.3284 18 14.5 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H14.5C14.7761 17 15 16.7761 15 16.5V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4Z" fill="#212121"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_image_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V9H15V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H9.03544C9.08595 17.3531 9.18915 17.6891 9.33682 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM10 12.5C10 11.1193 11.1193 10 12.5 10H16.5C17.8807 10 19 11.1193 19 12.5V16.5C19 17.0095 18.8476 17.4835 18.5858 17.8787L15.5607 14.8536C14.9749 14.2678 14.0251 14.2678 13.4393 14.8536L10.4142 17.8787C10.1524 17.4835 10 17.0095 10 16.5V12.5ZM17 12.75C17 12.3358 16.6642 12 16.25 12C15.8358 12 15.5 12.3358 15.5 12.75C15.5 13.1642 15.8358 13.5 16.25 13.5C16.6642 13.5 17 13.1642 17 12.75ZM11.1213 18.5858C11.5165 18.8476 11.9905 19 12.5 19H16.5C17.0095 19 17.4835 18.8476 17.8787 18.5858L14.8536 15.5607C14.6583 15.3654 14.3417 15.3654 14.1464 15.5607L11.1213 18.5858Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_image_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V9H15V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H9.03544C9.08595 17.3531 9.18915 17.6891 9.33682 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM10 12.5C10 11.1193 11.1193 10 12.5 10H16.5C17.8807 10 19 11.1193 19 12.5V16.5C19 17.0095 18.8476 17.4835 18.5858 17.8787L15.5607 14.8536C14.9749 14.2678 14.0251 14.2678 13.4393 14.8536L10.4142 17.8787C10.1524 17.4835 10 17.0095 10 16.5V12.5ZM17 12.75C17 12.3358 16.6642 12 16.25 12C15.8358 12 15.5 12.3358 15.5 12.75C15.5 13.1642 15.8358 13.5 16.25 13.5C16.6642 13.5 17 13.1642 17 12.75ZM11.1213 18.5858C11.5165 18.8476 11.9905 19 12.5 19H16.5C17.0095 19 17.4835 18.8476 17.8787 18.5858L14.8536 15.5607C14.6583 15.3654 14.3417 15.3654 14.1464 15.5607L11.1213 18.5858Z" fill="#212121"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_letter_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V10.337L15.3698 8.89819C15.2826 8.69904 15.1554 8.52562 15 8.38568V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H9.08561C8.9672 17.3338 8.97447 17.6857 9.08567 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM14.4538 9.2994C14.3741 9.11744 14.1942 8.99992 13.9956 9C13.797 9.00008 13.6172 9.11776 13.5376 9.29979L10.0417 17.2998C9.93114 17.5528 10.0466 17.8476 10.2997 17.9582C10.5527 18.0687 10.8475 17.9533 10.958 17.7002L12.138 15H15.859L17.0419 17.7006C17.1527 17.9535 17.4475 18.0688 17.7005 17.958C17.9534 17.8472 18.0687 17.5523 17.9579 17.2994L14.4538 9.2994ZM15.421 14H12.575L13.9963 10.7474L15.421 14Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_clipboard_letter_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.08535 3C7.29127 2.4174 7.84689 2 8.5 2H11.5C12.1531 2 12.7087 2.4174 12.9146 3H14.5C15.3284 3 16 3.67157 16 4.5V10.337L15.3698 8.89819C15.2826 8.69904 15.1554 8.52562 15 8.38568V4.5C15 4.22386 14.7761 4 14.5 4H12.9146C12.7087 4.5826 12.1531 5 11.5 5H8.5C7.84689 5 7.29127 4.5826 7.08535 4H5.5C5.22386 4 5 4.22386 5 4.5V16.5C5 16.7761 5.22386 17 5.5 17H9.08561C8.9672 17.3338 8.97447 17.6857 9.08567 18H5.5C4.67157 18 4 17.3284 4 16.5V4.5C4 3.67157 4.67157 3 5.5 3H7.08535ZM8.5 3C8.22386 3 8 3.22386 8 3.5C8 3.77614 8.22386 4 8.5 4H11.5C11.7761 4 12 3.77614 12 3.5C12 3.22386 11.7761 3 11.5 3H8.5ZM14.4538 9.2994C14.3741 9.11744 14.1942 8.99992 13.9956 9C13.797 9.00008 13.6172 9.11776 13.5376 9.29979L10.0417 17.2998C9.93114 17.5528 10.0466 17.8476 10.2997 17.9582C10.5527 18.0687 10.8475 17.9533 10.958 17.7002L12.138 15H15.859L17.0419 17.7006C17.1527 17.9535 17.4475 18.0688 17.7005 17.958C17.9534 17.8472 18.0687 17.5523 17.9579 17.2994L14.4538 9.2994ZM15.421 14H12.575L13.9963 10.7474L15.421 14Z" fill="#212121"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_copy_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8 2C6.89543 2 6 2.89543 6 4V14C6 15.1046 6.89543 16 8 16H14C15.1046 16 16 15.1046 16 14V4C16 2.89543 15.1046 2 14 2H8ZM7 4C7 3.44772 7.44772 3 8 3H14C14.5523 3 15 3.44772 15 4V14C15 14.5523 14.5523 15 14 15H8C7.44772 15 7 14.5523 7 14V4ZM4 6.00001C4 5.25973 4.4022 4.61339 5 4.26758V14.5C5 15.8807 6.11929 17 7.5 17H13.7324C13.3866 17.5978 12.7403 18 12 18H7.5C5.567 18 4 16.433 4 14.5V6.00001Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_copy_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8 2C6.89543 2 6 2.89543 6 4V14C6 15.1046 6.89543 16 8 16H14C15.1046 16 16 15.1046 16 14V4C16 2.89543 15.1046 2 14 2H8ZM7 4C7 3.44772 7.44772 3 8 3H14C14.5523 3 15 3.44772 15 4V14C15 14.5523 14.5523 15 14 15H8C7.44772 15 7 14.5523 7 14V4ZM4 6.00001C4 5.25973 4.4022 4.61339 5 4.26758V14.5C5 15.8807 6.11929 17 7.5 17H13.7324C13.3866 17.5978 12.7403 18 12 18H7.5C5.567 18 4 16.433 4 14.5V6.00001Z" fill="#212121"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_document_copy_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M6 4C6 2.89543 6.89543 2 8 2H11.5858C11.9836 2 12.3651 2.15804 12.6464 2.43934L16.5607 6.35355C16.842 6.63486 17 7.01639 17 7.41421V14C17 15.1046 16.1046 16 15 16H8C6.89543 16 6 15.1046 6 14V4ZM8 3C7.44772 3 7 3.44772 7 4V14C7 14.5523 7.44772 15 8 15H15C15.5523 15 16 14.5523 16 14V8H12.5C11.6716 8 11 7.32843 11 6.5V3H8ZM12 3.20711V6.5C12 6.77614 12.2239 7 12.5 7H15.7929L12 3.20711ZM4 5C4 4.44772 4.44772 4 5 4V14C5 15.6569 6.34315 17 8 17L15 17C15 17.5523 14.5523 18 14 18H7.93939C5.76373 18 4 16.2363 4 14.0606V5Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_document_copy_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M6 4C6 2.89543 6.89543 2 8 2H11.5858C11.9836 2 12.3651 2.15804 12.6464 2.43934L16.5607 6.35355C16.842 6.63486 17 7.01639 17 7.41421V14C17 15.1046 16.1046 16 15 16H8C6.89543 16 6 15.1046 6 14V4ZM8 3C7.44772 3 7 3.44772 7 4V14C7 14.5523 7.44772 15 8 15H15C15.5523 15 16 14.5523 16 14V8H12.5C11.6716 8 11 7.32843 11 6.5V3H8ZM12 3.20711V6.5C12 6.77614 12.2239 7 12.5 7H15.7929L12 3.20711ZM4 5C4 4.44772 4.44772 4 5 4V14C5 15.6569 6.34315 17 8 17L15 17C15 17.5523 14.5523 18 14 18H7.93939C5.76373 18 4 16.2363 4 14.0606V5Z" fill="#212121"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_image_copy_20_regular.dark.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8.49751 7.4966C9.04842 7.4966 9.49502 7.05 9.49502 6.4991C9.49502 5.94819 9.04842 5.50159 8.49751 5.50159C7.9466 5.50159 7.5 5.94819 7.5 6.4991C7.5 7.05 7.9466 7.4966 8.49751 7.4966ZM5 6C5 4.34315 6.34315 3 8 3H14C15.6569 3 17 4.34315 17 6V12C17 13.6569 15.6569 15 14 15H8C6.34315 15 5 13.6569 5 12V6ZM8 4C6.89543 4 6 4.89543 6 6V12C6 12.3709 6.10097 12.7182 6.27692 13.016L9.79085 9.50207C10.4586 8.83427 11.5414 8.83427 12.2092 9.50207L15.7231 13.016C15.899 12.7182 16 12.3709 16 12V6C16 4.89543 15.1046 4 14 4H8ZM15.016 13.7231L11.502 10.2092C11.2248 9.9319 10.7752 9.9319 10.498 10.2092L6.98403 13.7231C7.28178 13.899 7.6291 14 8 14H14C14.3709 14 14.7182 13.899 15.016 13.7231ZM12 17C12.8885 17 13.6868 16.6138 14.2361 16H7.5C5.68782 16 4.1973 14.6228 4.01807 12.8579C4.00612 12.7402 4 12.6208 4 12.5V5.76392C3.38625 6.31324 3 7.11152 3 8.00002V12.5C3 14.9853 5.01472 17 7.5 17H12Z" fill="#D0D0D0"/>
-</svg>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Assets/Icons/ic_fluent_image_copy_20_regular.light.svg

@@ -1,3 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8.49751 7.4966C9.04842 7.4966 9.49502 7.05 9.49502 6.4991C9.49502 5.94819 9.04842 5.50159 8.49751 5.50159C7.9466 5.50159 7.5 5.94819 7.5 6.4991C7.5 7.05 7.9466 7.4966 8.49751 7.4966ZM5 6C5 4.34315 6.34315 3 8 3H14C15.6569 3 17 4.34315 17 6V12C17 13.6569 15.6569 15 14 15H8C6.34315 15 5 13.6569 5 12V6ZM8 4C6.89543 4 6 4.89543 6 6V12C6 12.3709 6.10097 12.7182 6.27692 13.016L9.79085 9.50207C10.4586 8.83427 11.5414 8.83427 12.2092 9.50207L15.7231 13.016C15.899 12.7182 16 12.3709 16 12V6C16 4.89543 15.1046 4 14 4H8ZM15.016 13.7231L11.502 10.2092C11.2248 9.9319 10.7752 9.9319 10.498 10.2092L6.98403 13.7231C7.28178 13.899 7.6291 14 8 14H14C14.3709 14 14.7182 13.899 15.016 13.7231ZM12 17C12.8885 17 13.6868 16.6138 14.2361 16H7.5C5.68782 16 4.1973 14.6228 4.01807 12.8579C4.00612 12.7402 4 12.6208 4 12.5V5.76392C3.38625 6.31324 3 7.11152 3 8.00002V12.5C3 14.9853 5.01472 17 7.5 17H12Z" fill="#212121"/>
-</svg>

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

@@ -1,12 +0,0 @@
-// 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.ClipboardHistory.Helpers;
-
-internal enum PrimaryAction
-{
-    Default,
-    Paste,
-    Copy,
-}