Add Copilot prompt panel to TODO detail with tests

Implement Copilot Status/Plan/Implementation prompt buttons and output panel in the TODO detail page, with robust error handling and inline feedback. Prompt errors are shown without collapsing the detail panel. Add Bunit tests for prompt UI and error handling. Refactor VSIX packaging to SDK-style, update UI dispatcher abstractions for WPF/Avalonia/test, and modernize ViewModel and API adapters. Update docs, .gitignore, and bump NuGet versions.

Author: sharpninja

.gitignore

@@ -34,3 +34,5 @@ AGENTS-README-FIRST.yaml
 scripts/__pycache__/
 testResults.xml
 .vscode/mcp.json
+/logs/web-ui-startup
+/TestResults/run-all-tests

build/Build.UtilityTargets.cs

@@ -102,11 +102,119 @@ private string ResolveDevenvPath()
         throw new FileNotFoundException("Could not locate devenv.exe. Set DEVENV_PATH or install Visual Studio.");
     }
 
+    private string GetVsixProjectDirectory()
+    {
+        return Path.Combine(RepoRootPath, "src", "McpServer.VsExtension.McpTodo.Vsix");
+    }
+
+    private string GetVsixProjectPath()
+    {
+        return Path.Combine(GetVsixProjectDirectory(), "McpServer.VsExtension.McpTodo.Vsix.csproj");
+    }
+
+    private string ResolveVsixBuildRelativePath()
+    {
+        var projectDocument = XDocument.Load(GetVsixProjectPath());
+        var targetFramework = projectDocument
+            .Descendants()
+            .FirstOrDefault(element => element.Name.LocalName == "TargetFramework")
+            ?.Value
+            .Trim();
+
+        if (string.IsNullOrWhiteSpace(targetFramework))
+        {
+            var targetFrameworks = projectDocument
+                .Descendants()
+                .FirstOrDefault(element => element.Name.LocalName == "TargetFrameworks")
+                ?.Value;
+            targetFramework = targetFrameworks?
+                .Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                .FirstOrDefault();
+        }
+
+        if (string.IsNullOrWhiteSpace(targetFramework))
+        {
+            throw new InvalidOperationException($"Could not determine TargetFramework from {GetVsixProjectPath()}");
+        }
+
+        var runtimeIdentifier = projectDocument
+            .Descendants()
+            .FirstOrDefault(element => element.Name.LocalName == "RuntimeIdentifier")
+            ?.Value
+            .Trim();
+
+        return string.IsNullOrWhiteSpace(runtimeIdentifier)
+            ? targetFramework
+            : Path.Combine(targetFramework, runtimeIdentifier);
+    }
+
+    private string ResolveVsixOutputDirectory()
+    {
+        return Path.Combine(GetVsixProjectDirectory(), "bin", Configuration, ResolveVsixBuildRelativePath());
+    }
+
+    private string ResolveVsixObjectDirectory()
+    {
+        return Path.Combine(GetVsixProjectDirectory(), "obj", Configuration, ResolveVsixBuildRelativePath());
+    }
+
+    private void WriteVsixPkgDefFile(string pkgDefPath, string dllFileName)
+    {
+        // CreatePkgDef.exe cannot reflect the VSIX assembly after the project moved to net9.0-windows,
+        // so keep emitting the same registration shape the extension already uses in Visual Studio.
+        const string packageGuid = "{e8f0a1b2-3c4d-4e5f-8a9b-0c1d2e3f4a5b}";
+        const string packageClass = "McpServer.VsExtension.McpTodo.McpServerMcpTodoPackage";
+        const string assemblyIdentity = "McpServer.VsExtension.McpTodo, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
+        const string solutionExistsContextGuid = "{f1536ef8-92ec-443c-9ed7-fdadf150da82}";
+        const string toolWindowGuid = "{a1b2c3d4-e5f6-7890-abcd-ef1234567890}";
+        const string toolWindowClass = "McpServer.VsExtension.McpTodo.McpServerMcpTodoToolWindowPane";
+        const string toolWindowHostGuid = "3ae79031-e1bc-11d0-8f78-00a0c9110057";
+
+        var lines = new[]
+        {
+            $"[$RootKey$\\Packages\\{packageGuid}]",
+            "@=\"McpServerMcpTodoPackage\"",
+            "\"InprocServer32\"=\"$WinDir$\\SYSTEM32\\MSCOREE.DLL\"",
+            $"\"Class\"=\"{packageClass}\"",
+            $"\"Assembly\"=\"{assemblyIdentity}\"",
+            "\"AllowsBackgroundLoad\"=dword:00000001",
+            $"[$RootKey$\\AutoLoadPackages\\{solutionExistsContextGuid}]",
+            $"\"{packageGuid}\"=dword:00000002",
+            "[$RootKey$\\Menus]",
+            $"\"{packageGuid}\"=\", Menus.ctmenu, 1\"",
+            $"[$RootKey$\\ToolWindows\\{toolWindowGuid}]",
+            $"@=\"{packageGuid}\"",
+            $"\"Name\"=\"{toolWindowClass}\"",
+            "\"Style\"=\"Tabbed\"",
+            $"\"Window\"=\"{toolWindowHostGuid}\"",
+            string.Empty
+        };
+
+        EnsureDirectoryExists(Path.GetDirectoryName(pkgDefPath)!);
+        File.WriteAllText(pkgDefPath, string.Join(Environment.NewLine, lines), Encoding.Unicode);
+
+        var injectCodeBasePath = Path.Combine(GetVsixProjectDirectory(), "InjectCodeBase.ps1");
+        InvokeProcess(
+            "pwsh",
+            new List<string>
+            {
+                "-NoProfile",
+                "-File",
+                injectCodeBasePath,
+                "-PkgdefPath",
+                pkgDefPath,
+                "-DllName",
+                dllFileName
+            },
+            RepoRootPath,
+            true);
+    }
+
     private void RunPackageVsixTarget()
     {
-        var extensionDirectory = Path.Combine(RepoRootPath, "src", "McpServer.VsExtension.McpTodo.Vsix");
-        var outputDirectory = Path.Combine(extensionDirectory, "bin", Configuration, "net472", "win");
-        var objectDirectory = Path.Combine(extensionDirectory, "obj", Configuration, "net472", "win");
+        var extensionDirectory = GetVsixProjectDirectory();
+        var outputDirectory = ResolveVsixOutputDirectory();
+        var objectDirectory = ResolveVsixObjectDirectory();
         var stagingDirectory = Path.Combine(objectDirectory, "vsixstaging");
         var vsixPath = Path.Combine(outputDirectory, "McpServer.VsExtension.McpTodo.vsix");
         var dllPath = Path.Combine(outputDirectory, "McpServer.VsExtension.McpTodo.dll");
@@ -123,29 +231,8 @@ private void RunPackageVsixTarget()
             return;
         }
 
