From 8e4c014ff357aff1e3c3ecbc811fffdef61d2733 Mon Sep 17 00:00:00 2001 From: Aaron Stannard Date: Thu, 16 Jul 2026 15:36:08 +0000 Subject: [PATCH 1/4] openspec: propose mcp-shutdown-teardown change (#1667) --- .../mcp-shutdown-teardown/.openspec.yaml | 2 + .../changes/mcp-shutdown-teardown/design.md | 249 ++++++++++++++++++ .../changes/mcp-shutdown-teardown/proposal.md | 94 +++++++ .../specs/netclaw-mcp/spec.md | 55 ++++ .../changes/mcp-shutdown-teardown/tasks.md | 20 ++ 5 files changed, 420 insertions(+) create mode 100644 openspec/changes/mcp-shutdown-teardown/.openspec.yaml create mode 100644 openspec/changes/mcp-shutdown-teardown/design.md create mode 100644 openspec/changes/mcp-shutdown-teardown/proposal.md create mode 100644 openspec/changes/mcp-shutdown-teardown/specs/netclaw-mcp/spec.md create mode 100644 openspec/changes/mcp-shutdown-teardown/tasks.md diff --git a/openspec/changes/mcp-shutdown-teardown/.openspec.yaml b/openspec/changes/mcp-shutdown-teardown/.openspec.yaml new file mode 100644 index 000000000..cd2ce7e9f --- /dev/null +++ b/openspec/changes/mcp-shutdown-teardown/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-07-16 diff --git a/openspec/changes/mcp-shutdown-teardown/design.md b/openspec/changes/mcp-shutdown-teardown/design.md new file mode 100644 index 000000000..d2f752af7 --- /dev/null +++ b/openspec/changes/mcp-shutdown-teardown/design.md @@ -0,0 +1,249 @@ +## Context + +`McpClientManager` is registered as an `IHostedService` (and singleton +`IMcpReconnectable`) before `services.AddAkka(...)` in +`ConfigureDaemonServices` (`src/Netclaw.Daemon/Program.cs`). .NET's generic +host stops hosted services in reverse registration order (LIFO). Akka's own +hosted service (`Akka.Hosting.AkkaHostedService`, registered internally by +`AddAkka`) is therefore stopped *before* `McpClientManager`. Its `StopAsync` +override does not consult the `CancellationToken` it's given — it always +awaits `CoordinatedShutdown.Run(...)` to natural completion: + +```csharp +public virtual async Task StopAsync(CancellationToken cancellationToken) +{ + if (CoordinatedShutdown == null) return; + await CoordinatedShutdown.Run(CoordinatedShutdown.ClrExitReason.Instance) + .ConfigureAwait(false); +} +``` + +`CoordinatedShutdown`'s `before-service-unbind` phase is where +`drain-llm-sessions` runs (`Program.cs` ~1071), bounded to +`DaemonConfig.BoundedDrainTimeout` (190s, per #1673) but not shorter than +that by design — sessions mid-LLM-call need room to finish. Only once that +phase (and the rest of `CoordinatedShutdown`) completes does +`AkkaHostedService.StopAsync` return, unblocking the host's stop sequence to +reach `McpClientManager.StopAsync`. Today that method disposes clients with a +plain `foreach` + `await` — sequential, not parallel — each client's SDK +dispose being a graceful wait then a process-tree kill (10s + 10s per +server). `McpReconnectionService` (a `BackgroundService` registered +immediately after `McpClientManager`) polls every 30s and calls +`TryReconnectAsync` for any server in `Unreachable` state; because it too +sits before `AddAkka` in registration order, its own `StopAsync` (which +cancels its `stoppingToken`) doesn't fire until after `AkkaHostedService` +stops — so it keeps ticking, and could reconnect (launching a new child +process) for the entire ~190s drain window, independent of this change. + +MCP server state was established as daemon-scoped (not session-isolated) by +#1636 (`2026-07-14-make-stdio-mcp-process-bound`); that change's design.md +explicitly deferred shutdown-sequencing changes as out of scope. This design +picks that up. + +## Goals / Non-Goals + +**Goals:** + +- Start MCP child-process teardown as early in the shutdown sequence as the + host lifecycle allows, so it runs concurrently with session drain instead + of strictly after the full Akka `CoordinatedShutdown` completes. +- Make teardown idempotent so it is safe to trigger from an early hook and + still let the existing `IHostedService.StopAsync`/`IDisposable.Dispose` + path run unconditionally afterward. +- Close the reconnect-during-shutdown gap: once teardown starts, no code + path (invocation retry, or `McpReconnectionService`'s poll) may create a + new client or child process. +- Bound total MCP teardown time by the slowest single server, not the sum + across configured servers. +- Preserve the existing clean-tool-error behavior for a tool call that loses + its transport mid-flight — this already exists at the `McpToolAdapter` + layer and needs no new plumbing, only confirmation it still applies. + +**Non-Goals:** + +- Lazy/on-demand MCP process startup or idle-process reclamation. +- Per-session MCP process isolation. +- Any change to `HostOptions.ShutdownTimeout`, `DaemonConfig.*ShutdownBudget*`, + or the Akka `before-service-unbind` phase timeout — those stay exactly as + #1673 left them. This change only moves *when MCP teardown starts* + relative to those existing budgets, not the budgets themselves. +- Solving the CLI force-kill orphan gap from inside the daemon (see Risks). +- Changing the per-client SDK dispose timing (10s graceful + 10s kill) or the + `StdioClientTransportOptions.ShutdownTimeout` value. + +## Decisions + +### Trigger teardown from `IHostApplicationLifetime.ApplicationStopping` + +The generic host fires `ApplicationStopping` at the very start of +`Host.StopAsync`, before any hosted service's `StopAsync` is invoked +(including `AkkaHostedService`'s). Registering a callback there +(`appLifetime.ApplicationStopping.Register(...)`, or an +`ApplicationStopping.Register` wired in during DI setup) gives +`McpClientManager` a shutdown signal that fires regardless of which hosted +service stops first, and regardless of hosted-service registration order — +so this fix does not depend on reordering `McpClientManager`'s or `AddAkka`'s +registration (a more fragile change that would need re-verifying on every +future service addition). + +`ApplicationStopping` also fires for every shutdown path that calls +`IHostApplicationLifetime.StopApplication()` or lets the host observe +SIGTERM/Ctrl-C — including the `daemon stop` graceful path and the config-reload +restart path (`DaemonRestartCoordinator`) — so this is a single hook, not one +more of several call sites to keep in sync. + +Alternative considered: reorder hosted-service registration so +`McpClientManager` stops before `AkkaHostedService`. Rejected — LIFO ordering +is implicit and easy to silently break with a future registration reorder; +`ApplicationStopping` is an explicit, order-independent signal for exactly +this purpose. + +### Idempotent teardown via a shared, memoized operation + +`McpClientManager` gains one internal `TeardownAsync()` that both the new +`ApplicationStopping` callback and the existing `StopAsync`/`Dispose` route +through. The first caller performs the real work (disposes each client, +clears `_clients`/`_sharedToolFunctions`); it also sets a `Volatile` +`_stopping` flag (see next decision) synchronously, before any awaits, so a +racing second call can observe it immediately. The teardown work itself is +memoized behind a single cached `Task` so a second caller awaits the same +completion instead of redoing (or racing) disposal — this is the same +"first caller does the work, others await it" shape already used for +one-time async initialization elsewhere in the codebase, applied here to +one-time async teardown. + +This means `StopAsync` (still called by the host afterward, since removing +the `IHostedService` registration is not proposed — the host's own lifecycle +guarantees are worth keeping as a backstop) becomes a no-op await on already- +completed work in the common case, and the log line for "MCP client shut +down" is only emitted once, by whichever call actually performed the +dispose. + +Alternative considered: guard with `Interlocked.CompareExchange` on a bool and +skip entirely on the second call without awaiting anything. Rejected — +if `ApplicationStopping`'s teardown is still in flight when `StopAsync` runs +(a real possibility, since `StopAsync` can be reached quickly if other +hosted services stop fast), a bare skip would let `StopAsync` return before +disposal is actually complete, which could race the process exit against +still-running child-process kills. Awaiting the same memoized task avoids +that. + +### Stopping flag gates `ConnectAsync`/`TryReconnectAsync` + +`ConnectAsync` and `TryReconnectAsync` both check the same `_stopping` flag +set by teardown and return `false`/no-op immediately if set, before touching +the transport or spawning a process. This is the single choke point both +existing reconnect callers go through: + +- `InvokeSharedAsync`'s failure-recovery path (a tool call whose function + invocation throws attempts `TryReconnectAsync` before surfacing the + error) — during shutdown, the exception it's recovering from may be the + very disposal this change introduces; without the guard, that recovery + path would spin up a brand-new child process seconds before the daemon + exits. +- `McpReconnectionService`'s periodic poll — already able to run for the + full drain window today (see Context); the guard closes this off as a + side effect without requiring any change to that service itself, keeping + this change scoped to `McpClientManager`. + +Alternative considered: only guard `McpReconnectionService` (e.g., stop its +background loop from the same `ApplicationStopping` hook). Rejected — that +leaves the tool-call retry path unguarded, and duplicates the "are we +shutting down" signal into a second place instead of one shared flag in the +component that already owns client lifecycle. + +### Parallel per-server teardown + +`TeardownAsync()` disposes all clients via a `Task.WhenAll` projection +instead of the current sequential `foreach` + `await`. Each server's dispose +keeps its own try/catch so one server's disposal failure doesn't prevent or +delay others' (matching today's per-iteration try/catch, just no longer +serialized). With `N` configured servers this bounds total MCP teardown +latency at roughly the slowest single dispose (~20s worst case) instead of +`N × 20s` — meaningful once `ApplicationStopping` makes MCP teardown a +concurrent, budget-competing activity alongside session drain rather than an +afterthought that ran once the drain had already finished. + +Alternative considered: leave teardown sequential since it now starts +earlier and usually has more elapsed time to work with. Rejected — "usually" +is exactly the kind of soft guarantee the #1664/#1665 postmortems warned +against; a deployment with several configured MCP servers and a slow drain +could still exhaust the remaining budget under sequential disposal, and +parallelizing is a small, low-risk, independently testable change. + +### In-flight tool call failure path: no new plumbing required + +`McpToolAdapter.ExecuteAsync` already wraps `_invoker.InvokeAsync(...)` in a +try/catch that converts any exception into +`"Error: MCP tool '{Name}' failed: {ex.Message}"` — a clean, attributed tool +result, not a hang or an unhandled fault. When teardown disposes a client +that has an in-flight call, the SDK's own graceful-then-kill dispose timeline +determines how soon that call's underlying transport read/write faults; that +fault propagates through `InvokeSharedAsync` → `McpToolAdapter.ExecuteAsync` +into the existing clean-error path unchanged. This satisfies the "no silent +fallback" bar (the session sees a loud, attributed error) without adding any +new exception handling. The bound on "how soon" is inherited from the +existing per-client SDK dispose timeout, not newly introduced by this +change — see Risks for why that upper bound (not the guaranteed lower bound) +is what we can actually promise here. + +### Force-kill orphan gap: not solved from inside the daemon + +The `netclaw daemon stop` force-kill path (#1665's `CliForceKillBudget` +escalation) sends `SIGKILL` to the main daemon PID from the CLI process. A +`SIGKILL` is not observable by the target process — nothing inside the +daemon, including this change's `ApplicationStopping` hook, ever runs, because +`ApplicationStopping` requires a graceful stop signal (SIGTERM or an explicit +`StopApplication()` call) to reach the host in the first place. The only +things that can reap the orphaned MCP child tree in that case are external to +the daemon process: systemd's cgroup-wide kill on unit stop (already covers +systemd-managed installs), or an external supervisor doing the same. In a +non-systemd deployment (bare `netclawd`, container entrypoint without a +process-group reaper, manual dev shell), a force-killed daemon still orphans +its MCP children after this change, exactly as it does today. This change +narrows the *window* in which force-kill is reached at all (graceful teardown +now finishes sooner, so fewer stops escalate to force-kill in practice) but +does not close the gap once force-kill happens. CLI-side child-PID tracking +(the CLI recording and killing MCP child PIDs itself) could close this +residual gap; it is out of scope here per the proposal and noted for future +work. + +## Risks / Trade-offs + +- **In-flight call failure timing is inherited, not new** → We bound "when + does an in-flight call fail" by the same SDK dispose timeout that already + exists (10s graceful + 10s kill per server), not something this change + invents. If that upper bound proves too slow in practice (e.g., a session + actor's own turn timeout is shorter and fires first, which is fine and + independent), tightening it is a follow-up, not part of this change. +- **Idempotency race is real, not hypothetical** → `ApplicationStopping` and + the host's normal hosted-service stop sequence can both reach + `McpClientManager` in a short window on a fast shutdown. The memoized-task + design (see Decisions) is chosen specifically so both paths converge on one + completion instead of a bare double-dispose or a skip that returns before + work is done. This is exactly the kind of concurrency detail that should be + scrutinized in review and covered by a real (not simulated) double-teardown + test using `McpSmokeHarness`'s spawned child processes. +- **Guarding reconnect could mask a legitimate late reconnect need** → + Once teardown starts there is no legitimate reason to reconnect (the daemon + is exiting), so returning `false`/failing fast is correct; the risk is + narrow (making sure the guard only engages once teardown has actually + begun, not preemptively during normal operation). +- **Residual non-systemd force-kill orphan gap remains** → Documented above + rather than glossed over; systemd-managed installs are covered by the + existing cgroup sweep, and this change reduces how often force-kill is + reached, but does not eliminate the gap for non-systemd deployments. + CLI-side child-PID tracking is the follow-up that would close it, called + out as future work, not silently implied as solved. + +## Migration Plan + +No configuration or persisted-state migration. Deploying this change moves +*when* MCP teardown starts and *how* per-server disposal is scheduled; +external behavior (schema, tool names, grants) is unchanged. Rollback +restores the prior strictly-sequenced, sequential-per-server teardown with no +data implications either direction. + +## Open Questions + +None for this change. diff --git a/openspec/changes/mcp-shutdown-teardown/proposal.md b/openspec/changes/mcp-shutdown-teardown/proposal.md new file mode 100644 index 000000000..14750478d --- /dev/null +++ b/openspec/changes/mcp-shutdown-teardown/proposal.md @@ -0,0 +1,94 @@ +## Why + +Stdio MCP child processes are only torn down by `McpClientManager.StopAsync` +(`src/Netclaw.Daemon/Mcp/McpClientManager.cs:73-90`), which is registered as an +`IHostedService` before `AddAkka`. .NET's LIFO hosted-service stop ordering +means `AkkaHostedService.StopAsync` runs first, and it awaits +`CoordinatedShutdown.Run()` to full completion while ignoring the host's +shutdown `CancellationToken` (`Akka.Hosting.AkkaHostedService.StopAsync`). +Session drain (`SessionDrainHelper.DrainAsync`, bounded to +`DaemonConfig.BoundedDrainTimeout` = 190s by #1673) therefore consumes nearly +all of the shutdown budget before `McpClientManager.StopAsync` gets to run at +all — and today's per-server teardown there is sequential (10s graceful + 10s +kill wait, per configured server), so with multiple servers it can still +overrun whatever budget remains. The CLI force-kill path +(`netclaw daemon stop`, #1673) SIGKILLs only the main daemon PID, so +`McpClientManager.StopAsync`/`Dispose` never runs at all on that path — +orphaning the MCP child tree in any non-systemd deployment (container +entrypoint, manual `netclawd`, dev shell). Production evidence: idle +Playwright MCP children observed still alive 90+ seconds into a drain, +reaped only by systemd's cgroup sweep after the main PID was force-killed. + +#1673 fixed the two race conditions in the session-drain/CLI-kill budget +layering (#1664, #1665) but did not touch MCP teardown sequencing or ordering +— it is a distinct defect, tracked as #1667. The prior MCP ownership change +(#1636, `2026-07-14-make-stdio-mcp-process-bound`) explicitly preserved +shutdown behavior as out of scope; this change is the first to address it. + +Source issue: netclaw-dev/netclaw#1667. Related: #1664, #1665, #1636. + +## What Changes + +- Trigger MCP client/child-process teardown from + `IHostApplicationLifetime.ApplicationStopping` (fires before any + `IHostedService.StopAsync`, including `AkkaHostedService`'s), so MCP + teardown runs concurrently with session drain instead of strictly after it. +- Make `McpClientManager` teardown idempotent: the `ApplicationStopping` + callback and the existing `StopAsync`/`Dispose` path converge on one + teardown operation; whichever runs second observes already-disposed state + and does not log spurious warnings or attempt to reconnect. +- Guard reconnect attempts (`ConnectAsync`/`TryReconnectAsync`) once teardown + has started, so neither an in-flight tool call's retry-after-failure path + nor `McpReconnectionService`'s periodic background poll can launch a new + MCP child process during shutdown. +- Tear down configured servers in parallel instead of today's sequential + `foreach`, so total MCP teardown time is bounded by the slowest single + server's dispose instead of the sum across all configured servers. +- Preserve the existing dispose behavior per client (graceful wait, then + process-tree kill) and the existing clean-tool-error path + (`McpToolAdapter.ExecuteAsync` already converts any invoker exception into + `"Error: MCP tool '{Name}' failed: {ex.Message}"`) for calls in flight when + teardown begins. + +Out of scope: lazy MCP startup, idle-process teardown, per-session MCP +lifecycle, CLI-side child-PID tracking or cleanup (the CLI force-kill path +still cannot reach children of an already-SIGKILLed main PID from outside the +process; see design.md for why this residual gap is not solved here), and any +change to the per-client SDK dispose timeout or process-tree kill mechanism. + +## Capabilities + +### New Capabilities + +None. + +### Modified Capabilities + +- `netclaw-mcp`: the "daemon shutdown owns local child cleanup" behavior + changes from "runs after the full actor-system shutdown completes" to + "starts at `ApplicationStopping`, runs concurrently with session drain, is + idempotent, and does not reconnect once started"; per-server teardown + changes from sequential to parallel. + +## Impact + +- Code: `McpClientManager` gains an `ApplicationStopping` hook, an + idempotency guard shared with `StopAsync`/`Dispose`, a stopping flag + consulted by `ConnectAsync`/`TryReconnectAsync`, and parallel (rather than + sequential) per-server disposal. `Program.cs`'s MCP service registration + gains the lifecycle wiring; no hosted-service registration order changes + are required (ordering was never the fix — the new trigger is). +- Tests: MCP teardown tests exercising real spawned child processes + (`McpSmokeHarness`, extending `McpProcessBoundStdioTests.cs`) prove + idempotent double-teardown, no reconnect after teardown starts, and + parallel (not summed) multi-server teardown latency. +- Security: no ACL/policy change. An in-flight MCP tool call that loses its + transport during shutdown fails loudly and immediately as a clean tool + error, rather than hanging — this is a desired, documented behavior change, + not a silent degradation. +- Operations: MCP children are reclaimed sooner during a graceful `daemon + stop`/SIGTERM, reducing (but not eliminating, on non-systemd deployments) + the window in which a force-kill of the main PID orphans MCP child + processes. +- Configuration/schema: unchanged. +- Dependencies and public APIs: unchanged. diff --git a/openspec/changes/mcp-shutdown-teardown/specs/netclaw-mcp/spec.md b/openspec/changes/mcp-shutdown-teardown/specs/netclaw-mcp/spec.md new file mode 100644 index 000000000..55d4502a9 --- /dev/null +++ b/openspec/changes/mcp-shutdown-teardown/specs/netclaw-mcp/spec.md @@ -0,0 +1,55 @@ +## MODIFIED Requirements + +### Requirement: Configured MCP server has daemon-bound client ownership + +The system SHALL maintain at most one live MCP client connection for each enabled configured MCP server within a daemon process. For a local STDIO server, that connection SHALL own the server child process and SHALL be shared by every Netclaw session authorized to invoke the server. + +#### Scenario: Different sessions invoke one local STDIO server + +- **GIVEN** a local STDIO MCP server is enabled and available to two authorized sessions +- **WHEN** both sessions invoke tools from that server +- **THEN** both invocations use the same configured MCP client connection +- **AND** Netclaw does not launch a child process for either session identity + +#### Scenario: Session identity does not partition MCP state + +- **GIVEN** an authorized session changes state held by an MCP server +- **WHEN** another authorized session invokes that server +- **THEN** the second invocation uses the same daemon-scoped server state + +#### Scenario: Daemon shutdown starts child cleanup before session drain completes + +- **GIVEN** one or more enabled local STDIO MCP servers are connected +- **WHEN** the Netclaw daemon begins graceful shutdown (SIGTERM or `daemon stop`) +- **THEN** Netclaw begins disposing configured MCP clients at the point the host signals application stop, without waiting for actor-system shutdown or session drain to complete +- **AND** each disposed client's transport terminates its owned child process +- **AND** MCP teardown and session drain proceed concurrently rather than one strictly after the other + +#### Scenario: MCP teardown across multiple servers runs in parallel + +- **GIVEN** more than one enabled local STDIO MCP server is connected +- **WHEN** the Netclaw daemon begins graceful shutdown +- **THEN** Netclaw disposes all configured MCP clients concurrently +- **AND** total MCP teardown time is bounded by the slowest single server's dispose, not the sum across all configured servers + +#### Scenario: Teardown is idempotent across shutdown paths + +- **GIVEN** MCP teardown has already run once during daemon shutdown +- **WHEN** the host's normal hosted-service stop sequence subsequently invokes MCP shutdown again +- **THEN** the repeated teardown observes already-disposed clients +- **AND** it does not log a warning or error for the already-disposed state +- **AND** it does not attempt to reconnect or relaunch a child process + +#### Scenario: No reconnect once teardown has started + +- **GIVEN** MCP daemon shutdown has begun and client teardown is in progress or complete +- **WHEN** an in-flight tool call's failure-recovery path, or the periodic MCP reconnection check, attempts to reconnect to a configured server +- **THEN** Netclaw does not create a new client connection or launch a new child process +- **AND** the reconnect attempt reports failure without side effects + +#### Scenario: In-flight tool call fails cleanly when teardown begins + +- **GIVEN** a session has an MCP tool call in flight against a local STDIO server +- **WHEN** daemon shutdown begins and that server's client is disposed +- **THEN** the in-flight call fails within the same bounded time as the client's own dispose +- **AND** the caller receives an attributed tool error rather than an indefinite hang diff --git a/openspec/changes/mcp-shutdown-teardown/tasks.md b/openspec/changes/mcp-shutdown-teardown/tasks.md new file mode 100644 index 000000000..b2e8e57bb --- /dev/null +++ b/openspec/changes/mcp-shutdown-teardown/tasks.md @@ -0,0 +1,20 @@ +## 1. Decouple MCP Teardown From Actor-System Shutdown + +- [ ] 1.1 Add an `IHostApplicationLifetime.ApplicationStopping` hook that triggers MCP client/child-process teardown independent of `IHostedService` stop ordering. +- [ ] 1.2 Refactor `McpClientManager` teardown into a single memoized `TeardownAsync()` operation shared by the `ApplicationStopping` callback, `StopAsync`, and `Dispose`, so a second caller awaits the same completed work instead of re-disposing or racing it. +- [ ] 1.3 Add a `_stopping` flag set synchronously when teardown begins, consulted by `ConnectAsync` and `TryReconnectAsync` so neither the tool-call retry-after-failure path nor `McpReconnectionService`'s periodic poll can create a new client or child process once teardown has started. +- [ ] 1.4 Change per-server disposal in `TeardownAsync()` from sequential `foreach` + `await` to a parallel `Task.WhenAll` projection, preserving today's per-server try/catch so one server's disposal failure doesn't block or delay others. + +## 2. Automated Proof + +- [ ] 2.1 Extend `McpProcessBoundStdioTests.cs` (using the real-process `McpSmokeHarness`) with a test proving double-teardown (`ApplicationStopping` hook followed by `StopAsync`) disposes the underlying child process exactly once, without a spurious warning on the second call. +- [ ] 2.2 Add a test proving that once teardown has started, a subsequent `TryReconnectAsync` call does not launch a new child process. +- [ ] 2.3 Add a test proving multiple configured servers tear down concurrently: total teardown wall-clock time is bounded by the slowest single server's dispose, not the sum across servers. +- [ ] 2.4 Add a test proving an in-flight tool call against a server whose client is disposed mid-call surfaces a clean, attributed tool error (via the existing `McpToolAdapter.ExecuteAsync` catch path) rather than hanging past the client's own dispose timeout. +- [ ] 2.5 Run targeted MCP tests and the full `Netclaw.Daemon.Tests` project. + +## 3. Guidance and Quality Gates + +- [ ] 3.1 Update `netclaw-operations` guidance to note that MCP child-process teardown now starts at application-stopping (concurrent with session drain) rather than after actor-system shutdown, and that in-flight MCP tool calls fail fast during shutdown; bump the skill version. +- [ ] 3.2 Confirm the eval suite is not applicable because this change does not alter production tool definitions, skill matching, prompts, or model behavior. +- [ ] 3.3 Run OpenSpec validation, Slopwatch, file-header verification, and `git diff --check`. From 541cd8a2c9533d0ec74a14d0c4b22967bc67756c Mon Sep 17 00:00:00 2001 From: Aaron Stannard Date: Thu, 16 Jul 2026 16:58:16 +0000 Subject: [PATCH 2/4] feat(mcp): tear down stdio MCP children at ApplicationStopping (#1667) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Stdio MCP child processes were only torn down by McpClientManager's IHostedService.StopAsync, which .NET's LIFO hosted-service ordering places after AkkaHostedService.StopAsync — which blocks on the full session-drain CoordinatedShutdown phase (up to 190s). MCP teardown therefore ran strictly after drain instead of concurrently with it, and the CLI force-kill path never runs it at all, orphaning MCP child processes. Implements openspec/changes/mcp-shutdown-teardown: - Trigger teardown from IHostApplicationLifetime.ApplicationStopping, which fires before any IHostedService.StopAsync, independent of registration order. - Make teardown idempotent via one memoized TeardownAsync() Task shared by the ApplicationStopping hook, StopAsync, and Dispose — whichever runs first does the real work, the others converge on the same completion. - Gate ConnectAsync/TryReconnectAsync on a _stopping flag set synchronously before any await, closing the tool-call-retry and McpReconnectionService reconnect paths without touching either caller. - Dispose all configured clients in parallel (Task.WhenAll + per-client try/catch) instead of sequentially, bounding total teardown by the slowest single server. Tests (McpShutdownTeardownTests.cs, real spawned child processes via McpSmokeHarness): idempotent double/triple teardown with no spurious warnings; TryReconnectAsync returns false and installs no new client once teardown starts; parallel teardown of 2 servers takes ~10s, not the ~20s a sequential regression produces (verified by temporarily reverting to sequential and confirming the test fails); an in-flight tool call fails with the standard "Error: MCP tool '...' failed" result within milliseconds of teardown starting, not a hang. Fixes #1667. The OpenSpec change ships in this PR; sync/archive follows post-merge. --- .slopwatch/baseline.json | 38 +-- .../.system/files/netclaw-operations/SKILL.md | 2 +- .../netclaw-operations/references/tools.md | 13 + .../changes/mcp-shutdown-teardown/tasks.md | 24 +- .../DaemonRuntimeStatusServiceTests.cs | 4 +- .../McpEndpointRouteBuilderExtensionsTests.cs | 4 +- .../Mcp/McpOAuthHeaderConflictTests.cs | 4 +- .../Mcp/McpShutdownTeardownTests.cs | 252 ++++++++++++++++++ .../Mcp/McpSmokeHarness.cs | 28 +- src/Netclaw.Daemon/Mcp/McpClientManager.cs | 99 ++++++- tests/Netclaw.SmokeMcpServer/Program.cs | 22 +- 11 files changed, 427 insertions(+), 63 deletions(-) create mode 100644 src/Netclaw.Daemon.Tests/Mcp/McpShutdownTeardownTests.cs diff --git a/.slopwatch/baseline.json b/.slopwatch/baseline.json index 73ed51960..14b22a920 100644 --- a/.slopwatch/baseline.json +++ b/.slopwatch/baseline.json @@ -1,7 +1,7 @@ { "version": 1, "createdAt": "2026-05-12T17:20:55.7365203+00:00", - "updatedAt": "2026-06-10T19:44:08.3092383+00:00", + "updatedAt": "2026-07-16T16:54:31.2122436+00:00", "description": "Initial baseline created by 'slopwatch init' on 2026-05-12 17:20:55 UTC", "entries": [ { @@ -31,24 +31,6 @@ "message": "Adding warnings to NoWarn: OPENAI001", "baselinedAt": "2026-05-12T17:20:55.7420301+00:00" }, - { - "hash": "1a29ed65e4ed3efb", - "ruleId": "SW004", - "filePath": "src/Netclaw.Daemon.Tests/Services/ConfigWatcherServiceTests.cs", - "lineNumber": 139, - "codeSnippet": "Task.Delay(50, ct)", - "message": "Test uses Task.Delay(50) which may indicate a timing-dependent test", - "baselinedAt": "2026-05-12T17:20:55.7420338+00:00" - }, - { - "hash": "fcb5e461d7f70a7c", - "ruleId": "SW004", - "filePath": "src/Netclaw.Daemon.Tests/Services/ConfigWatcherServiceTests.cs", - "lineNumber": 154, - "codeSnippet": "Task.Delay(100, ct)", - "message": "Test uses Task.Delay(100) which may indicate a timing-dependent test", - "baselinedAt": "2026-05-12T17:20:55.7420454+00:00" - }, { "hash": "6ea5c8bbead4b59c", "ruleId": "SW004", @@ -112,15 +94,6 @@ "message": "Test uses Task.Delay(25 * (i + 1)) which may indicate a timing-dependent test", "baselinedAt": "2026-05-12T17:20:55.7421146+00:00" }, - { - "hash": "c00fb5b6beafab8b", - "ruleId": "SW004", - "filePath": "src/Netclaw.Actors.Tests/SubAgents/SubAgentActorTests.cs", - "lineNumber": 459, - "codeSnippet": "Task.Delay(Delay, cancellationToken)", - "message": "Test uses Task.Delay(Delay) which may indicate a timing-dependent test", - "baselinedAt": "2026-05-12T17:20:55.7421212+00:00" - }, { "hash": "b691cefe260611c6", "ruleId": "SW004", @@ -174,6 +147,15 @@ "codeSnippet": "Fact(SkipUnless = nameof(IsPosix), Skip = \"POSIX-only — matcher routes through BashParser on POSIX\")", "message": "Test method 'IsApproved_git_tag_grant_matches_both_version_forms' is disabled: POSIX-only — matcher routes through BashParser on POSIX", "baselinedAt": "2026-06-10T19:44:08.3092375+00:00" + }, + { + "hash": "92870afae0455103", + "ruleId": "SW004", + "filePath": "tests/Netclaw.SmokeMcpServer/Program.cs", + "lineNumber": 105, + "codeSnippet": "Task.Delay(ms)", + "message": "Test uses Task.Delay(ms) which may indicate a timing-dependent test", + "baselinedAt": "2026-07-16T16:54:31.2120133+00:00" } ] } \ No newline at end of file diff --git a/feeds/skills/.system/files/netclaw-operations/SKILL.md b/feeds/skills/.system/files/netclaw-operations/SKILL.md index 119bab907..9c748a10b 100644 --- a/feeds/skills/.system/files/netclaw-operations/SKILL.md +++ b/feeds/skills/.system/files/netclaw-operations/SKILL.md @@ -3,7 +3,7 @@ name: netclaw-operations description: "REQUIRED when the user asks about scheduling, reminders, cron jobs, timers, background jobs, diagnostics, troubleshooting, MCP tools, daemon health, identity updates, or Netclaw capabilities and self-maintenance." metadata: author: netclaw - version: "2.32.0" + version: "2.33.0" --- # Netclaw Operations diff --git a/feeds/skills/.system/files/netclaw-operations/references/tools.md b/feeds/skills/.system/files/netclaw-operations/references/tools.md index 6a3f13284..ffa52eb01 100644 --- a/feeds/skills/.system/files/netclaw-operations/references/tools.md +++ b/feeds/skills/.system/files/netclaw-operations/references/tools.md @@ -121,3 +121,16 @@ JSON blob — so you can act on it directly: Both name the server explicitly (`server/tool`), so when two servers expose a same-named tool you can tell which one failed. + +### MCP teardown during daemon shutdown + +Once the daemon begins a graceful shutdown (SIGTERM or `netclaw daemon stop`), +MCP client teardown starts immediately — concurrently with session drain, +not strictly after it — and every configured server tears down at the same +time (bounded by the slowest single server, not the sum). If your tool call +is in flight when its server's client gets disposed, expect the same +`Error: MCP tool 'server/tool' failed: ` result described above, +returned promptly rather than hanging until the process exits — this is +expected end-of-life behavior, not a bug to retry around. Once shutdown has +started, no MCP server reconnects for any reason (not the automatic +reconnect above, not a background health check) — the daemon is exiting. diff --git a/openspec/changes/mcp-shutdown-teardown/tasks.md b/openspec/changes/mcp-shutdown-teardown/tasks.md index b2e8e57bb..326854536 100644 --- a/openspec/changes/mcp-shutdown-teardown/tasks.md +++ b/openspec/changes/mcp-shutdown-teardown/tasks.md @@ -1,20 +1,20 @@ ## 1. Decouple MCP Teardown From Actor-System Shutdown -- [ ] 1.1 Add an `IHostApplicationLifetime.ApplicationStopping` hook that triggers MCP client/child-process teardown independent of `IHostedService` stop ordering. -- [ ] 1.2 Refactor `McpClientManager` teardown into a single memoized `TeardownAsync()` operation shared by the `ApplicationStopping` callback, `StopAsync`, and `Dispose`, so a second caller awaits the same completed work instead of re-disposing or racing it. -- [ ] 1.3 Add a `_stopping` flag set synchronously when teardown begins, consulted by `ConnectAsync` and `TryReconnectAsync` so neither the tool-call retry-after-failure path nor `McpReconnectionService`'s periodic poll can create a new client or child process once teardown has started. -- [ ] 1.4 Change per-server disposal in `TeardownAsync()` from sequential `foreach` + `await` to a parallel `Task.WhenAll` projection, preserving today's per-server try/catch so one server's disposal failure doesn't block or delay others. +- [x] 1.1 Add an `IHostApplicationLifetime.ApplicationStopping` hook that triggers MCP client/child-process teardown independent of `IHostedService` stop ordering. +- [x] 1.2 Refactor `McpClientManager` teardown into a single memoized `TeardownAsync()` operation shared by the `ApplicationStopping` callback, `StopAsync`, and `Dispose`, so a second caller awaits the same completed work instead of re-disposing or racing it. +- [x] 1.3 Add a `_stopping` flag set synchronously when teardown begins, consulted by `ConnectAsync` and `TryReconnectAsync` so neither the tool-call retry-after-failure path nor `McpReconnectionService`'s periodic poll can create a new client or child process once teardown has started. +- [x] 1.4 Change per-server disposal in `TeardownAsync()` from sequential `foreach` + `await` to a parallel `Task.WhenAll` projection, preserving today's per-server try/catch so one server's disposal failure doesn't block or delay others. ## 2. Automated Proof -- [ ] 2.1 Extend `McpProcessBoundStdioTests.cs` (using the real-process `McpSmokeHarness`) with a test proving double-teardown (`ApplicationStopping` hook followed by `StopAsync`) disposes the underlying child process exactly once, without a spurious warning on the second call. -- [ ] 2.2 Add a test proving that once teardown has started, a subsequent `TryReconnectAsync` call does not launch a new child process. -- [ ] 2.3 Add a test proving multiple configured servers tear down concurrently: total teardown wall-clock time is bounded by the slowest single server's dispose, not the sum across servers. -- [ ] 2.4 Add a test proving an in-flight tool call against a server whose client is disposed mid-call surfaces a clean, attributed tool error (via the existing `McpToolAdapter.ExecuteAsync` catch path) rather than hanging past the client's own dispose timeout. -- [ ] 2.5 Run targeted MCP tests and the full `Netclaw.Daemon.Tests` project. +- [x] 2.1 Extend `McpProcessBoundStdioTests.cs` (using the real-process `McpSmokeHarness`) with a test proving double-teardown (`ApplicationStopping` hook followed by `StopAsync`) disposes the underlying child process exactly once, without a spurious warning on the second call. (Landed as a new sibling file `McpShutdownTeardownTests.cs` reusing `McpSmokeHarness`, rather than growing the unrelated process-ownership test file — also exercises a third entry point, `Dispose()`, in the same test.) +- [x] 2.2 Add a test proving that once teardown has started, a subsequent `TryReconnectAsync` call does not launch a new child process. +- [x] 2.3 Add a test proving multiple configured servers tear down concurrently: total teardown wall-clock time is bounded by the slowest single server's dispose, not the sum across servers. +- [x] 2.4 Add a test proving an in-flight tool call against a server whose client is disposed mid-call surfaces a clean, attributed tool error (via the existing `McpToolAdapter.ExecuteAsync` catch path) rather than hanging past the client's own dispose timeout. +- [x] 2.5 Run targeted MCP tests and the full `Netclaw.Daemon.Tests` project. ## 3. Guidance and Quality Gates -- [ ] 3.1 Update `netclaw-operations` guidance to note that MCP child-process teardown now starts at application-stopping (concurrent with session drain) rather than after actor-system shutdown, and that in-flight MCP tool calls fail fast during shutdown; bump the skill version. -- [ ] 3.2 Confirm the eval suite is not applicable because this change does not alter production tool definitions, skill matching, prompts, or model behavior. -- [ ] 3.3 Run OpenSpec validation, Slopwatch, file-header verification, and `git diff --check`. +- [x] 3.1 Update `netclaw-operations` guidance to note that MCP child-process teardown now starts at application-stopping (concurrent with session drain) rather than after actor-system shutdown, and that in-flight MCP tool calls fail fast during shutdown; bump the skill version. +- [x] 3.2 Confirm the eval suite is not applicable because this change does not alter production tool definitions, skill matching, prompts, or model behavior. +- [x] 3.3 Run OpenSpec validation, Slopwatch, file-header verification, and `git diff --check`. diff --git a/src/Netclaw.Daemon.Tests/Gateway/DaemonRuntimeStatusServiceTests.cs b/src/Netclaw.Daemon.Tests/Gateway/DaemonRuntimeStatusServiceTests.cs index 028adce84..4e36ac95b 100644 --- a/src/Netclaw.Daemon.Tests/Gateway/DaemonRuntimeStatusServiceTests.cs +++ b/src/Netclaw.Daemon.Tests/Gateway/DaemonRuntimeStatusServiceTests.cs @@ -6,6 +6,7 @@ using System.Net; using Microsoft.Extensions.AI; using Microsoft.Data.Sqlite; +using Microsoft.Extensions.Hosting.Internal; using Microsoft.Extensions.Options; using Microsoft.Extensions.Logging.Abstractions; using Netclaw.Actors.Channels; @@ -298,7 +299,8 @@ public async Task IncludesMcpConnectorHealthFromRuntimeStatuses() oauthService, NullNotificationSink.Instance, TimeProvider.System, - NullLogger.Instance); + NullLogger.Instance, + new ApplicationLifetime(NullLogger.Instance)); await manager.StartAsync(CancellationToken.None); try diff --git a/src/Netclaw.Daemon.Tests/Mcp/McpEndpointRouteBuilderExtensionsTests.cs b/src/Netclaw.Daemon.Tests/Mcp/McpEndpointRouteBuilderExtensionsTests.cs index 27ce28cb0..8d7925a89 100644 --- a/src/Netclaw.Daemon.Tests/Mcp/McpEndpointRouteBuilderExtensionsTests.cs +++ b/src/Netclaw.Daemon.Tests/Mcp/McpEndpointRouteBuilderExtensionsTests.cs @@ -14,6 +14,7 @@ using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.TestHost; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting.Internal; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Options; @@ -88,7 +89,8 @@ private async Task CreateAppAsync( oauthService, NullNotificationSink.Instance, TimeProvider.System, - NullLogger.Instance); + NullLogger.Instance, + new ApplicationLifetime(NullLogger.Instance)); builder.Services.AddSingleton(oauthService); builder.Services.AddSingleton(mcpManager); diff --git a/src/Netclaw.Daemon.Tests/Mcp/McpOAuthHeaderConflictTests.cs b/src/Netclaw.Daemon.Tests/Mcp/McpOAuthHeaderConflictTests.cs index c4b2abafb..b3e392195 100644 --- a/src/Netclaw.Daemon.Tests/Mcp/McpOAuthHeaderConflictTests.cs +++ b/src/Netclaw.Daemon.Tests/Mcp/McpOAuthHeaderConflictTests.cs @@ -8,6 +8,7 @@ using System.Reflection; using System.Text; using System.Text.Json; +using Microsoft.Extensions.Hosting.Internal; using Microsoft.Extensions.Logging.Abstractions; using Netclaw.Actors.Tools; using Netclaw.Configuration; @@ -223,7 +224,8 @@ private McpClientManager CreateManager( oauthService, NullNotificationSink.Instance, TimeProvider.System, - NullLogger.Instance); + NullLogger.Instance, + new ApplicationLifetime(NullLogger.Instance)); } private static HttpClient CreateDiscoveryClientThatReturnsOAuthHints() diff --git a/src/Netclaw.Daemon.Tests/Mcp/McpShutdownTeardownTests.cs b/src/Netclaw.Daemon.Tests/Mcp/McpShutdownTeardownTests.cs new file mode 100644 index 000000000..fdf145798 --- /dev/null +++ b/src/Netclaw.Daemon.Tests/Mcp/McpShutdownTeardownTests.cs @@ -0,0 +1,252 @@ +// ----------------------------------------------------------------------- +// +// Copyright (C) 2026 - 2026 Petabridge, LLC +// +// ----------------------------------------------------------------------- +using System.Diagnostics; +using System.Text.Json; +using Microsoft.Extensions.Logging; +using Netclaw.Actors.Tools; +using Netclaw.Configuration; +using Netclaw.Daemon.Mcp; +using Netclaw.Tools; +using Xunit; + +namespace Netclaw.Daemon.Tests.Mcp; + +/// +/// Real-process proofs for the mcp-shutdown-teardown change +/// (openspec/changes/mcp-shutdown-teardown, GitHub #1667): idempotent +/// double-teardown, no reconnect once teardown has started, parallel +/// multi-server teardown, and clean failure for a tool call in flight when +/// its client is disposed. Uses 's real spawned +/// child MCP server processes throughout — no faked transports or clients. +/// +public sealed class McpShutdownTeardownTests +{ + [Fact] + public async Task DoubleTeardown_DisposesChildProcessExactlyOnce_WithoutSpuriousWarnings() + { + using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); + var recordingLogger = new RecordingLogger(); + await using var harness = McpSmokeHarness.Create( + new Dictionary { ["teardown_probe"] = CreateEntry() }, + new ToolRegistry(), + recordingLogger); + + await harness.Manager.StartAsync(cts.Token); + + var info = await GetProcessInfoAsync(harness, "teardown_probe", "slack/channel/thread", cts.Token); + using var process = Process.GetProcessById(info.ProcessId); + + // Simulate the real shutdown sequence this change introduces: + // ApplicationStopping (the new hook, registered in StartAsync) + // fires first, then the host's normal IHostedService.StopAsync + // runs afterward regardless of which one actually did the work. + harness.AppLifetime.StopApplication(); + await harness.Manager.StopAsync(cts.Token); + + // A third entry point — IDisposable.Dispose, e.g. DI container + // teardown — must also converge on the same completed work rather + // than redoing (or racing) disposal. + harness.Manager.Dispose(); + + await process.WaitForExitAsync(cts.Token); + Assert.True(process.HasExited); + + // The success log fires exactly once — by whichever of the three + // callers actually did the work — never once per caller. + Assert.Single(recordingLogger.Entries, e => e.Level == LogLevel.Information + && e.Message.Contains("MCP clients shut down", StringComparison.Ordinal)); + + // The second and third entries observe already-disposed state and + // must not log a warning or error for it. + Assert.DoesNotContain(recordingLogger.Entries, e => e.Level is LogLevel.Warning or LogLevel.Error); + } + + [Fact] + public async Task TryReconnectAsync_AfterTeardownStarted_ReturnsFalseAndCreatesNoNewClient() + { + using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); + var serverName = new McpServerName("teardown_probe"); + await using var harness = McpSmokeHarness.Create( + new Dictionary { [serverName.Value] = CreateEntry() }, + new ToolRegistry()); + + await harness.Manager.StartAsync(cts.Token); + + var originalClient = harness.Manager.GetClient(serverName); + Assert.NotNull(originalClient); + + // ApplicationLifetime.StopApplication() cancels the ApplicationStopping + // token synchronously on this thread, which synchronously invokes our + // registered callback and sets McpClientManager's _stopping flag — + // all before this call returns. There is no race window to wait out + // before the next line: TryReconnectAsync is guaranteed to observe + // _stopping == true. + harness.AppLifetime.StopApplication(); + + var reconnected = await harness.Manager.TryReconnectAsync(serverName, cts.Token); + Assert.False(reconnected); + + // Had the guard not engaged, TryReconnectAsync would have removed + // the original client, spawned a brand-new child process, and + // installed a new McpClient in its place. Instead the slot is + // either untouched (the background teardown triggered by + // StopApplication() hasn't reached it yet) or cleared to null by + // that same teardown — never replaced with something new. Since a + // new child process can only come into existence via a new McpClient + // (ConnectAsync creates the transport — and its process — before + // installing the client), this is a direct proof no process spawned. + var clientAfterReconnectAttempt = harness.Manager.GetClient(serverName); + Assert.True( + clientAfterReconnectAttempt is null || ReferenceEquals(clientAfterReconnectAttempt, originalClient), + "TryReconnectAsync must not install a new client once teardown has started."); + + await harness.Manager.StopAsync(cts.Token); + } + + [Fact] + public async Task ParallelTeardown_DisposesConfiguredServersConcurrently() + { + using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); + await using var harness = McpSmokeHarness.Create( + new Dictionary + { + ["teardown_probe_a"] = CreateEntry(), + ["teardown_probe_b"] = CreateEntry(), + }, + new ToolRegistry()); + + await harness.Manager.StartAsync(cts.Token); + + // Each configured server's dispose is dominated by a real, fixed + // cost inherent to the MCP SDK, not something this test injects: + // StdioClientSessionTransport.CleanupAsync (see + // ModelContextProtocol.Client.StdioClientSessionTransport, v1.4.1) + // idly awaits the child process's own exit for up to + // StdioClientTransportOptions.ShutdownTimeout (hardcoded to 10s in + // McpClientManager.CreateTransport) before force-killing the + // process tree — the SDK never proactively closes the child's + // stdin first, so a healthy smoke-server process (which never + // exits on its own) reliably burns close to that full 10s per + // dispose. Two servers therefore give a real, deterministic + // ~10s-per-client cost: ~10s total if disposed in parallel, + // ~20s if disposed sequentially — a large enough gap that a + // generous bound comfortably distinguishes the two without + // flaking on a slow CI runner. + var stopwatch = Stopwatch.StartNew(); + await harness.Manager.StopAsync(cts.Token); + stopwatch.Stop(); + + Assert.True( + stopwatch.Elapsed < TimeSpan.FromSeconds(16), + $"Expected concurrent teardown of 2 servers to take roughly one ~10s dispose, not the ~20s sum of two sequential disposes. Actual: {stopwatch.Elapsed}."); + } + + [Fact] + public async Task InFlightToolCall_FailsCleanly_WhenTeardownDisposesItsClient() + { + using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)); + var registry = new ToolRegistry(); + await using var harness = McpSmokeHarness.Create( + new Dictionary { ["teardown_probe"] = CreateEntry() }, + registry); + + await harness.Manager.StartAsync(cts.Token); + + // Go through the registered McpToolAdapter (not McpClientManager + // directly) so this test exercises the exact path a real session + // uses, including McpToolAdapter.ExecuteAsync's catch that formats + // any invoker exception into the clean "Error: MCP tool '...' + // failed" result. + var tool = registry.GetByName("teardown_probe/sleep"); + Assert.NotNull(tool); + + var invocation = TestToolExecutionContext + .CreateBound("slack/channel/thread", null, TrustAudience.Personal) + .Invocation; + + // 30s is far longer than this test needs to wait: McpSessionHandler + // cancels every outstanding request's TaskCompletionSource as the + // very first step of McpClient.DisposeAsync (before any process + // teardown), so the in-flight call fails within milliseconds of + // StopAsync starting — well before the tool's own 30s would elapse + // and well before the SDK's ~10s process-kill timeline. + var callTask = tool!.ExecuteAsync( + new Dictionary { ["ms"] = 30_000 }, invocation, cts.Token); + + // No delay before triggering teardown: ExecuteAsync's async call + // chain (McpToolAdapter -> McpClientManager -> the MCP SDK's + // SendRequestAsync) runs synchronously on this thread up to its + // first genuine suspension point — which is after the pending + // request is already registered — before control returns here. + await harness.Manager.StopAsync(cts.Token); + + var result = await callTask.WaitAsync(TimeSpan.FromSeconds(5), cts.Token); + Assert.StartsWith("Error: MCP tool 'teardown_probe/sleep' failed:", result, StringComparison.Ordinal); + } + + private static McpServerEntry CreateEntry() + => new() + { + Transport = "stdio", + Command = "dotnet", + Arguments = [SmokeMcpServerLocator.LocateDll()], + Enabled = true, + }; + + private static async Task GetProcessInfoAsync( + McpSmokeHarness harness, + string serverName, + string sessionId, + CancellationToken ct) + { + var result = await harness.Manager.InvokeAsync( + serverName, + "process-info", + null, + TestToolExecutionContext.CreateBound(sessionId, null, TrustAudience.Personal).Invocation, + ct); + + return JsonSerializer.Deserialize(result, JsonOptions)!; + } + + private static readonly JsonSerializerOptions JsonOptions = new() + { + PropertyNameCaseInsensitive = true, + }; + + private sealed record ProcessInfo(int ProcessId, string[] Arguments); + + /// + /// Captures every log call made through it so tests can assert on + /// message content and level without a mocking framework. Thread-safe: + /// parallel teardown logs from multiple concurrent dispose tasks. + /// + private sealed class RecordingLogger : ILogger + { + private readonly List<(LogLevel Level, string Message)> _entries = []; + + public IReadOnlyList<(LogLevel Level, string Message)> Entries + { + get { lock (_entries) return _entries.ToList(); } + } + + public IDisposable? BeginScope(TState state) where TState : notnull => null; + + public bool IsEnabled(LogLevel logLevel) => true; + + public void Log( + LogLevel logLevel, + EventId eventId, + TState state, + Exception? exception, + Func formatter) + { + var message = formatter(state, exception); + lock (_entries) + _entries.Add((logLevel, message)); + } + } +} diff --git a/src/Netclaw.Daemon.Tests/Mcp/McpSmokeHarness.cs b/src/Netclaw.Daemon.Tests/Mcp/McpSmokeHarness.cs index 75760d66d..476ae3789 100644 --- a/src/Netclaw.Daemon.Tests/Mcp/McpSmokeHarness.cs +++ b/src/Netclaw.Daemon.Tests/Mcp/McpSmokeHarness.cs @@ -3,6 +3,9 @@ // Copyright (C) 2026 - 2026 Petabridge, LLC // // ----------------------------------------------------------------------- +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.Hosting.Internal; +using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using Netclaw.Actors.Tools; using Netclaw.Configuration; @@ -24,18 +27,33 @@ internal sealed class McpSmokeHarness : IAsyncDisposable private readonly HttpClient _pkceHttp; private readonly HttpClient _oauthHttp; - private McpSmokeHarness(McpClientManager manager, HttpClient pkceHttp, HttpClient oauthHttp) + private McpSmokeHarness( + McpClientManager manager, + ApplicationLifetime appLifetime, + HttpClient pkceHttp, + HttpClient oauthHttp) { Manager = manager; + AppLifetime = appLifetime; _pkceHttp = pkceHttp; _oauthHttp = oauthHttp; } public McpClientManager Manager { get; } + /// + /// The real implementation backing + /// . Tests call + /// to fire ApplicationStopping synchronously, exactly as the + /// generic host does on SIGTERM/graceful stop, without needing a full + /// . + /// + public ApplicationLifetime AppLifetime { get; } + public static McpSmokeHarness Create( Dictionary serverEntries, - ToolRegistry registry) + ToolRegistry registry, + ILogger? logger = null) { var pkceHttp = new HttpClient(); var oauthHttp = new HttpClient(); @@ -46,6 +64,7 @@ public static McpSmokeHarness Create( NullLogger.Instance, new OAuthPkceService(pkceHttp), NullNotificationSink.Instance); + var appLifetime = new ApplicationLifetime(NullLogger.Instance); var manager = new McpClientManager( serverEntries, registry, @@ -53,8 +72,9 @@ public static McpSmokeHarness Create( oauthService, NullNotificationSink.Instance, TimeProvider.System, - NullLogger.Instance); - return new McpSmokeHarness(manager, pkceHttp, oauthHttp); + logger ?? NullLogger.Instance, + appLifetime); + return new McpSmokeHarness(manager, appLifetime, pkceHttp, oauthHttp); } public async ValueTask DisposeAsync() diff --git a/src/Netclaw.Daemon/Mcp/McpClientManager.cs b/src/Netclaw.Daemon/Mcp/McpClientManager.cs index 7f0e3c08e..106a14b29 100644 --- a/src/Netclaw.Daemon/Mcp/McpClientManager.cs +++ b/src/Netclaw.Daemon/Mcp/McpClientManager.cs @@ -24,6 +24,7 @@ internal sealed class McpClientManager : IHostedService, IDisposable, IMcpToolIn private readonly IOperationalNotificationSink _notificationSink; private readonly TimeProvider _timeProvider; private readonly ILogger _logger; + private readonly IHostApplicationLifetime _appLifetime; private readonly int _maxToolDescriptionChars; private readonly int _maxToolSchemaWarnChars; @@ -33,6 +34,22 @@ internal sealed class McpClientManager : IHostedService, IDisposable, IMcpToolIn private readonly ConcurrentDictionary _statuses = new(); + // Guards the memoized teardown Task below. Teardown can be reached from + // three independent callers (the ApplicationStopping hook, the host's + // IHostedService.StopAsync, and IDisposable.Dispose) and must run its real + // work exactly once; every caller after the first converges on the same + // Task instead of re-disposing already-disposed clients or racing them. + private readonly object _teardownGate = new(); + private Task? _teardownTask; + + // Set synchronously (before any await) the moment teardown begins, so a + // racing ConnectAsync/TryReconnectAsync call started on another thread can + // observe it immediately and bail out before touching the transport or + // spawning a process. Volatile, not Interlocked-guarded state, is + // sufficient here: the flag is only ever written once (inside + // _teardownGate) and is read-only everywhere else. + private volatile bool _stopping; + public McpClientManager( Dictionary serverEntries, ToolRegistry toolRegistry, @@ -41,6 +58,7 @@ public McpClientManager( IOperationalNotificationSink notificationSink, TimeProvider timeProvider, ILogger logger, + IHostApplicationLifetime appLifetime, SessionConfig? sessionConfig = null) { _serverEntries = serverEntries; @@ -50,12 +68,23 @@ public McpClientManager( _notificationSink = notificationSink; _timeProvider = timeProvider; _logger = logger; + _appLifetime = appLifetime; _maxToolDescriptionChars = sessionConfig?.Tuning.MaxToolDescriptionChars ?? 0; _maxToolSchemaWarnChars = sessionConfig?.Tuning.MaxToolSchemaWarnChars ?? 0; } public async Task StartAsync(CancellationToken cancellationToken) { + // ApplicationStopping fires before any IHostedService.StopAsync runs — + // including AkkaHostedService's, which blocks on CoordinatedShutdown's + // full session-drain phase (up to DaemonConfig.BoundedDrainTimeout). + // Hooking here lets MCP child-process teardown start concurrently with + // session drain instead of waiting for it to finish first. StopAsync + // and Dispose route through the same memoized TeardownAsync() below as + // a backstop, so whichever of the three callers runs first does the + // real work and the others just await its completion. + _appLifetime.ApplicationStopping.Register(() => _ = TeardownAsync()); + foreach (var (name, entry) in _serverEntries) { var serverName = new McpServerName(name); @@ -70,23 +99,47 @@ public async Task StartAsync(CancellationToken cancellationToken) } } - public async Task StopAsync(CancellationToken cancellationToken) + public Task StopAsync(CancellationToken cancellationToken) => TeardownAsync(); + + /// + /// Returns the single, memoized teardown operation for this manager's + /// lifetime, creating it on first call. Sets + /// synchronously (inside the lock, before + /// reaches its first await) so a racing reconnect call started on another + /// thread cannot slip a new client past this point. + /// + private Task TeardownAsync() + { + lock (_teardownGate) + { + if (_teardownTask is not null) + return _teardownTask; + + _stopping = true; + _teardownTask = TeardownCoreAsync(); + return _teardownTask; + } + } + + private async Task TeardownCoreAsync() { - foreach (var (name, client) in _clients) + var disposals = _clients.ToArray().Select(async entry => { try { - await client.DisposeAsync(); - _logger.LogInformation("MCP client '{Name}' shut down", name.Value); + await entry.Value.DisposeAsync(); } catch (Exception ex) { - _logger.LogWarning(ex, "Error shutting down MCP client '{Name}'", name.Value); + _logger.LogWarning(ex, "Error shutting down MCP client '{Name}'", entry.Key.Value); } - } + }); + + await Task.WhenAll(disposals); _clients.Clear(); _sharedToolFunctions.Clear(); + _logger.LogInformation("MCP clients shut down"); } public McpClient? GetClient(McpServerName serverName) @@ -109,6 +162,14 @@ public IReadOnlyList GetToolNames(McpServerName serverName) public async Task TryReconnectAsync(McpServerName serverName, CancellationToken ct = default) { + // Once teardown has begun there is no legitimate reason to reconnect — + // the daemon is exiting. This is the single choke point both the + // tool-call retry-after-failure path (InvokeSharedAsync) and + // McpReconnectionService's periodic poll go through, so gating here + // closes off both without touching either caller. + if (_stopping) + return false; + if (!_serverEntries.TryGetValue(serverName.Value, out var entry) || !entry.Enabled) return false; @@ -206,6 +267,13 @@ private bool TryGetSharedFunction(McpServerName serverName, string toolName, out private async Task ConnectAsync(McpServerName name, McpServerEntry entry, CancellationToken ct) { + // Same shutdown guard as TryReconnectAsync: refuse to spawn a new + // child process once teardown has started. StartAsync's own initial + // connect loop always runs before _stopping can be set, so this only + // ever short-circuits reconnect-triggered calls. + if (_stopping) + return false; + // Holds the client until ownership passes to _clients. If the connect // fails after the client — and its child process — is created but // before that handoff (e.g. ListToolsAsync throws), the finally @@ -589,16 +657,19 @@ private void LogToolDrift(McpServerName serverName, IList discove } } + // Routes through the same memoized teardown as StopAsync/ApplicationStopping + // rather than its own separate synchronous dispose pass, so all three + // entry points converge on one real disposal (graceful wait, then + // process-tree kill) instead of Dispose racing a weaker, synchronous-only + // teardown against the other two. Blocking here is safe: by the time the + // generic host disposes this singleton, StopAsync has already run and the + // memoized task is normally already complete, making this a synchronous + // no-op in the common case (the backstop case is a caller that only ever + // calls Dispose(), e.g. a test harness or a crash path that never reached + // StopAsync). public void Dispose() { - foreach (var client in _clients.Values) - { - try { (client as IDisposable)?.Dispose(); } - catch (Exception ex) { _logger.LogDebug(ex, "Error disposing MCP client during shutdown"); } - } - - _clients.Clear(); - _sharedToolFunctions.Clear(); + TeardownAsync().GetAwaiter().GetResult(); } } diff --git a/tests/Netclaw.SmokeMcpServer/Program.cs b/tests/Netclaw.SmokeMcpServer/Program.cs index 840e73e11..21b212496 100644 --- a/tests/Netclaw.SmokeMcpServer/Program.cs +++ b/tests/Netclaw.SmokeMcpServer/Program.cs @@ -20,13 +20,16 @@ // echo(text) -> text // record-tasks(tasks, ref) -> a summary of the structured arguments // process-info() -> process ID and command-line arguments +// sleep(ms) -> waits ms milliseconds, then "awake" // // Determinism is the whole point: add(2, 2) is always 4, so a smoke // scenario can hard-assert on the tool RESULT even though the // surrounding LLM prose is random. `record-tasks` additionally gives // netclaw's schema-driven argument coercion a tool with an // array-of-objects parameter to exercise end to end (see -// SmokeMcpServerArgumentCoercionTests). +// SmokeMcpServerArgumentCoercionTests). `sleep` gives MCP teardown tests +// a way to hold a tool call in flight for a known duration (see +// McpShutdownTeardownTests). // // CRITICAL: stdout is the MCP JSON-RPC protocol channel. Nothing // other than protocol frames may be written to stdout. All @@ -87,6 +90,22 @@ public static string RecordTasks( return $"reference={reference} count={tasks.Length} kinds=[{kinds}]"; } + /// + /// Deterministic-duration tool used to hold a call in flight for teardown + /// tests: the caller knows exactly how long the server will keep the + /// request open, so a test can start this call, trigger client disposal + /// concurrently, and assert on how the in-flight call resolves without + /// racing on real elapsed time to decide whether it was "in flight." + /// + [McpServerTool(Name = "sleep")] + [Description("Sleeps for the given number of milliseconds, then returns 'awake'. Used to hold a call in flight for lifecycle tests.")] + public static async Task Sleep( + [Description("Milliseconds to sleep before returning.")] int ms) + { + await Task.Delay(ms); + return "awake"; + } + [McpServerTool(Name = "process-info")] [Description("Returns this server process ID and command-line arguments for lifecycle tests.")] public static string ProcessInfo() @@ -150,6 +169,7 @@ private static async Task RunStdioAsync() McpServerTool.Create(Echo, new McpServerToolCreateOptions { Name = "echo" }), McpServerTool.Create(RecordTasks, new McpServerToolCreateOptions { Name = "record-tasks" }), McpServerTool.Create(ProcessInfo, new McpServerToolCreateOptions { Name = "process-info" }), + McpServerTool.Create(Sleep, new McpServerToolCreateOptions { Name = "sleep" }), }; var options = new McpServerOptions From c0c8e3b6507a80cad588c12b1d05089ee249671e Mon Sep 17 00:00:00 2001 From: Aaron Stannard Date: Thu, 16 Jul 2026 21:10:21 +0000 Subject: [PATCH 3/4] fix(smoke): update MCP fixtures for smoke server's 5th tool (sleep) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The sleep tool added to Netclaw.SmokeMcpServer for the MCP shutdown teardown tests bumped the smoke server's tool count from 4 to 5, which two end-to-end fixtures still hard-asserted: - tests/smoke/scenarios/mcp-setup.sh failed on the daemon connection log line ("connected (5 tools)" vs expected "(4 tools)") - tests/smoke/tapes/screenshots/mcp-permissions.tape hung forever in its readiness loop grepping for 'connected (4 tools)', so the TUI never launched and both screenshot frames timed out Update both to expect 5 tools and remove the stale approved baselines so the next Screenshot Regression run regenerates them via the documented workflow (tests/smoke/tapes/README.md § Baseline workflow: a run with no baseline fails and uploads the captured actual for review). The server-list baseline must be removed rather than left to fail on its own: its only pixel delta is the single "4"->"5" glyph (AE=146), which sits inside the harness's cursor tolerance (SHOT_AE_TOLERANCE=1000), so CI would keep passing it against the stale image and never emit a fresh actual. Validated locally: run-smoke.sh mcp-setup passes (5/5); the mcp-permissions tape completes with both frames captured, tool grid showing all five rows with the header intact (issue #1424 guard). --- tests/smoke/scenarios/mcp-setup.sh | 10 +++--- .../mcp-permissions-server-list.approved.png | Bin 31660 -> 0 bytes .../mcp-permissions-tool-grid.approved.png | Bin 66822 -> 0 bytes .../tapes/screenshots/mcp-permissions.tape | 33 ++++++++++-------- 4 files changed, 23 insertions(+), 20 deletions(-) delete mode 100644 tests/smoke/screenshots/mcp-permissions-server-list.approved.png delete mode 100644 tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png diff --git a/tests/smoke/scenarios/mcp-setup.sh b/tests/smoke/scenarios/mcp-setup.sh index 5a5b16bd9..61c0b70ce 100755 --- a/tests/smoke/scenarios/mcp-setup.sh +++ b/tests/smoke/scenarios/mcp-setup.sh @@ -87,12 +87,12 @@ else die "daemon log: no 'MCP server ${MCP_SERVER_NAME} connected' line — stdio handshake failed" fi -# The test server exposes exactly four tools (add, echo, record-tasks, process-info) — -# confirm the daemon registered all of them. -if [[ "$connect_line" == *"(4 tools)"* ]]; then - pass "daemon log: MCP server registered 4 tools (add, echo, record-tasks, process-info)" +# The test server exposes exactly five tools (add, echo, record-tasks, +# process-info, sleep) — confirm the daemon registered all of them. +if [[ "$connect_line" == *"(5 tools)"* ]]; then + pass "daemon log: MCP server registered 5 tools (add, echo, record-tasks, process-info, sleep)" else - die "daemon log: expected '(4 tools)' in the connection line, got: $connect_line" + die "daemon log: expected '(5 tools)' in the connection line, got: $connect_line" fi summarize diff --git a/tests/smoke/screenshots/mcp-permissions-server-list.approved.png b/tests/smoke/screenshots/mcp-permissions-server-list.approved.png deleted file mode 100644 index 94100e39913807de02fc94d20898c2e8e878d545..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 31660 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 diff --git a/tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png b/tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png deleted file mode 100644 index c3db20a858a9247e28f7b66be5d1baeda4f295b4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 66822 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 z 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 diff --git a/tests/smoke/tapes/screenshots/mcp-permissions.tape b/tests/smoke/tapes/screenshots/mcp-permissions.tape index 90e437fa0..b12c21023 100644 --- a/tests/smoke/tapes/screenshots/mcp-permissions.tape +++ b/tests/smoke/tapes/screenshots/mcp-permissions.tape @@ -7,10 +7,11 @@ # # Frames captured: # mcp-permissions-server-list — ServerList state: smoke-math appears as -# "Connected, 4 tools" below the header. +# "Connected, 5 tools" below the header. # mcp-permissions-tool-grid — ToolGrid state: header rows (Audience, # Server enabled, Server default) and all -# four tool rows (add, echo, record-tasks, process-info) +# five tool rows (add, echo, record-tasks, +# process-info, sleep) # simultaneously visible. This is the direct # regression check for issue #1424 — the # scroll container must not overwrite the header. @@ -37,7 +38,8 @@ Type "netclaw model set main smoke-llm qwen2:0.5b" Enter Wait+Screen@10s /TAPE\$/ -# Register the deterministic smoke MCP server (add, echo, record-tasks, process-info). +# Register the deterministic smoke MCP server (add, echo, record-tasks, +# process-info, sleep). # --grant-all means every tool is auto-approved for all audiences. Type "netclaw mcp add --transport stdio --grant-all smoke-math -- __NETCLAW_SMOKE_MCP_SERVER__" Enter @@ -48,12 +50,12 @@ Type "netclaw daemon start" Enter Wait+Screen@20s /TAPE\$/ -# Poll until the daemon reports smoke-math as fully connected with 4 tools. +# Poll until the daemon reports smoke-math as fully connected with 5 tools. # Replaces the former fixed Sleep 5s: we wait for the actual CLI signal # rather than guessing. `netclaw mcp list` queries the daemon's cached -# server state; "connected (4 tools)" means the stdio handshake and tool +# server state; "connected (5 tools)" means the stdio handshake and tool # indexing are complete. The Wait+Screen@60s is a safety net for a hard hang. -Type "until netclaw mcp list 2>/dev/null | grep -q 'connected (4 tools)'; do sleep 2; done" +Type "until netclaw mcp list 2>/dev/null | grep -q 'connected (5 tools)'; do sleep 2; done" Enter Wait+Screen@60s /TAPE\$/ Show @@ -63,26 +65,26 @@ Type "netclaw mcp permissions" Enter # ─── Frame 1: ServerList ───────────────────────────────────────────── -# smoke-math should appear as "Connected, 4 tools". Do NOT anchor on -# "smoke-math" or "4 tools" alone — both already sit in the shell +# smoke-math should appear as "Connected, 5 tools". Do NOT anchor on +# "smoke-math" or "5 tools" alone — both already sit in the shell # scrollback before the TUI ever paints: # - "smoke-math" appears in the setup output above ("Added MCP server # 'smoke-math' (stdio)" / "...adjust approvals for 'smoke-math'."). -# - "4 tools" appears in this tape's own typed readiness-loop command, -# still visible on screen: `... grep -q 'connected (4 tools)' ...`. +# - "5 tools" appears in this tape's own typed readiness-loop command, +# still visible on screen: `... grep -q 'connected (5 tools)' ...`. # Immediately after Enter, before the TUI switches to the alternate # screen buffer, Wait+Screen can match that leftover transcript text and # return instantly, capturing the raw shell instead of the rendered TUI # (README.md rule 5: anchor on the *next view*, not text that predates # it). Anchor on TUI-only chrome instead: "MCP Permissions" is the page # title from McpToolPermissionsPage.BuildHeader (proves the alt screen -# painted), and "Connected, 4 tools" is the exact rendered server-row +# painted), and "Connected, 5 tools" is the exact rendered server-row # text from McpToolPermissionsPage.BuildServerList — "{Name} ({Status}, # {ToolCount} tools)" with capital-C Status and a comma, which the -# transcript's lowercase, comma-less "connected (4 tools)" never +# transcript's lowercase, comma-less "connected (5 tools)" never # produces. Neither anchor occurs anywhere in the shell transcript. Wait+Screen@15s /MCP Permissions/ -Wait+Screen@5s /Connected, 4 tools/ +Wait+Screen@5s /Connected, 5 tools/ # Sleep 3s: let the server-list frame fully settle before capturing. The # first match of the anchors above can be a transient render; the # daemon may push a state update (re-index, status refresh) immediately @@ -98,7 +100,7 @@ Screenshot "/tmp/shot-mcp-permissions-server-list.png" # land on an empty server list (daemon cleared it mid-transition), causing # the TUI to navigate to a blank or non-existent tool grid. Wait+Screen@20s /smoke-math/ -Wait+Screen@10s /4 tools/ +Wait+Screen@10s /5 tools/ # Sleep 5s: extended settle guard (was 2s). Daemon MCP state updates can # arrive at any point; 5s provides substantially more headroom under CI # load where the re-index cycle can be slow. @@ -107,7 +109,8 @@ Enter # ─── Frame 2: ToolGrid ─────────────────────────────────────────────── # All header rows (Server, Audience, Server enabled, Server default) plus -# all tool rows (add, echo, record-tasks, process-info) must be visible simultaneously. +# all tool rows (add, echo, record-tasks, process-info, sleep) must be +# visible simultaneously. # If the #1424 regression reappears, tool rows will overwrite the header. # Timeout is 30s (was 15s) to give the tool grid more headroom to load # under CI load. /Server default:/ (with colon) matches the rendered From f30235fb3d5dfe4578dc9b97ef4b55a915a4e0b9 Mon Sep 17 00:00:00 2001 From: Aaron Stannard Date: Sat, 18 Jul 2026 19:15:21 +0000 Subject: [PATCH 4/4] fix(smoke): refresh mcp-permissions baselines from CI-rendered frames MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The previous commit (c0c8e3b65) removed the stale mcp-permissions approved baselines so CI would regenerate them per the documented baseline workflow (tests/smoke/tapes/README.md § Baseline workflow). That run failed as expected ("no approved baseline") and uploaded the actual frames. Reviewed both actual frames from run 29535030964: - mcp-permissions-server-list: shows smoke-math (Connected, 5 tools) - mcp-permissions-tool-grid: shows all 5 tool rows (add, echo, process-info, record-tasks, sleep) with the header intact Committing the CI-rendered PNGs as the new approved baselines. --- .../mcp-permissions-server-list.approved.png | Bin 0 -> 31661 bytes .../mcp-permissions-tool-grid.approved.png | Bin 0 -> 69964 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/smoke/screenshots/mcp-permissions-server-list.approved.png create mode 100644 tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png diff --git a/tests/smoke/screenshots/mcp-permissions-server-list.approved.png b/tests/smoke/screenshots/mcp-permissions-server-list.approved.png new file mode 100644 index 0000000000000000000000000000000000000000..46be08c5ab17f890fb48cd85b00dd4a6f2d8b4dd GIT binary patch literal 31661 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 literal 0 HcmV?d00001 diff --git a/tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png b/tests/smoke/screenshots/mcp-permissions-tool-grid.approved.png new file mode 100644 index 0000000000000000000000000000000000000000..59077e5c512cc545257373069abb94f643a1fa3c GIT binary patch literal 69964 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 z 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

{_8n?AR zY{PATUaEux|PQP`{UudZUp$oq|~W>`vj&ytrxct?jOqH0gdk* zK8HYE1|Tq#6nK(Ua(|Hl4o4c&E!-fX9t=gS&p7Xp5BlxibFHWz1D_gs@H8mI8o91v zHj6&hA+MQiX0Yy?bA&nlkxk7+Udh{##e)n&F--wAsE9grn6$DBFh9@ZY0ovMnv*GU z`OPFL+4h(tqEF_PmdymA02wB7FyiSzzNZ=d#k+mw+FrXvUygkwEQEQJer3^k45k&e zE|UQ!MM8tPnik7PkFHfMbxRTF59wwn*LWcZlPeQN!}&Wc;lXNBuiEe(`+S3`6`_^1 zPw;Kz4Qi7%br$LldfN0lLEHZ`I)nZTu8iHJdTQ2Tj3Jr zCw~)B%2}MPrb-l>B^j&?#;)HC-~~Q%te#&MCrfJ}oz6$VA3%cLy!NhQg9^@Rq0pf? zbcjm7TBcH^vei+^7zm)uL6G3q;fr!`)pcK=)6$oF+OUqy<9WwW{jr^u84C$V`dnpV}&5TB^R_PVF!)JJcX)ILS4SYNT(Ya_H#j2xi?$x>+UIMk1_L_ zBqT3JOujGeT%8(ExQP5Bs#{0da$Jm$imsqe9u%pIkDcRo911KAWf3MgOA`Yfi@c)V z4dNQt!P^HxV-rM#vm?fUUi`nZ4UHb;D$$I@A6>jMWiVOm6XYK9yow)yZcNvYKOa|A z80hE-t%}@b&?yj2OHq15HTKZc51l_(Y%C@KrD>FtFg%f_2HWWs@SeMqvbMjoVw%^sKmFsrt{bTF*8o{3z|yr&<=aP9Xq$7Zp(-4D{2 z*V4y8cJ|F6Z@s?JDwp&_A6%hp#*lfZ!oXfjOhiIiM*)aD1)mPDCAg7JcNA!7;hGsi z9t@bJx-;*w@$yd3x?#}RSxp0*2Z0_&UIH`whhyx?E+UZV0;&tqUg@lo`tEXLO17JI zfB%pc#!678SNDDd>HhWg0ApgKo89By79(Vqy*h|v{0i=OngoOk`t$>%Y)a6a`0~yi znhO*>eTI-UCy2r!qC|(BSPYCFCi%6k+n^AquGfy1vfb zm#e8773^K-n`arcYV(a#S97^PU2_BoaM?oqeU zn@I;8PXyf)*}Wd3TO@6I(p}K;osX#Z9~K<0Zt_20JEEA{$GLt}buY5@jLqRo`%0<|wGZtVG2*D7 zoZRf{!+(xHnp(YJ8N|9X_Lr(d<6m*t>))EQXJ6l6ssC>Oj6;jUjf-c0 zs!huXVMM}jJ5^nNtvR`_uyr=7)X#!QEPqnrpx4wXBsr?sR7F zr`RNxNB$~Oj}Vf~&aNvwp-t%N?tFXxh|$YRX<~6$PvNNpzx{Jf1GUs5-S7UC`13*b z`9D9HT#^h^?7Xhn`z7s3qW4F!4gxmJ>*}2El+D+A1yi}d? zy zu9R4wz%F$@sM_;`h8?&ur`E4>O-g+Qg+AxivAXVX@y})SS}vKR}-*&mw;Jsq$gIUp3v`E`eu8CLf(VNwSSe=- zrQGGrtZ=1NJf7HAO!Ru0fv^8_%@CX}_Wu=Az6AkYbLe?wk}lG&moI2`ka@8Qm4kU> zHueQ$tJ0~&z*zdeZe@S3E$zID3|TSP?6}YmDc0MafzDBu{SWIrQS|bGwK1yh=3}Fp z^gdxr)UzKr`i~dU#|WbPxygPuns+{({WG;|q#Vl1Wj}HQ51rPRc;j@}BB1RqL?aBL zLyhFkX@b?$eyv(!{vn^TaiAFM{wj*83G_r<{d;zxScGcun7P;a`G(`)6kQ&IU0<=C wRqF_f&uWbEKUHAVo#M=s$NssVns5(%;c>^_YdP%x-B)t=w&^Y8jb|_aKkowE>i_@% literal 0 HcmV?d00001