The user wants a Blazor web app that runs PowerShell scripts on a local client PC via a local agent. This is a fairly common architecture pattern where: 1. A Blazor web app (server or WebAssembly) provides the UI for composing/running PowerShell scripts 2. A "local agent" is a lightweight service/daemon running on the client machine that receives commands and executes PowerShell locally 3. Communication between them happens over HTTP/WebSockets/SignalR Let me think through the architecture: **Architecture options:** Option A: Blazor Server + Local Agent with SignalR - Blazor Server app hosts the UI - Agent connects to the server (or server connects to agent) - Server can't directly reach client PCs behind NAT typically, so the agent usually connects outbound to the server via SignalR Option B: Blazor WebAssembly + Local Agent with REST API - WASM app runs in browser - Agent runs a local HTTP listener (e.g., http://localhost:5000) - Browser calls localhost endpoints — but this has HTTPS/CORS/mixed content issues The most robust pattern for "runs scripts on local client PC via local agent" is: - Blazor Server (or Blazor Web with Server interactivity) - A SignalR hub where agents connect outbound (so no inbound firewall issues on client) - Server sends script to agent via SignalR, agent executes PowerShell, streams output back - UI shows real-time output This is essentially an RMM (remote monitoring and management) light pattern. Let me design the full solution: **Solution structure:** 1. `BlazorPowerShell.Web` — Blazor Server app (.NET 8/9) - `Hubs/AgentHub.cs` — SignalR hub for agent communication - UI pages: list connected agents, select agent, write script, run, stream output - `AgentConnectionManager` — singleton tracking connected agents (connectionId → agent info) 2. `Agent` — console app / worker service running on client PC - Connects to hub with SignalR client - Registers itself (machine name, user, etc.) - Listens for `RunScript` invocation - Executes PowerShell via `System.Management.Automation` PowerShell SDK - Streams output lines back to hub **Key technical pieces:** - SignalR hub with methods: - Agent → Server: `RegisterAgent(machineName, os, version)` - Server → Agent: `RunScript(scriptId, script)` - Agent → Server: `ScriptOutput(scriptId, line)`, `ScriptCompleted(scriptId, exitCode)`, `ScriptError(...)` - `IHubContext` on server to push commands - Singleton `AgentRegistry` (ConcurrentDictionary) to track online agents - PowerShell execution in agent using Runspace/PowerShell instance: ```csharp using var ps = PowerShell.Create(); ps.AddScript(script); ps.Streams.Progress.DataAdded += ... ps.Streams.Output.DataAdded += ... ps.Streams.Error.DataAdded += ... ``` Stream output as it's produced (DataAdded events) for real-time feedback. - Run in Task.Run so SignalR invocation doesn't block. - Optionally an execution timeout / cancellation. - Security considerations: authentication between agent and hub (API key), TLS, script allowlisting, audit logging. I should mention these but keep the sample functional. **Blazor UI:** - Page "Agents" showing connected agents with online status - Page "Run" with a dropdown of agents, textarea for script, Run button, output console (real-time updates via events) For real-time updates in Blazor Server UI, we need to marshal events to the circuit. The AgentRegistry can raise events; the component subscribes and calls `InvokeAsync(StateHasChanged)`. Need to be careful with event handlers across components; a common approach is a singleton `ScriptResultStore` that holds output lines per scriptId, and the component polls or subscribes. Simpler approach for the demo: when user clicks Run, generate a scriptId, call `hubContext.Clients.Client(agentConnId).SendAsync("RunScript", scriptId, script)`, then await a `TaskCompletionSource` for completion while the output lines accumulate into a buffer; the UI subscribes to a per-script event. I'll implement a `ScriptMonitor`/`ScriptRunStore` singleton with: ```csharp public class ScriptRunStore { private readonly ConcurrentDictionary _runs = new(); public ScriptRun CreateRun(string scriptId, string agentId, string script) ... public void AppendOutput(string scriptId, string line) ... public void CompleteRun(string scriptId, int exitCode) ... public event Action? OnChange; // naive } ``` Better: each ScriptRun has its own event so only subscribers to that run get updated. Or the component can subscribe to the run's event. Let me write the code. **Target framework:** .NET 8 (LTS) — good choice. Blazor Web App template with Server interactivity (global). SignalR included in Blazor Server. **Project 1: BlazorPowerShell.Web** Program.cs: ```csharp using BlazorPowerShell.Web.Components; using BlazorPowerShell.Web.Hubs; using BlazorPowerShell.Web.Services; var builder = WebApplication.CreateBuilder(args); builder.Services.AddRazorComponents() .AddInteractiveServerComponents(); builder.Services.AddSignalR(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); var app = builder.Build(); // ... app.MapRazorComponents() .AddInteractiveServerRenderMode(); app.MapHub("/hubs/agent"); app.Run(); ``` AgentRegistry: ```csharp public sealed class AgentRegistry { private readonly ConcurrentDictionary _agents = new(); public event Action? AgentsChanged; public void AddOrUpdate(string connectionId, AgentInfo info) { _agents[connectionId] = info; AgentsChanged?.Invoke(); } public void Remove(string connectionId) { _agents.TryRemove(connectionId, out _); AgentsChanged?.Invoke(); } public IReadOnlyList GetAll() => _agents.Values.ToList(); public bool TryGetByMachine(string machineName, out AgentInfo? info) { info = _agents.Values.FirstOrDefault(a => a.MachineName == machineName); return info is not null; } } public record AgentInfo(string ConnectionId, string MachineName, string UserName, string Os, string AgentVersion, DateTimeOffset ConnectedAt); ``` Hmm, but connectionId as key — when reconnecting it changes. For simplicity fine. ScriptRunStore: ```csharp public sealed class ScriptRun { public string ScriptId { get; } = Guid.NewGuid().ToString("N"); public string AgentConnectionId { get; init; } = ""; public string Script { get; init; } = ""; public DateTimeOffset StartedAt { get; init; } public List Output { get; } = new(); public int? ExitCode { get; set; } public bool IsComplete { get; set; } public string? Error { get; set; } public event Action? OutputReceived; public event Action? Completed; internal void OnOutput(string line) { lock (Output) Output.Add(line); OutputReceived?.Invoke(line); } internal void OnCompleted(int? code, string? error) { ExitCode = code; Error = error; IsComplete = true; Completed?.Invoke(); } } public sealed class ScriptRunStore { private readonly ConcurrentDictionary _runs = new(); public ScriptRun Create(string connectionId, string script) { ... } public ScriptRun? Get(string scriptId) => _runs.TryGetValue(scriptId, out var r) ? r : null; } ``` AgentHub: ```csharp [Authorize] // optional; I'll keep it open for demo but mention auth public sealed class AgentHub : Hub { private readonly AgentRegistry _registry; public AgentHub(AgentRegistry registry) => _registry = registry; public Task RegisterAgent(AgentInfoDto info) { _registry.AddOrUpdate(Context.ConnectionId, new AgentInfo( Context.ConnectionId, info.MachineName, info.UserName, info.Os, info.Version, DateTimeOffset.UtcNow)); return Task.CompletedTask; } public Task ScriptOutput(string scriptId, string line) { // find run and append } public Task ScriptCompleted(string scriptId, int exitCode, string? error) { ... } public override Task OnDisconnectedAsync(Exception? exception) { _registry.Remove(Context.ConnectionId); return base.OnDisconnectedAsync(exception); } } ``` Hmm — using `AgentInfoDto` shared between server and agent. Best to have a shared project `Shared` with DTOs. For a self-contained answer, I can duplicate the DTO in the agent or make a shared class library. I'll create a shared project `BlazorPowerShell.Shared` containing `AgentHubMethods` constants and DTO records. That's cleaner. Actually, to reduce project count, I could just define DTOs in the Web project and reference... but the agent referencing the web project is ugly. A shared class library is the professional way. Let me include: - `src/BlazorPowerShell.Shared` (classlib): DTOs + hub method name constants - `src/BlazorPowerShell.Web` (blazor web app) - `src/BlazorPowerShell.Agent` (console app / worker) UI components: Routes.razor, App.razor standard. Pages: - `Agents.razor` — list connected agents (interactive server) - `RunScript.razor` — pick agent, script textarea, run, console output RunScript.razor logic: ```csharp private string? _selectedConnectionId; private string _script = ""; private ScriptRun? _currentRun; private async Task RunAsync() { if (!_registry.TryGet(_selectedConnectionId, out var agent)) return; var run = _runStore.Create(agent.ConnectionId, _script); _currentRun = run; run.OutputReceived += _ => InvokeAsync(StateHasChanged); run.Completed += _ => InvokeAsync(StateHasChanged); await Hub.Clients.Client(agent.ConnectionId).SendAsync(HubMethods.RunScript, run.ScriptId, _script); } ``` Inject `IHubContext`. Dispose: unsubscribe events in IDisposable.Dispose. **Project 2: Agent** Worker or console app. Console app simpler: ```csharp var builder = Host.CreateApplicationBuilder(args); builder.Services.AddSignalR(); // client builder.Services.AddHostedService(); ``` Actually for SignalR client in a hosted service, use `HubConnectionBuilder`. Let me write AgentWorker: ```csharp public sealed class AgentWorker : BackgroundService { private HubConnection? _connection; protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var hubUrl = config["HubUrl"]; // e.g. https://localhost:7001/hubs/agent _connection = new HubConnectionBuilder() .WithUrl(hubUrl, options => { options.AccessTokenProvider = () => Task.FromResult(config["Agent:ApiKey"]); // if using auth }) .WithAutomaticReconnect() .Build(); _connection.On(HubMethods.RunScript, RunScriptAsync); // register on reconnect _connection.Reconnected += _ => RegisterAsync(); await _connection.StartAsync(stoppingToken); await RegisterAsync(); } private async Task RunScriptAsync(string scriptId, string script) { try { using var ps = PowerShell.Create(); ps.AddScript(script); // stream output ps.Streams.Output.DataAdded += (_, e) => { var item = ps.Streams.Output[e.Index]; Send(scriptId, item?.ToString() ?? ""); }; ps.Streams.Error.DataAdded += ...; ps.Streams.Progress.DataAdded += ...; ps.Streams.Warning.DataAdded += ...; ps.Streams.Verbose... var result = await ps.InvokeAsync().ConfigureAwait(false); // flush any remaining int code = ps.HadErrors ? 1 : 0; // or use $LASTEXITCODE await _connection!.InvokeAsync(HubMethods.ScriptCompleted, scriptId, code, null); } catch (Exception ex) { await _connection!.InvokeAsync(HubMethods.ScriptCompleted, scriptId, 1, ex.Message); } } } ``` Careful: DataAdded events fire on the pipeline thread; sending via connection thread-safe — SignalR client `SendAsync` is thread safe. But we should not `await` inside event handler; use fire-and-forget with try/catch. Also concurrent sends of ordered output — SignalR preserves per-invocation order; multiple concurrent SendAsync calls may reorder. To keep order, serialize sends with a lock or a Channel. Simplest: use a lock around SendAsync fire-and-forget? A lock around async isn't good. Use `SemaphoreSlim(1,1)` or a Channel-based writer loop. To keep the answer approachable, I can serialize with a `SemaphoreSlim`: ```csharp private readonly SemaphoreSlim _sendLock = new(1, 1); private async Task SendLineAsync(string scriptId, string line) { try { await _sendLock.WaitAsync(); await _connection!.SendAsync(HubMethods.ScriptOutput, scriptId, line); } finally { _sendLock.Release(); } } ``` But DataAdded handler can't await. Use `_ = SendLineAsync(...)` fire and forget — the semaphore preserves ordering. Good. For exit code: proper way is to run `$LASTEXITCODE` after? Or check `ps.HadErrors`. For simplicity: capture `$LASTEXITCODE` if set by native commands. I can add `ps.AddScript(script); ps.Streams...` then after invoke, if `ps.Runspace` ... simpler: append nothing, and on completion evaluate: Actually simplest robust: after invoking the user script, run a tiny second pipeline to read `$LASTEXITCODE`. Or set exit code = HadErrors ? 1 : 0. I'll do: `int exitCode = ps.HadErrors ? 1 : 0;` and mention you can extend to capture `$LASTEXITCODE`. Or do it properly: ```csharp ps.Commands.Clear(); ps.AddScript("if ($null -ne $LASTEXITCODE) { $LASTEXITCODE } else { if ($?) { 0 } else { 1 } }"); ``` Hmm that's getting complicated because `$LASTEXITCODE` persists in the runspace after invoking script. Since same PowerShell instance/runspace persists, after `InvokeAsync` of the script, I can invoke another command in the same instance to read `$LASTEXITCODE`: ```csharp ps.Streams.ClearStreams(); ps.Commands.Clear(); ps.AddScript("if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } else { 0 }"); var exit = (await ps.InvokeAsync()).FirstOrDefault()?.BaseObject as int? ?? 0; ``` That works since same runspace retains variables. Nice touch, but adds complexity. I'll include it but keep it readable, with fallback to HadErrors. Agent should also support cancellation? Keep simple; mention timeout as improvement. Maybe add optional `Runspace` timeout via CancellationToken + `ps.Stop()`. Skip for brevity but mention. **Security section** (important — this is remote code execution infra): - Require auth on hub (API key via query string or bearer token; validate in `OnConnectedAsync`) - Use HTTPS with valid cert - Consider [Authorize] with policy for agents vs users - Sanitize/allowlist scripts, audit log, run as non-admin, constrained language mode / JEA, signing scripts - The demo leaves the hub open so it works out of the box — call it out. I should include a simple API key check to show how: in hub `OnConnectedAsync`, read `Context.GetHttpContext().Request.Query["access_token"]` or header. And agent sets `options.Headers.Add("x-agent-key", key)` or AccessTokenProvider. I'll show a minimal version with a config value, maybe commented. Let me include it but allow empty key in dev. Actually to keep the sample runnable easily, I'll include the auth check but default config value "dev-key" both sides. Hmm — adds friction. Alternative: show the code but guarded by config flag. I think showing it is valuable; this is inherently a remote-code-execution system. I'll include a simple shared-secret check on connect, configured in appsettings both sides, and note to replace with real auth (cert/mTLS/Entra ID) in production. Let me keep it lean: in AgentHub.OnConnectedAsync, if configured AgentKey is non-empty, require header `X-Agent-Key` match else abort. Agent adds the header. Good balance. **Hosting notes:** - Blazor Server app run: `dotnet run --project src/BlazorPowerShell.Web` (use `--urls https://localhost:7001`) - Agent run on client PC: edit appsettings or args: `dotnet src/BlazorPowerShell.Agent.dll --HubUrl https://yourserver:7001/hubs/agent` - For cross-machine, the web server must be reachable; the agent connects outbound so client firewalls/NAT are fine. - Install agent as a Windows Service: mention `Microsoft.Extensions.Hosting.SystemService`/`UseWindowsService()` with sc create command. I can add `builder.Services.AddWindowsService();` guarded — include the package line and one-liner. **UI design details:** App.razor with default .NET 8 template structure. I'll write minimal custom CSS inline in components or a site.css addition. To keep the answer focused, use Bootstrap classes (the template ships Bootstrap). Console output in a `

` styled dark background, auto-scroll via JS? Auto-scroll requires JS interop or simple `overflow` styling; I can add a tiny JS snippet in App.razor or the component with `afterRenderAsync` scroll to bottom. Keep simple: fixed-height pre with `overflow:auto`, and after each render scroll via ElementReference + JS. I'll include a small JS call using IJSRuntime `consoleScroll.scrollTop = consoleScroll.scrollHeight`. Or skip and mention. I'll include it — small and nice UX. Actually to limit complexity, maybe use a simple `IJSRuntime.InvokeVoidAsync("eval", ...)`? No — do a tiny inline script in App.razor:

```html

```

And in component: `await JS.InvokeVoidAsync("scrollToBottom", _consoleEl);` in AfterRenderAsync when output changed. Fine.

Pages code — RunScript.razor:

```razor
@page "/run"
@using Microsoft.AspNetCore.SignalR
@inject IHubContext Hub
@inject AgentRegistry Registry
@inject ScriptRunStore Runs
@inject IJSRuntime JS
@implements IDisposable

Run PowerShell


<button @onclick="Run" disabled="@(_running || _selected is null)">Run</button>
<button @onclick="Cancel" ...>Cancel</button>

<div class="console"><pre>@foreach line</pre></div>
```

Need to handle registry changes to refresh the select: subscribe `Registry.AgentsChanged += () => InvokeAsync(StateHasChanged)`.

Cancel: send `CancelScript(scriptId)` to agent; agent calls `ps.Stop()` from another task, or uses CancellationToken with Register to Stop. Implement: keep dictionary of running PowerShell instances by scriptId in agent; on Cancel, `ps.Stop()`. `PowerShell.Stop()` is synchronous and safe to call from another thread. I'll implement `CancellationTokenSource` + `ct.Register(() => ps.Stop())` — actually `PowerShell.Stop()` stops the pipeline. Note: with event handlers, stop triggers PipelineStoppedException possibly — handle.

Hmm, is cancellation necessary for the demo? It's a nice-to-have. I'll include it lightly: agent keeps `ConcurrentDictionary<string, PowerShell> _running`; hub method CancelScript invokes `_running[scriptId].Stop()`. Server: send `HubMethods.CancelScript` with scriptId. UI: Cancel button. This is genuinely useful for a runaway script. Include but keep code tight.

Edge cases to mention:
- Multiple agents behind same machine name — key by connection id.
- Output encoding of complex objects: `ToString()` or format via `Out-String`? Streaming raw objects: use `ConvertTo-Json` per item? Simpler: for each output item, use `string.Format("{0}", item)` — PSObject ToString gives pretty text usually. Or the agent wraps script with `| Out-String -Stream`? That changes semantics. I'll just ToString and note formatting option: wrap with `Out-String` for tables. Actually a neat approach: use `ps.AddCommand("Out-String")...` no — that buffers everything. Keep ToString and mention.

Progress: `Write-Progress` events -> send as lines like `[PROGRESS] ...`? Keep: send progress activity as line with prefix. Warnings/verbose/errors prefixed `[warning]`, `[error]`, `[verbose]`. In UI, color errors red? That requires storing line severity. Let me store severity: output lines as `ConsoleLine(string Text, string Kind)`. Kind: "output", "error", "warning", "info", "system". Hub sends `ScriptOutput(scriptId, kind, text)`. UI colors via class. That's a bit more code but much better UX. I'll do it.

DTO for hub methods: define constants in Shared:

```csharp
public static class HubMethods
{
    public const string ServerAgentHubPath = "/hubs/agent";
    // agent -> server
    public const string RegisterAgent = "RegisterAgent";
    public const string ScriptOutput = "ScriptOutput";
    public const string ScriptCompleted = "ScriptCompleted";
    // server -> agent
    public const string RunScript = "RunScript";
    public const string CancelScript = "CancelScript";
}

public record AgentRegistration(string MachineName, string UserName, string Os, string AgentVersion);
```

Output line: send as (string kind, string text) — use a record `ScriptOutputLine(string Kind, string Text)` in Shared.

ScriptRun stores `List<ScriptOutputLine>`.

**Agent PowerShell details:**

`System.Management.Automation` NuGet package (PowerShell SDK). For a console app targeting net8.0 on Windows, add `Microsoft.PowerShell.SDK` version `7.4.*` to get pwsh 7.4 engine — cross-platform! That's better than Windows PowerShell 5.1 (`System.Management.Automation` from nuget is the 6+/7 SDK). Microsoft.PowerShell.SDK gives you PS 7.x engine, cross-platform. Use that. Mention: if you need Windows PowerShell 5.1, use the Windows PowerShell SDK refs instead (only on Windows).

Version: pick `7.4.*` to be safe (7.5 exists but let me not overcommit; use 7.4.x LTS). I'll write version `7.4.*`.

Agent code with streaming:

```csharp
private async Task RunScriptAsync(string scriptId, string script)
{
    var ps = PowerShell.Create();
    _running[scriptId] = ps;

    void Attach(PSDataCollection<DebugRecord> ... ) // hmm generic per stream
```

Better to attach per-stream handlers:

```csharp
ps.Streams.Error.DataAdded += (_, e) => Send(scriptId, "error", FormatRecord(ps.Streams.Error[e.Index]));
ps.Streams.Warning.DataAdded += ...
ps.Streams.Verbose / Debug / Progress similar
ps.Streams.Output.DataAdded += (_, e) => Send(scriptId, "output", Format(ps.Streams.Output[e.Index]));
```

Format function:

```csharp
private static string Format(PSObject o) => o?.BaseObject is string s ? s : o?.ToString() ?? "";
```

Cancel: in agent `_connection.On<string>(HubMethods.CancelScript, id => { if (_running.TryGetValue(id, out var ps)) ps.Stop(); });`

`ps.Stop()` from another thread — yes documented.

After invoke completes: remove from running, compute exit code, send completed. Handle `PipelineStoppedException` -> report cancelled.

Timeout option: add config `DefaultTimeoutMinutes`, create CTS, register `ps.Stop()`; catch. Maybe include as optional lines. Might be too much; I'll mention in "ideas to extend".

Also make sure event handler closures don't fire after completion — fine.

One subtlety: `ps.InvokeAsync()` with DataAdded streaming: events fire on background threads as items arrive. Works.

**Server hub script output:**

```csharp
public Task ScriptOutput(string scriptId, string kind, string text)
    => Task.Run(() => _runs.Append(scriptId, kind, text));
```

Actually just call synchronously: `_runs.Append(scriptId, kind, text); return Task.CompletedTask;`

The ScriptRun event invokes UI handler -> `InvokeAsync(StateHasChanged)`. Blazor's InvokeAsync from non-UI thread is fine (it marshals to renderer sync context).

**Projects/csproj listings:**

Shared:
```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>
```

Web csproj: net8.0, packages: none extra beyond framework (SignalR server is part of ASP.NET Core shared framework). Blazor Web App template references... For .NET 8 Blazor Web App (Server), the SDK `Microsoft.NET.Sdk.Web` includes SignalR. Good.

Agent csproj:
```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    ...
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.*" />
    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="8.0.*" />
    <PackageReference Include="Microsoft.PowerShell.SDK" Version="7.4.*" />
    <PackageReference Include="Microsoft.Extensions.Hosting.Systemd" ... optional
  </ItemGroup>
</Project>
```

Note: Microsoft.PowerShell.SDK is heavy (~ tens of MB) but fine.

**Files to present:**

1. Solution layout overview + architecture diagram (ASCII)
2. Shared project files
3. Web: Program.cs, AgentRegistry.cs, ScriptRunStore.cs, AgentHub.cs, Pages (Agents.razor, RunScript.razor), App.razor/Routes minimal
4. Agent: Program.cs, AgentWorker.cs, appsettings.json
5. Run instructions
6. Security + production hardening notes
7. Possible enhancements

This is a big answer; the user asked "write a blazor web app..." — they want the code. Length will be long but necessary. I should keep each file tight, avoid boilerplate bloat. Skip components/layout niceties; use the default template files but I need to include the minimum: Program.cs, App.razor, Routes.razor, and the two pages. I can tell them to create from template `dotnet new blazor -n BlazorPowerShell.Web --interactivity Server` (in .NET 8 the template is `dotnet new blazor` with options `-int Server`?). The .NET 8 template: `dotnet new blazor --interactivity Server` produces "Blazor Web App" with global server interactivity. Then they replace/add files. That saves including Layout/Routes boilerplate. But to make it self-contained and copy-pasteable, including Routes/App minimal might help. Hmm. Template creation + "add these files" instructions is the cleanest: fewer files, less error-prone. I'll instruct to scaffold with the template and then replace/add files, listing exactly which.

For pages, the template's sample pages (Counter, Weather) can be deleted.

Let me now write all the code carefully, checking API correctness.

**AgentHub with IHubContext injected into pages:** `@inject IHubContext<AgentHub> Hub` — need `@using Microsoft.AspNetCore.SignalR`. Yes.

**ScriptRunStore implementation:**

```csharp
public sealed class ScriptRunStore
{
    private readonly ConcurrentDictionary<string, ScriptRun> _runs = new();

    public ScriptRun Create(string agentConnectionId, string script)
    {
        var run = new ScriptRun(agentConnectionId, script);
        _runs[run.ScriptId] = run;
        return run;
    }

    public ScriptRun? Get(string scriptId) =>
        _runs.TryGetValue(scriptId, out var run) ? run : null;

    public void Append(string scriptId, string kind, string text) =>
        Get(scriptId)?.OnOutput(kind, text);

    public void Complete(string scriptId, int? exitCode, string? error) =>
        Get(scriptId)?.OnCompleted(exitCode, error);
}
```

ScriptRun:

```csharp
public sealed class ScriptRun
{
    public string ScriptId { get; } = Guid.NewGuid().ToString("N");
    public string AgentConnectionId { get; }
    public string Script { get; }
    public DateTimeOffset StartedAtUtc { get; } = DateTimeOffset.UtcNow;
    public int? ExitCode { get; private set; }
    public string? Error { get; private set; }
    public bool IsComplete { get; private set; }

    private readonly List<ScriptOutputLine> _lines = [];
    public IReadOnlyList<ScriptOutputLine> Lines => _lines;

    public event Action<ScriptOutputLine>? LineReceived;
    public event Action? Completed;

    public ScriptRun(string agentConnectionId, string script)
    {
        AgentConnectionId = agentConnectionId;
        Script = script;
    }

    internal void OnOutput(string kind, string text)
    {
        lock (_lines)
        {
            _lines.Add(new ScriptOutputLine(kind, text));
        }
        LineReceived?.Invoke(new ScriptOutputLine(kind, text));
    }

    internal void OnCompleted(int? exitCode, string? error)
    {
        if (IsComplete) return;
        ExitCode = exitCode;
        Error = error;
        IsComplete = true;
        Completed?.Invoke();
    }
}
```

`List<ScriptOutputLine> _lines = [];` — C# 12 collection expression works for List. .NET 8 = C# 12. OK.

Note: `lock (_lines)` then raising event outside lock — good.

ScriptOutputLine record in Shared:

```csharp
public record ScriptOutputLine(string Kind, string Text);
```

**AgentRegistry:**

```csharp
public sealed record AgentInfo(
    string ConnectionId, string MachineName, string UserName,
    string OsDescription, string AgentVersion, DateTimeOffset ConnectedAtUtc);

public sealed class AgentRegistry
{
    private readonly ConcurrentDictionary<string, AgentInfo> _agents = new();

    public event Action? Changed;

    public void AddOrUpdate(AgentInfo info)
    {
        _agents[info.ConnectionId] = info;
        Changed?.Invoke();
    }

    public void Remove(string connectionId)
    {
        if (_agents.TryRemove(connectionId, out _)) Changed?.Invoke();
    }

    public IReadOnlyCollection<AgentInfo> All => _agents.Values.ToArray();

    public AgentInfo? Find(string connectionId) =>
        _agents.TryGetValue(connectionId, out var a) ? a : null;
}
```

**AgentHub:**

```csharp
public sealed class AgentHub : Hub
{
    private readonly AgentRegistry _agents;
    private readonly ScriptRunStore _runs;
    private readonly IConfiguration _config;
    private readonly ILogger<AgentHub> _logger;

    public AgentHub(...) { ... }

    public override Task OnConnectedAsync()
    {
        var requiredKey = _config["AgentAuth:Key"];
        if (!string.IsNullOrEmpty(requiredKey))
        {
            var provided = Context.GetHttpContext()?.Request.Headers["X-Agent-Key"].ToString();
            if (!string.Equals(provided, requiredKey, StringComparison.Ordinal))
            {
                _logger.LogWarning("Rejected agent connection {ConnectionId}: bad key", Context.ConnectionId);
                Context.Abort();
            }
        }
        return base.OnConnectedAsync();
    }

    public Task RegisterAgent(AgentRegistration registration)
    {
        _agents.AddOrUpdate(new AgentInfo(
            Context.ConnectionId,
            registration.MachineName,
            registration.UserName,
            registration.OsDescription,
            registration.AgentVersion,
            DateTimeOffset.UtcNow));
        return Task.CompletedTask;
    }

    public Task ScriptOutput(string scriptId, string kind, string text)
    {
        _runs.Append(scriptId, kind, text);
        return Task.CompletedTask;
    }

    public Task ScriptCompleted(string scriptId, int? exitCode, string? error)
    {
        _runs.Complete(scriptId, exitCode, error);
        return Task.CompletedTask;
    }

    public override Task OnDisconnectedAsync(Exception? exception)
    {
        _agents.Remove(Context.ConnectionId);
        return base.OnDisconnectedAsync(exception);
    }
}
```

Note: `Context.Abort()` then returning base.OnConnectedAsync — ok.

**RunScript.razor:**

```razor
@page "/run"
@using Microsoft.AspNetCore.SignalR
@using BlazorPowerShell.Shared
@using BlazorPowerShell.Web.Hubs
@using BlazorPowerShell.Web.Services
@inject IHubContext<AgentHub> Hub
@inject AgentRegistry Agents
@inject ScriptRunStore Runs
@inject IJSRuntime JS
@implements IDisposable
@rendermode InteractiveServer

<PageTitle>Run PowerShell</PageTitle>

<h3>Run PowerShell on an agent</h3>

<div class="row g-3">
  <div class="col-md-4">
    <label class="form-label">Agent</label>
    <select class="form-select" @bind="_selectedConnectionId">
      <option value="" disabled selected>Choose an agent…</option>
      @foreach (var a in _agentsList)
      {
        <option value="@a.ConnectionId">@a.MachineName (@a.UserName) — @a.ConnectedAtUtc.ToString("HH:mm:ss")</option>
      }
    </select>
  </div>
</div>

<label class="form-label mt-3">Script</label>
<textarea class="form-control font-monospace" rows="10" @bind="_script" spellcheck="false">


  
  



  
    @foreach line
  

```

Code:

```csharp
@code {
    private List _agentsList = [];
    private string? _selectedConnectionId;
    private string _script = "Get-Process | Select-Object -First 5";
    private bool _running;
    private ScriptRun? _currentRun;
    private ElementReference _consoleEl;
    private bool _dirtyConsole;

    protected override void OnInitialized()
    {
        Agents.Changed += OnAgentsChanged;
        RefreshAgents();
    }

    private void OnAgentsChanged() => InvokeAsync(RefreshAgents);
    private void RefreshAgents()
    {
        _agentsList = Agents.All.OrderByDescending(a => a.ConnectedAtUtc).ToList();
        if (_selectedConnectionId is not null && _agentsList.All(a => a.ConnectionId != _selectedConnectionId))
            _selectedConnectionId = null;
        StateHasChanged();
    }

    private async Task Run()
    {
        var agent = Agents.Find(_selectedConnectionId!);
        if (agent is null) return;

        _currentRun = Runs.Create(agent.ConnectionId, _script);
        _currentRun.LineReceived += OnLine;
        _currentRun.Completed += OnCompleted;
        _running = true;

        await Hub.Clients.Client(agent.ConnectionId)
            .SendAsync(HubMethods.RunScript, _currentRun.ScriptId, _script);
        StateHasChanged();
    }

    private void OnLine(ScriptOutputLine line) { _dirtyConsole = true; InvokeAsync(StateHasChanged); }
    private void OnCompleted() => InvokeAsync(StateHasChanged);

    private async Task Cancel()
    {
        if (_currentRun is null) return;
        await Hub.Clients.Client(_currentRun.AgentConnectionId)
            .SendAsync(HubMethods.CancelScript, _currentRun.ScriptId);
    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (_dirtyConsole)
        {
            _dirtyConsole = false;
            await JS.InvokeVoidAsync("window.psConsole.scrollToBottom", _consoleEl);
        }
    }

    public void Dispose()
    {
        Agents.Changed -= OnAgentsChanged;
        if (_currentRun is not null)
        {
            _currentRun.LineReceived -= OnLine;
            _currentRun.Completed -= OnCompleted;
        }
    }
}
```

Wait: `OnLine` sets _dirtyConsole and StateHasChanged; AfterRender scrolls. Fine. Also the `pre` markup: render lines with color classes:

```razor
@if (_currentRun is null)
{
    // Select an agent and run a script
}
else
{
    foreach line:
    @line.Text
}

```

In razor inside pre, need careful whitespace handling. Write:

```razor
@if (_currentRun is not null)
{
    foreach (var line in _currentRun.Lines)
    {
        @line.Text

    }
    ...
}

```

Newline inside span text: simpler to output `@line.Text` then rely on `white-space: pre` on the container and each span being a block? If spans are inline, lines run together. Make `.console .ln { display: block; }` and put text with `@line.Text` — but then trailing newline? display:block handles line breaks visually. Good: CSS `.console { max-height: 400px; overflow-y: auto; } .ln { display: block; white-space: pre-wrap; }`. And classes: `.ln.err { color:#ff6b6b } .ln.warn { color:#ffd43b } .ln.info { color:#8ce99a }` etc. Add CSS to app.css. I'll provide the CSS snippet.

Kind mapping: "out", "err", "warn", "info", "prog", "sys". Keep Kinds: out/err/warn/verbose/progress. And from server: "sys" for "connected/finished". Let me define constants in Shared? Just strings; keep simple.

**Agents.razor page:**

```razor
@page "/agents"
@implements IDisposable
@rendermode InteractiveServer
@inject AgentRegistry Agents

Connected agents
@if (!_agentsList.Any()) { No agents connected. Start the agent and it will appear here. }

 ... MachineName, User, OS, version, connected


@code {
    private IReadOnlyCollection _agentsList = Array.Empty();
    protected override void OnInitialized() { Agents.Changed += OnChanged; _agentsList = Agents.All; }
    private void OnChanged() => InvokeAsync(() => { _agentsList = Agents.All; StateHasChanged(); });
    public void Dispose() => Agents.Changed -= OnChanged;
}
```

Nav menu: tell them to edit NavMenu.razor to add links (or include a small snippet).

**App.razor + script:**

The .NET 8 template's App.razor already includes a ``. I just need them to add:

```html

```

in App.razor head/body. I'll note "add this before the blazor.web.js script" — anywhere in body after is fine too. Provide snippet and instructions.

Also Routes.razor from template is fine as-is.

**Program.cs (web):**

```csharp
using BlazorPowerShell.Web.Components;
using BlazorPowerShell.Web.Hubs;
using BlazorPowerShell.Web.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

builder.Services.AddSignalR();

builder.Services.AddSingleton();
builder.Services.AddSingleton();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseAntiforgery();

app.MapRazorComponents()
    .AddInteractiveServerRenderMode();

app.MapHub("/hubs/agent");

app.Run();
```

That matches .NET 8 template structure.

**Agent Program.cs:**

```csharp
using BlazorPowerShell.Agent;

var builder = Host.CreateApplicationBuilder(args);

// Windows service / systemd support (optional)
builder.Services.AddWindowsService(o => o.ServiceName = "BlazorPowerShellAgent");

builder.Services.AddHostedService();

builder.Build().Run();
```

Hmm — `AddWindowsService` requires `Microsoft.Extensions.Hosting.WindowsServices` package. Include the package and one line; it's harmless on Linux (it no-ops? Actually AddWindowsService is safe to call on non-Windows — it just won't activate unless running as a service; per docs it "sets up the host to run as a Windows service" — calling on Linux is fine, it checks runtime). Yes, `AddWindowsService` is safe cross-platform (it no-ops if not on Windows... let me recall: `UseWindowsService()` docs: "calling this method on non-Windows is safe/no-op"). Yes, documented: "This method is safe to call on non-Windows platforms." Good, keep it. Also add `AddSystemd()`? That requires package too. To keep it lean, mention both in csproj comment or just include WindowsServices only and mention systemd package in notes. Actually I'll include both lines with packages — production agents usually run as services. Hmm, extra packages: `Microsoft.Extensions.Hosting.WindowsServices` and `Microsoft.Extensions.Hosting.Systemd`. Both small. Include both; safe cross-platform.

**AgentWorker.cs:**

```csharp
using System.Collections.Concurrent;
using System.Management.Automation;
using BlazorPowerShell.Shared;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Extensions.Hosting; // implicit usings may cover

namespace BlazorPowerShell.Agent;

public sealed class AgentWorker : BackgroundService
{
    private readonly AgentOptions _options;
    private readonly ILogger _logger;
    private readonly ConcurrentDictionary _running = new();
    private readonly SemaphoreSlim _sendGate = new(1, 1);
    private HubConnection? _connection;

    public AgentWorker(IOptions options, ILogger logger)
    {
        _options = options.Value;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                _connection = new HubConnectionBuilder()
                    .WithUrl(new Uri(_options.HubUrl), http =>
                    {
                        http.Headers["X-Agent-Key"] = _options.ApiKey;
                    })
                    .WithAutomaticReconnect(new[] { TimeSpan.Zero, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(30) })
                    .Build();

                _connection.On(HubMethods.RunScript, RunScriptAsync);
                _connection.On(HubMethods.CancelScript, CancelScript);
                _connection.Reconnected += _ => RegisterAsync();
                _connection.Closed += ex => { _logger.LogWarning(ex, "Connection closed"); return Task.CompletedTask; };

                await _connection.StartAsync(stoppingToken);
                await RegisterAsync();

                _logger.LogInformation("Agent connected to {HubUrl}", _options.HubUrl);

                await Task.Delay(Timeout.Infinite, stoppingToken); // keep worker alive; connection events do the work
            }
            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) { break; }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Connection failed — retrying in 5s");
                await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
            }
        }
    }
```

Hmm — with WithAutomaticReconnect, after connection drops it reconnects automatically and `Reconnected` re-registers. But if StartAsync throws initially (server down), the loop retries — but then we rebuild the connection each time. That's OK. But once started successfully, we block in Task.Delay forever; automatic reconnect handles drops. However if the hub is restarted, WithAutomaticReconnect will keep trying? Automatic reconnect only retries up to the retry policy durations then gives up (goes to Closed). After Closed with automatic reconnect exhausted, it stops. So better to loop: after Task.Delay or Closed, dispose and recreate. Simpler robust pattern: inner loop waiting on Task.Delay(Infinite) won't notice Closed. Alternative: rely on reconnect and if it eventually closes, restart loop. Let me structure:

```csharp
await _connection.StartAsync(stoppingToken);
await RegisterAsync();
_logger.LogInformation(...);

// Wait until the connection closes (reconnect handled by WithAutomaticReconnect).
var closedTcs = new TaskCompletionSource();
_connection.Closed += _ => { closedTcs.TrySetResult(); return Task.CompletedTask; };
await closedTcs.Task.WaitAsync(stoppingToken);
// loop continues -> rebuild connection after short delay
await Task.Delay(TimeSpan.FromSeconds(2), stoppingToken);
```

Hmm wait — WithAutomaticReconnect fires Closed only after reconnect attempts exhausted? Actually: with automatic reconnect, when connection drops, it transitions to Reconnecting; if reconnect fails through all retries, it transitions to Closed. So waiting on Closed means "reconnect gave up", then we rebuild. During Reconnecting, Reconnected event re-registers. 

Also note RegisterAsync must be called after each Reconnected because new connection id. Yes we do.

One more subtlety: the `RunScriptAsync` handler is registered on the connection instance; when we rebuild, re-register handlers — we rebuild the whole HubConnection so `.On` calls happen again. Fine.

Actually simpler for the answer: keep my loop with Closed tcs. But careful: `RegisterAsync` invoked from Reconnected event handler while also doing initial register. OK.

Now RunScriptAsync:

```csharp
private async Task RunScriptAsync(string scriptId, string script)
{
    _logger.LogInformation("Running script {ScriptId} ({Length} chars)", scriptId, script.Length);

    var ps = PowerShell.Create();
    _running[scriptId] = ps;

    // Stream results back as they arrive.
    ps.Streams.Output.DataAdded += (_, e) => SendLineAsync(scriptId, "out", ToString(ps.Streams.Output[e.Index]));
    ps.Streams.Error.DataAdded   += (_, e) => SendLineAsync(scriptId, "err", ToString(ps.Streams.Error[e.Index]));
    ps.Streams.Warning.DataAdded += (_, e) => SendLineAsync(scriptId, "warn", ps.Streams.Warning[e.Index]?.Message ?? "");
    ps.Streams.Verbose.DataAdded += (_, e) => SendLineAsync(scriptId, "verbose", ps.Streams.Verbose[e.Index]?.Message ?? "");
    ps.Streams.Progress.DataAdded += (_, e) =>
    {
        var rec = ps.Streams.Progress[e.Index];
        SendLineAsync(scriptId, "prog", $"{rec?.Activity ?? "?"} — {rec?.StatusDescription ?? ""} ({rec?.PercentComplete ?? 0}%)");
    };

    try
    {
        ps.AddScript(script);
        await ps.InvokeAsync();  // events above already streamed the output

        // Use $LASTEXITCODE from the same runspace when available.
        ps.Commands.Clear();
        ps.Streams.ClearStreams();
        ps.AddScript("if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } else { 0 }");
        var exitCode = (await ps.InvokeAsync()).FirstOrDefault()?.BaseObject as int? ?? 0;

        await SendLineAsync(scriptId, "sys", $"Finished with exit code {exitCode}.");
        await _connection!.InvokeAsync(HubMethods.ScriptCompleted, scriptId, (int?)exitCode, (string?)null, CancellationToken.None);
    }
    catch (PipelineStoppedException)
    {
        await SendLineAsync(scriptId, "sys", "Cancelled.");
        await _connection!.InvokeAsync(HubMethods.ScriptCompleted, scriptId, (int?)null, "Cancelled", CancellationToken.None);
    }
    catch (Exception ex)
    {
        await SendLineAsync(scriptId, "err", ex.Message);
        await _connection!.InvokeAsync(HubMethods.ScriptCompleted, scriptId, (int?)1, ex.Message, CancellationToken.None);
    }
    finally
    {
        _running.TryRemove(scriptId, out _);
        ps.Dispose();
    }
}
```

Wait — issue: `ps.InvokeAsync()` — when Stop() is called, InvokeAsync completes with... PowerShell.Stop causes the pipeline to stop; InvokeAsync task completes (or throws PipelineStoppedException?). Behavior: calling Stop() causes the currently executing pipeline to stop; the async invoke's task transitions; you may get PipelineStoppedException on await? I believe `PowerShell.InvokeAsync` returns IAsyncEnumerable? No — `PowerShell.InvokeAsync()` (parameterless, PSDataCollection-based) returns `Task>`. Hmm: there are two: `InvokeAsync()` returns `Task>`, and `InvokeAsync(PSDataCollection output)`... Let me recall the PowerShell class API (System.Management.Automation):

- `public Task> InvokeAsync();` — yes this exists.
- `public IAsyncEnumerable InvokeAsyncEnumerable? ` — not in 7.4? There's `PowerShell.InvokeAsync()` returning Task. For streaming we use the DataAdded events on `ps.Streams.Output` or the returned collection. Since we attach to `ps.Streams.Output`, we don't need the returned collection. Actually careful: when calling parameterless `InvokeAsync()`, output is collected into an internal collection; events on `ps.Streams.Output` fire? Hmm. Is `ps.Streams.Output` (the stream's `PSDataCollection`) the same collection that gets appended? The `PSCommand` invocation with default host writes output to the returned collection, and the streams collections (`ps.Streams.Error` etc.) get events. For output: when using `PowerShell.Create()` + `AddScript` + `InvokeAsync()` without passing a collection, the output goes to an internal buffer returned in the task result. Does `ps.Streams.Output` receive DataAdded? 

Let me think. `PowerShell.Streams` property returns `PSDataStreams` containing Error, Warning, Verbose, Information, Debug, Progress collections. Output is NOT in Streams (Streams doesn't have Output!). Indeed — `PSDataStreams` has Error, Warning, Verbose, Information, Debug, Progress — no Output. Correct: output isn't a "stream" in that sense; it's the pipeline output.

So to stream output items, I need the returned PSDataCollection: `var output = await ps.InvokeAsync()` returns the full collection after completion. To stream: use the overload `ps.InvokeAsync(outputCollection)`? There is `public void Invoke(PSDataCollection output)`? Hmm. The async overloads: `PowerShell.InvokeAsync(PSDataCollection output)` returns `Task` and appends into the provided collection, firing DataAdded as items arrive. Let me recall System.Management.Automation.PowerShell methods:

- `BeginInvoke(PSDataCollection input, PSDataCollection output)` (APM)
- `EndInvoke(IAsyncResult)`
- `InvokeAsync()` → `Task>` — creates internal output collection.
- `InvokeAsync(PSDataCollection input, PSDataCollection output)` → `Task` — hmm, I think the generic async version exists: `public Task InvokeAsync(PSDataCollection input, PSDataCollection output)`? Not sure about generic; I recall `InvokeAsync(PSDataCollection output)`? 

Checking memory of the actual API: In System.Management.Automation (PS 7), class PowerShell has:
- `public Task> InvokeAsync()`
- `public Task> InvokeAsync()`? no...
- Actually there is: `public Task InvokeAsync(PSDataCollection input, PSDataCollection output)` — I'm fairly confident this exists (it was added with the async support in PowerShell Core). Let me verify by memory of docs page "PowerShell.InvokeAsync Method": lists InvokeAsync(), InvokeAsync(PSDataCollection, PSDataCollection). Yes, docs show those two overloads.

So streaming output:

```csharp
var output = new PSDataCollection();
output.DataAdded += (_, e) => SendLine(scriptId, "out", Format(ps[e.Index]));
var invokeTask = ps.InvokeAsync(null, output)?? 
```

Hmm — input collection: we have no input. Pass `null`? Docs: input can be null when command doesn't need input? For BeginInvoke you can pass null input. For InvokeAsync(PSDataCollection input, PSDataCollection output) — I think input null is acceptable? Safer: create empty input collection and Complete() it? An empty non-completed input collection would block? Input collection semantics: if null, no stdin; if provided, pipeline reads until collection Completed/Closed. Passing an empty collection that is never completed might cause the pipeline to wait for input? For a script with no `param`/`$input` usage, probably fine, but risky.

Alternative simpler approach: use parameterless `InvokeAsync()` and stream output by attaching DataAdded to the *returned* collection before awaiting? But parameterless InvokeAsync creates the collection internally and returns it only when complete. So can't attach.

Alternative: use `ps.AddScript(...)` then `var psObjects = await Task.Run(() => ps.Invoke())` synchronous within background task — no streaming.

Better alternative: wrap user script with `| ForEach-Object { $_ | Out-String }`? No.

Cleanest documented approach: `PSDataCollection output = new(); output.DataAdded += ...; ps.InvokeAsync(output)`? Is there an overload taking just output? I genuinely recall there IS: `public Task InvokeAsync(PSDataCollection output)`? Hmm... Let me think about the actual signatures in System.Management.Automation.dll (PowerShell 7.4). The PowerShell class async methods:

From reference source (Microsoft.PowerShell.Commands.Utility... no, engine): `public partial class PowerShell`:
- `public Task> InvokeAsync()`
- `public Task InvokeAsync(PSDataCollection output)`? 

I remember reading GitHub issues about streaming with InvokeAsync: common pattern:

```csharp
PSDataCollection outputCollection = new();
ps.AddScript(script);
var task = ps.InvokeAsync(outputCollection);  // hmm?
```

Hmm, actually I recall the docs for `PowerShell.InvokeAsync` listing:
- `InvokeAsync()` — Returns `Task>`
- `InvokeAsync(PSDataCollection input, PSDataCollection output)` — Returns `Task`

Yes, I'm fairly confident these two exist. Microsoft Learn page "PowerShell.InvokeAsync Method (System.Management.Automation)" shows exactly these two overloads. 

So use:

```csharp
var output = new PSDataCollection();
output.DataAdded += (_, e) => SendLine(scriptId, "out", FormatRecord(output[e.Index]));
await ps.InvokeAsync(null, output);
```

Hmm, `ps.InvokeAsync(null, output)` — TInput can be inferred? With null input, type inference fails, so specify explicitly. `PSObject` as TOutput. Hmm, does passing null input work? In the reference source, `InvokeAsync(PSDataCollection input, PSDataCollection output)`:

```csharp
public Task InvokeAsync(PSDataCollection input, PSDataCollection output)
{
    if (output == null) throw new ArgumentNullException(nameof(output));
    return InvokeAysncHelper... creates AsyncResult, calls BeginInvoke(input, output)...
}
```

BeginInvoke accepts null input (documented: "input can be null"). I believe it's fine.

Hmm wait, actually maybe I'm wrong about needing input; maybe signature is `InvokeAsync(PSDataCollection output)` non-generic too. To dodge uncertainty, alternative approach that definitely works and is simpler:

Use the parameterless `InvokeAsync()` but redirect the user's script output into the Information/verbose? No.

Another rock-solid approach: run the script synchronously on a background thread and stream via a proxy? Overkill.

Alternative widely-used approach: instead of streaming raw output objects, have the agent append an `Out-String -Stream`-like transform by adding a second script block? Complicated.

OK here's another robust and simple approach I've seen in many samples:

```csharp
var ps = PowerShell.Create();
ps.AddScript(script);

var output = new PSDataCollection();
output.DataAdded += (_, e) => SendLine(scriptId, "out", Format(output[e.Index]));

await ps.InvokeAsync(output); // if this overload exists
```

Let me settle this. Searching memory: learn.microsoft.com/en-us/dotnet/api/system.management.automation.powershell.invokeasync — Overloads table:
- `InvokeAsync()` → Task> "Executes the pipeline... asynchronously"
- `InvokeAsync(PSDataCollection, PSDataCollection)` → Task

I'm now quite sure only these two exist (no output-only overload). So:

```csharp
var output = new PSDataCollection();
output.DataAdded += (sender, e) => { ... };
await ps.InvokeAsync(null, output);
```

Wait, generic args: `TInput` — passing null. C# nullable: `null` with `object?` type param OK.

Hmm, but is `TInput` = object? fine? BeginInvoke with null input ignores it. OK.

Alternatively avoid generics by `ps.Commands.Clear(); var input = new PSDataCollection

PowerShell Executer