-        var nugetRoot = ResolveNuGetPackageRoot();
-        var vssdkPackageRoot = Path.Combine(nugetRoot, "microsoft.vssdk.buildtools");
-        if (!Directory.Exists(vssdkPackageRoot))
-        {
-            throw new DirectoryNotFoundException($"VSSDK build tools package directory not found at {vssdkPackageRoot}");
-        }
-
-        var vssdkVersionDirectory = Directory.GetDirectories(vssdkPackageRoot)
-            .OrderByDescending(path => path, StringComparer.OrdinalIgnoreCase)
-            .FirstOrDefault();
-        if (string.IsNullOrWhiteSpace(vssdkVersionDirectory))
-        {
-            throw new DirectoryNotFoundException($"No VSSDK version directories found at {vssdkPackageRoot}");
-        }
-
-        var createPkgDefPath = Path.Combine(vssdkVersionDirectory, "tools", "vssdk", "bin", "CreatePkgDef.exe");
-        if (!File.Exists(createPkgDefPath))
-        {
-            throw new FileNotFoundException($"CreatePkgDef not found at {createPkgDefPath}");
-        }
-
         EnsureDirectoryExists(objectDirectory);
-        InvokeProcess(createPkgDefPath, new List<string> { $"/out={pkgDefPath}", dllPath }, RepoRootPath, true);
+        WriteVsixPkgDefFile(pkgDefPath, Path.GetFileName(dllPath));
 
         ClearDirectory(stagingDirectory);
         EnsureDirectoryExists(stagingDirectory);
