Add PowerShell host UI streaming

[eosfor]

Problem

PowerShell cells that wrote host UI output during long-running execution did not surface that output until the command finished. This made cells that called Write-Host, prompted with Read-Host, or blocked on longer work feel unresponsive in the notebook UI.

PowerShell interactive input also needed a host-to-extension path that can reply while the execution pipeline is still running, without waiting behind the same sequential request queue.

Approach

This PR adds a dedicated Verso.PowerShellHost adapter and wires it into the PowerShell runspace. The host captures PowerShell UI output and input requests, forwards streamed output through the execution context, and sends input requests to the VS Code extension through the host protocol.

The VS Code bridge handles input/request notifications by showing an input box and replying to the host with input/response.

Notable changes

• Add src/Verso.PowerShellHost with a PSHost, PSHostUserInterface, and raw UI implementation.
• Create the PowerShell runspace with the Verso host adapter.
• Stream host output through IExecutionContext.WriteOutputAsync.
• Add interactive input plumbing through IExecutionContext.RequestInputAsync.
• Add JSON-RPC protocol names and VS Code bridge handling for input/request and input/response.
• Add PowerShell host package metadata/README so package generation succeeds.
• Document PowerShell host interactivity in the architecture docs.
• Update related tests and test fakes for the expanded execution context surface.

Validation

• npm run lint
• dotnet build Verso.sln --no-restore

Manual checks

PowerShell host output now appears while the command is still running:

Write-Host "before $(Get-Date -Format HH:mm:ss)"
Start-Sleep -Seconds 20
Write-Host "after $(Get-Date -Format HH:mm:ss)"

Interactive input can be requested from a PowerShell cell:

$name = Read-Host "Name"
Write-Host "hello $name"

Review notes

This PR intentionally focuses on PowerShell host UI streaming and input plumbing. Stop/cancel controls are split into a separate PR.

[eosfor]

Rebased this branch onto current main with -Xrenormalize and force-pushed. GitHub now reports it as mergeable.

[eosfor]

Synced and rechecked the F5 manual validation.

The issue we saw locally was not the PowerShell host streaming implementation itself. The F5 extension host was able to pick up an older configured verso.hostPath, so it was running a stale host instead of the freshly built bundled vscode/host/Verso.Host.dll.

I updated development-mode host resolution so F5 prefers the bundled host, while production still honors a configured verso.hostPath. I also added tests for that behavior.

Manual F5 verification now passes:

• Write-Host "before" appears while Start-Sleep is still running.
• Read-Host shows the input prompt and then outputs the provided value.

I also reverted the WASM cache-buster experiment since it was not the root cause.

[eosfor]

I'm sorry, this was smth internal :)

But actually, yes, .net8 end of support is November 10, 2026. So perhaps it is time to migrate.

[eosfor]

Rebased this PR onto current main (ce26f2b) and force-pushed. The branch still stays on the current upstream target frameworks; the separate local .NET 9 work is not included here.

Local validation after the rebase:

• npm run lint
• dotnet build Verso.sln --no-restore
• dotnet test tests/Verso.PowerShell.Tests/Verso.PowerShell.Tests.csproj --no-restore

Do you plan to merge this PR, or is there anything else you would like changed first?

This one is important for us because it makes PowerShell notebooks usable for the workflows we are actively testing. The sample notebooks we are using include:

• installing/importing graph modules such as PSQuickGraph and PSGraphView from PowerShell Gallery,
• building graph objects in PowerShell and rendering them back into the notebook as SVG/PNG output,
• running richer PowerShell notebooks such as a small micrograd-style computation graph with custom formatting and graph visualization.

For those scenarios, silent long-running cells are very hard to diagnose, and interactive host prompts are a blocker for common PowerShell flows such as Read-Host, credential/choice prompts, and auth/device-login style commands. Streaming host UI output and routing host input through the VS Code bridge are the pieces that make those notebooks feel like a real PowerShell environment instead of a batch-only runner.

