CmdPal JS/TS Extensions - Phase 4: extension service, wrapper, discovery + host wiring

[michaeljolley]

Warning

This PR is one in a series of PRs focused on adding TypeScript/JavaScript extension support to Command Palette.

This PR should not be merged until PR #49326 is merged into it.

Note

To test the final result, run the branch associated with PR #49364.

Summary

Phase 4 of the CmdPal JS/TS extensions effort. This is the integration phase that makes JavaScript/TypeScript Command Palette extensions actually load and run end to end. JS/TS extensions run as isolated Node.js processes that talk to the C# host over JSON-RPC 2.0 via stdio (LSP Content-Length framing).

Tracking issue: #48707

Stacking

This PR stacks on Phase 3 (#49324) and targets dev/mjolley/phase-3-cmdpal-adapters, not main. It stays a draft until the earlier phases are reviewed and merged. Phases 1-3 (TypeScript SDK, JSON-RPC transport + manifest, and the adapter/proxy translation layer) are already present in the base branch.

What this adds

• Models/JSExtensionWrapper.cs (IExtensionWrapper): spawns node <entrypoint> with stdio redirection, honoring cmdpal.debug to pass --inspect and debugPort (auto-assigned from 9229). Owns a JsonRpcConnection (Phase 2), sends the initialize handshake, and exposes the JSCommandProviderProxy (Phase 3). Lifecycle start/stop/dispose sends the dispose notification with a 2 second grace period before killing the process tree. Teardown is deadlock-safe (handlers unsubscribed and fields captured under lock, blocking work done outside the lock). A consecutive-crash counter treats 1-3 crashes as restartable and marks the extension unhealthy after more than 3.
• Services/JsonRpcExtensionService.cs (IExtensionService): discovers extensions under %LOCALAPPDATA%\Microsoft\PowerToys\CommandPalette\JSExtensions, validates each package.json against the Phase 2 manifest, and builds a CommandProviderWrapper per extension. A FileSystemWatcher handles install (load), uninstall (unload + kill), and *.js changes for hot-reload (debounced 500 ms, ignoring node_modules). Raises OnProviderAdded/OnProviderRemoved.
• Services/HotReloadDebouncer.cs: testable 500 ms per-directory debounce that ignores node_modules changes.
• CommandProviderWrapper.cs: new constructor for the JS path, where the ICommandProvider is obtained directly over JSON-RPC instead of through GetExtensionObject.
• Wiring (App.xaml.cs): registers JsonRpcExtensionService as an IExtensionService singleton alongside the built-in and WinRT services. TopLevelCommandManager consumes it through the existing IEnumerable<IExtensionService> path, and MainWindow disposes it through the existing SignalStopAsync loop, so no new signatures were needed.

Host-side host/logMessage, host/showStatus, host/hideStatus, and host/copyText notifications are already handled by the JSCommandProviderProxy from Phase 3, so no ShellViewModel/MainWindow host-notification changes were required.

How JS extensions now load end to end

1. On startup the service scans the JSExtensions directory and validates each manifest.
2. For each valid extension it constructs a JSExtensionWrapper, spawns the Node.js process, performs the initialize handshake, and wraps the resulting provider in a CommandProviderWrapper.
3. TopLevelCommandManager picks the providers up through the shared IExtensionService enumeration and surfaces their commands.
4. Directory and source-file watchers keep the set live: new directories load, deleted directories unload and kill the process, and *.js edits hot-reload (recreating the wrapper so the proxy rebinds to a fresh connection).
5. On shutdown each extension receives a dispose notification followed by process-tree termination.

Validation

• Build: tools\build\build.ps1 -Path src\modules\cmdpal -Platform x64 -Configuration Debug exits 0.
• Unit tests: all CmdPal *.UnitTests projects pass. New tests cover discovery/manifest filtering, hot-reload debounce (including node_modules exclusion and cancellation), and crash-counter state transitions, all factored to run without spawning a Node.js process.