@@ -249,7 +336,7 @@ private void RunPackageVsixTarget()
 
     private void RunBuildAndInstallVsixTarget()
     {
-        var projectPath = Path.Combine(RepoRootPath, "src", "McpServer.VsExtension.McpTodo.Vsix", "McpServer.VsExtension.McpTodo.Vsix.csproj");
+        var projectPath = GetVsixProjectPath();
         if (!ShouldExecuteAction($"Build VSIX project {projectPath}"))
         {
             return;
@@ -258,7 +345,7 @@ private void RunBuildAndInstallVsixTarget()
         InvokeDotNet(new List<string> { "build", projectPath, "-c", Configuration }, RepoRootPath);
         RunPackageVsixTarget();
 
-        var vsixPath = Path.Combine(RepoRootPath, "src", "McpServer.VsExtension.McpTodo.Vsix", "bin", Configuration, "net472", "win", "McpServer.VsExtension.McpTodo.vsix");
+        var vsixPath = Path.Combine(ResolveVsixOutputDirectory(), "McpServer.VsExtension.McpTodo.vsix");
         if (!SkipInstall)
         {
             if (!ShouldExecuteAction($"Launch VSIX installer for {vsixPath}"))
@@ -402,7 +489,7 @@ void RemoveExistingExtensionDirectories(string baseDirectory)
     private void RunDeployMcpTodoExtensionTarget()
     {
         var targetInstallDirectory = ResolveVsixInstallDirectory();
-        var sourceDirectory = Path.Combine(RepoRootPath, "src", "McpServer.VsExtension.McpTodo.Vsix", "bin", Configuration, "net472", "win");
+        var sourceDirectory = ResolveVsixOutputDirectory();
         if (!Directory.Exists(sourceDirectory))
         {
             throw new DirectoryNotFoundException($"VSIX output directory not found: {sourceDirectory}");

docs/todo.yaml

@@ -905,14 +905,38 @@ mvp-mcp:
   high-priority:
   - id: DEPLOY-ALLSCRIPT-001
     title: A script to deploy all targets
-    done: false
+    note: Closed on 2026-03-16 after auditing the current repository implementation against the MCP TODO scope. All six requested targets are implemented in the deploy-all flow, automated coverage exists, and non-destructive validation passed in this session. The AndroidEmulator target was skipped in the WhatIf smoke run only because no emulator was attached, which is an environment condition rather than an implementation gap.
+    done: true
+    completed: 2026-03-16T02:38:19.6106193Z
     description:
-    - '- Director as Global Dotnet Tool'
-    - '- Web-UI as Global Dotnet Tool'
-    - '- Android to attached Phone'
-    - '- Android to attached Emulator'
-    - '- Desktop as MSIX to Windows'
-    - '- Desktop as DEB to WSL'
+    - Deploy all supported delivery targets from one orchestrated entry point.
+    - Cover Director as a global dotnet tool, Web-UI as a global dotnet tool, Android to an attached phone, Android to an attached emulator, Desktop as MSIX to Windows, and Desktop as DEB to WSL.
+    - Support both full-all deployment and targeted subset execution without requiring users to invoke individual build targets manually.
+    - Support safe dry-run auditing with -WhatIf so users can inspect the full deployment plan without mutating local installations or attached devices.
+    done-summary: Implemented and audited a unified deploy-all workflow covering Director, WebUi, AndroidPhone, AndroidEmulator, DesktopMsix, and DesktopDeb. Verified target selection, configuration overrides, WhatIf support, PowerShell compatibility helpers, documentation, three passing Pester tests, and a successful six-target WhatIf smoke run with zero failures.
+    remaining: None. DEPLOY-ALLSCRIPT-001 was closed on 2026-03-16 after confirming six-target coverage, orchestration support, automated tests, documentation, and passing non-destructive validation.
+    technical-details:
+    - scripts\\deploy-all.ps1 is the PowerShell entry point and exposes validated target selection, configuration, package-version, Android serial, WSL distro, and WhatIf parameters.
+    - scripts\\DeployAllTargets.psm1 provides the compatibility/orchestration module for PowerShell-based deploy-all target dispatch and summary reporting.
+    - build\\Build.cs declares the DeployAll target and the shared deployment parameters consumed by NUKE.
+    - build\\Build.BuildAndDeployTargets.cs implements DeployDirectorCore, DeployWebUiCore, DeployAndroidSelection, DeployDesktopMsixCore, DeployDesktopDebCore, ParseDeploySelections, ShowDeploySummary, and RunDeployAllTarget.
+    - README.md documents the DeployAll workflow, target-selection examples, and validation commands.
+    - Audit validation on 2026-03-16 passed with Invoke-Pester scripts\\DeployAllTargets.Tests.ps1 (3/3 tests) and scripts\\deploy-all.ps1 -WhatIf across Director, WebUi, AndroidPhone, AndroidEmulator, DesktopMsix, and DesktopDeb. The WhatIf run reported Failed=0; AndroidEmulator was skipped only because no attached emulator was present in this environment.
+    implementation-tasks:
+    - task: Provide a single deploy-all entry point that can orchestrate Director, WebUi, AndroidPhone, AndroidEmulator, DesktopMsix, and DesktopDeb.
+      done: true
+    - task: Support selective target execution instead of requiring all six targets on every run.
+      done: true
+    - task: Support deployment configuration overrides and target-specific parameters such as package version, Android serials, and WSL distro.
+      done: true
+    - task: Support safe dry-run auditing through WhatIf so the full deployment plan can be previewed without side effects.
+      done: true
+    - task: Add automated tests for deploy-all compatibility/orchestration behavior.
+      done: true
+    - task: Document the DeployAll workflow and validation commands for users.
+      done: true
+    - task: Audit the completed implementation against the MCP TODO scope and rerun non-destructive validation before closing the item.
+      done: true
   medium-priority: []
 director:
   medium-priority:

nupkg/SharpNinja.McpServer.Web.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
   <metadata>
     <id>SharpNinja.McpServer.Web</id>
-    <version>0.5.1-30</version>
+    <version>0.5.1-34</version>
     <authors>SharpNinja</authors>
     <description>SharpNinja.McpServer.Web</description>
     <packageTypes>

src/McpServer.Director/McpServer.Director.csproj

@@ -20,6 +20,7 @@
     <RepositoryType>git</RepositoryType>
   </PropertyGroup>
   <ItemGroup>
+    <PackageReference Include="System.Text.Json" Version="10.0.3" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc3" />
     <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.3.0" />

src/McpServer.UI.Core/Commands/InvokeUiActionCommand.cs

@@ -26,18 +26,17 @@ public InvokeUiActionCommand(Func<Task> Action)
     public Func<Task> Action { get; }
 }
 
-public sealed class InvokeUiActionHandler : ICommandHandler<InvokeUiActionCommand, bool>
+public sealed class InvokeUiActionHandler(Services.IUiDispatcherService uiDispatcher) : ICommandHandler<InvokeUiActionCommand, bool>
 {
     public async Task<Result<bool>> HandleAsync(InvokeUiActionCommand command, CallContext context)
     {
-        if (Avalonia.Threading.Dispatcher.UIThread.CheckAccess())
+        if (uiDispatcher.CheckAccess())
         {
             await command.Action().ConfigureAwait(true);
             return Result<bool>.Success(true);
         }
 
-        await Avalonia.Threading.Dispatcher.UIThread.InvokeAsync(async () =>
-            await command.Action().ConfigureAwait(true)).ConfigureAwait(true);
+        await uiDispatcher.InvokeAsync(command.Action).ConfigureAwait(true);
         return Result<bool>.Success(true);
     }
 }

src/McpServer.UI.Core/Services/IUiDispatchStrategy.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Threading.Tasks;
+
+namespace McpServer.UI.Core.Services;
+
+/// <summary>
+/// Strategy for marshaling work onto a host UI thread or synchronization context.
+/// </summary>
+public interface IUiDispatchStrategy
+{
+    /// <summary>Returns <see langword="true"/> when the caller already has UI access.</summary>
+    bool CheckAccess();
+
+    /// <summary>Invokes an asynchronous action on the UI context.</summary>
+    Task InvokeAsync(Func<Task> action);
+
+    /// <summary>Posts a synchronous action to the UI context.</summary>
+    void Post(Action action);
+}

src/McpServer.UI.Core/Services/IUiDispatcherService.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 
 namespace McpServer.UI.Core.Services;
 
@@ -7,6 +8,12 @@ namespace McpServer.UI.Core.Services;
 /// </summary>
 public interface IUiDispatcherService
 {
+    /// <summary>Returns <see langword="true"/> when the caller is already on the UI context.</summary>
+    bool CheckAccess();
+
+    /// <summary>Invokes an asynchronous action on the UI context.</summary>
+    Task InvokeAsync(Func<Task> action);
+
     /// <summary>Posts an action for execution on the UI context.</summary>
     void Post(Action action);
 }

src/McpServer.UI.Core/Services/ImmediateUiDispatcherService.cs

@@ -1,12 +1,35 @@
 using System;
+using System.Threading.Tasks;
 
 namespace McpServer.UI.Core.Services;
 
 /// <summary>
 /// Default dispatcher that executes work inline when no UI dispatcher is supplied by host.
 /// </summary>
-public sealed class ImmediateUiDispatcherService : IUiDispatcherService
+public sealed class ImmediateUiDispatcherService : StrategyUiDispatcherService
 {
-    /// <inheritdoc />
-    public void Post(Action action) => action();
+    /// <summary>
+    /// Initializes the immediate dispatcher service.
+    /// </summary>
+    public ImmediateUiDispatcherService()
+        : base(new ImmediateUiDispatchStrategy())
+    {
+    }
+}
+
+internal sealed class ImmediateUiDispatchStrategy : IUiDispatchStrategy
+{
+    public bool CheckAccess() => true;
+
+    public Task InvokeAsync(Func<Task> action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        return action();
+    }
+
+    public void Post(Action action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        action();
+    }
 }

src/McpServer.UI.Core/Services/StrategyUiDispatcherService.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Threading.Tasks;
+
+namespace McpServer.UI.Core.Services;
+
+/// <summary>
+/// Reusable <see cref="IUiDispatcherService"/> implementation that delegates UI marshaling to a strategy.
+/// </summary>
+public class StrategyUiDispatcherService : IUiDispatcherService
+{
+    private readonly IUiDispatchStrategy _strategy;
+
+    /// <summary>
+    /// Initializes a strategy-backed UI dispatcher service.
+    /// </summary>
+    /// <param name="strategy">Framework-specific UI dispatch strategy.</param>
+    public StrategyUiDispatcherService(IUiDispatchStrategy strategy)
+    {
+        ArgumentNullException.ThrowIfNull(strategy);
+        _strategy = strategy;
+    }
+
+    /// <summary>
+    /// Gets the active UI dispatch strategy.
+    /// </summary>
+    protected IUiDispatchStrategy Strategy => _strategy;
+
+    /// <inheritdoc />
+    public bool CheckAccess() => _strategy.CheckAccess();
+
+    /// <inheritdoc />
+    public Task InvokeAsync(Func<Task> action) => _strategy.InvokeAsync(action);
+
+    /// <inheritdoc />
+    public void Post(Action action) => _strategy.Post(action);
+}