[TorreyBetts]

Thanks for the rebase and the validation runs. Before I review this one I want to finish closing out testing on the PRs that merged recently and fix anything that surfaces from that pass. Stacking more on top before that makes the next round of issues harder to attribute. I'll come back to this once that's done.

[TorreyBetts]

Write-Information output is dropped: WriteInformation is a no-op and ps.Streams.Information is skipped when hostOutput is set. Please keep the stream loop and filter records by tag: skip PSHOST (that's Write-Host, already covered by the host UI) and keep the rest. Worth a regression test with Write-Information -InformationAction Continue.

[TorreyBetts]

The new Scaffold.OnCellOutputUpdated and Scaffold.InputRequester are only wired in Verso.Host (the VS Code backend). ServerNotebookService subscribes to OnCellExecuted but not the new event, and nothing sets InputRequester for Blazor Server. Net effect: Read-Host in verso serve falls through to a PSError ("Interactive input is not supported") even though a UI is present. Please add equivalent wiring next to the existing OnCellExecuted subscription so live output and input prompts work there too.

Unrelated to the above, but should be addressed as well is Verso.PowerShellHost is published as its own NuGet, but it has only one consumer and no third-party scenario. Could you fold the contents into src/Verso.PowerShell/Kernel/Host/ as internal types? That preserves your intent without committing to a new package.

[TorreyBetts]

It's cleaner to set this as false until SGR parsing is implemented. The Emit currently strips the ANSI sequences, so it's easier to just leave them out for now.

[eosfor]

Pushed the review follow-up changes to pr/powershell-host-streaming.

Summary of what changed:

• Folded the PowerShell host adapter into Verso.PowerShell.

  • Removed the separate Verso.PowerShellHost project/package.
  • Moved the host implementation under src/Verso.PowerShell/Kernel/Host/.
  • Made the host adapter types internal.

• Set SupportsVirtualTerminal => false.

  • The host still strips ANSI escape sequences, but does not advertise VT support until SGR parsing is implemented.

• Fixed Write-Information.

  • Non-PSHOST information records are now preserved.
  • PSHOST records are skipped to avoid duplicating Write-Host.
  • Added regression coverage for Write-Information -InformationAction Continue.
  • Also fixed the Blazor Server case where Write-Information -InformationAction Continue could render twice because PowerShell can both host-render the information message and keep the same record in ps.Streams.Information.

• Wired Blazor Server / verso serve to the same live output and input flow.

  • ServerNotebookService now subscribes to Scaffold.OnCellOutputUpdated.
  • ServerNotebookService now provides Scaffold.InputRequester.
  • Added a Blazor input dialog for Read-Host / secure input.
  • Fixed the Blazor Server event-flow issue where awaiting the full cell execution inside the original run-button event prevented Submit/Cancel/close clicks from resolving a pending Read-Host.

Validation run locally:

dotnet test tests/Verso.PowerShell.Tests/Verso.PowerShell.Tests.csproj --no-restore
dotnet test tests/Verso.Blazor.Shared.Tests/Verso.Blazor.Shared.Tests.csproj --no-restore
dotnet build Verso.sln --no-restore
npm run lint

Manual verso serve checks:

Write-Host "before $(Get-Date -Format HH:mm:ss)"
Start-Sleep -Seconds 5
Write-Host "after $(Get-Date -Format HH:mm:ss)"

Confirmed before appears while the cell is still running, and after appears after the sleep.

$name = Read-Host "Name"
Write-Host "hello $name"

Confirmed the input dialog appears, Submit resumes execution, and output contains the submitted value.

$secret = Read-Host "Secret" -AsSecureString
Write-Host "done"

Confirmed secure input is masked and execution resumes.

Write-Information "info message" -InformationAction Continue

Confirmed the message renders once.

[TorreyBetts]

Thanks for the follow-up work. Merging now.