From 59280ef312ca60ebc10d59efb92bfaed56fec61e Mon Sep 17 00:00:00 2001 From: Scott Stauffer Date: Wed, 11 Nov 2026 20:22:01 -0600 Subject: [PATCH 1/2] feat(mcp): connect MCP servers a launcher provides in FUSERAFT_MCP_SERVERS - Lets fuseraft-web configure MCP servers once for every account, without writing into each user's config; tokens travel as separate *_TOKEN env vars referenced by ${VAR}, so they're masked like any other secret - The REPL merges them with saved servers, and a saved server of the same name wins so users can still override one - Orchestration connects one only when an agent lists it in Plugins; a server that's down registers no tools and warns instead of failing the run --- docs/mcp.md | 23 ++++++ src/Cli/Commands/Repl/ReplCommand.cs | 5 +- src/Cli/Commands/Repl/ReplCommands.Mcp.cs | 9 ++ src/Cli/OrchestratorBuilder.cs | 28 +++++++ .../Storage/ManagedMcpServers.cs | 60 ++++++++++++++ .../ManagedMcpServersTests.cs | 82 +++++++++++++++++++ .../OrchestratorBuilderManagedMcpTests.cs | 44 ++++++++++ 7 files changed, 250 insertions(+), 1 deletion(-) create mode 100644 src/Infrastructure/Storage/ManagedMcpServers.cs create mode 100644 tests/FuseraftCli.Tests/ManagedMcpServersTests.cs create mode 100644 tests/FuseraftCli.Tests/OrchestratorBuilderManagedMcpTests.cs diff --git a/docs/mcp.md b/docs/mcp.md index a94ed83d..824a97f5 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -190,6 +190,29 @@ The agent then sees all tools from the Puppeteer server alongside the built-in F --- +## Servers provided by the launcher + +A program that starts fuseraft can give it MCP servers of its own through the `FUSERAFT_MCP_SERVERS` +environment variable: a JSON array of the `McpServerConfig` fields above. fuseraft-web uses this for the +MCP servers an admin adds on its MCP servers page, which reach every account's chats and runs. + +```sh +export SQL_MCP_TOKEN=... +export FUSERAFT_MCP_SERVERS='[{"Name":"Sql","Transport":"http","Url":"http://localhost:8080/mcp", + "TransportMode":"streamable-http","Headers":{"Authorization":"Bearer ${SQL_MCP_TOKEN}"}}]' +``` + +Keep secrets in their own variables and refer to them with `${NAME}`, as above. Values of variables whose +names look like secrets (`..._TOKEN`, `..._KEY`) are masked in tool output; `FUSERAFT_MCP_SERVERS` itself isn't. + +- **REPL**: each one connects at startup along with your saved servers, and `/mcp list` marks it *provided by + the launcher*. A saved server with the same name is used instead. `/mcp remove` drops it for the session only. +- **Orchestration**: one connects only if an agent names it in `Plugins` and the config's own `McpServers` + doesn't use the name. If it can't connect, the run logs a warning and carries on without its tools, rather + than failing as a server in `McpServers` would. + +--- + ## Building your own MCP server Any MCP-compliant server works. For .NET, use the `ModelContextProtocol` NuGet package. diff --git a/src/Cli/Commands/Repl/ReplCommand.cs b/src/Cli/Commands/Repl/ReplCommand.cs index a17d8fa6..8af7d4e8 100644 --- a/src/Cli/Commands/Repl/ReplCommand.cs +++ b/src/Cli/Commands/Repl/ReplCommand.cs @@ -660,7 +660,10 @@ private async Task RunAsync( activePlugins.Add(p); } - foreach (var server in ReplMcpServerStore.Load()) + var managedMcp = ManagedMcpServers.Load(out var managedMcpError); + if (managedMcpError is not null) + AnsiConsole.MarkupLine($"[yellow]⚠ {Markup.Escape(managedMcpError)}[/]"); + foreach (var server in ManagedMcpServers.Merge(ReplMcpServerStore.Load(), managedMcp)) { try { diff --git a/src/Cli/Commands/Repl/ReplCommands.Mcp.cs b/src/Cli/Commands/Repl/ReplCommands.Mcp.cs index c742db8c..09f4ff89 100644 --- a/src/Cli/Commands/Repl/ReplCommands.Mcp.cs +++ b/src/Cli/Commands/Repl/ReplCommands.Mcp.cs @@ -84,6 +84,7 @@ private static CommandResult CmdMcpList(ReplSessionContext ctx) var name = category[McpCategoryPrefix.Length..]; var stopped = ctx.McpManager?.IsRunning(name) == false; AnsiConsole.MarkupLine($" [bold cyan]{Markup.Escape(name)}[/] [dim]({tools.Count} tool(s))[/]" + + (IsManagedOnly(name) ? " [dim]· provided by the launcher[/]" : "") + (stopped ? $" [yellow]not running[/] [dim]— /mcp reconnect {Markup.Escape(name)}[/]" : "")); foreach (var t in tools) AnsiConsole.MarkupLine($" [dim]·[/] {Markup.Escape(t.Name)}"); @@ -91,6 +92,11 @@ private static CommandResult CmdMcpList(ReplSessionContext ctx) return CommandResult.Continue; } + // Came from whatever launched fuseraft (FUSERAFT_MCP_SERVERS), with no saved server of the name standing in front of it. + private static bool IsManagedOnly(string name) => + ManagedMcpServers.Load(out _).Any(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) + && !ReplMcpServerStore.Load().Any(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); + private static async Task CmdMcpAddAsync( ReplSessionContext ctx, string arg, CancellationToken cancellationToken) { @@ -479,6 +485,7 @@ private static async Task CmdMcpRemoveAsync(ReplSessionContext ct ctx.DisabledCategories.Remove(category); ctx.ChatOptions = ctx.BuildChatOptions(); + var managedOnly = IsManagedOnly(name); var saved = ReplMcpServerStore.Load(); var removed = saved.Where(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ToList(); @@ -511,6 +518,8 @@ private static async Task CmdMcpRemoveAsync(ReplSessionContext ct AnsiConsole.MarkupLine(disconnected ? $"[green]Removed '{Markup.Escape(name)}'[/] [dim]and closed its connection.[/]" : $"[green]Removed '{Markup.Escape(name)}'.[/] [dim]Its tools are no longer offered to the model.[/]"); + if (managedOnly) + AnsiConsole.MarkupLine("[dim]Whatever launched fuseraft provides it, so it's back in your next session.[/]"); return CommandResult.Continue; } } diff --git a/src/Cli/OrchestratorBuilder.cs b/src/Cli/OrchestratorBuilder.cs index 1367dbbc..c552265e 100644 --- a/src/Cli/OrchestratorBuilder.cs +++ b/src/Cli/OrchestratorBuilder.cs @@ -333,6 +333,30 @@ private sealed record InfrastructureResult( string? ReadCachePath, Action RebindSessionScopedState); + // A server-provided MCP server serves every run on the machine, so it's connected only for a config whose agents + // name it in Plugins, and one that's down costs that agent its tools rather than failing the run. + internal static async Task ConnectManagedMcpServersAsync(OrchestrationConfig config, IReadOnlyList managed, + McpSessionManager mcpManager, PluginRegistry pluginRegistry, ILogger logger, CancellationToken cancellationToken) + { + var wanted = ManagedMcpServers.ReferencedBy(managed, config.McpServers, config.Agents.SelectMany(a => a.Plugins)); + foreach (var server in wanted) + { + try + { + var (_, tools) = await mcpManager.ConnectSingleAsync(server, cancellationToken); + pluginRegistry.RegisterAIFunctions(server.Name, tools); + logger.LogInformation("Connected server-provided MCP server '{Name}' ({Count} tool(s)).", server.Name, tools.Count); + } + catch (Exception ex) when (ex is not OperationCanceledException || !cancellationToken.IsCancellationRequested) + { + // Registered empty, so an agent that lists it still builds instead of failing on an unknown plugin. + pluginRegistry.RegisterAIFunctions(server.Name, []); + logger.LogWarning("Could not connect server-provided MCP server '{Name}': {Error}. Agents that list it run without its tools.", + server.Name, ex.Message); + } + } + } + private static async Task InitInfrastructure( OrchestrationConfig config, PluginRegistry pluginRegistry, @@ -349,6 +373,10 @@ private static async Task InitInfrastructure( var mcpManager = new McpSessionManager(loggerFactory); if (config.McpServers.Count > 0) await mcpManager.InitializeAsync(config.McpServers, pluginRegistry, cancellationToken); + var mcpLogger = loggerFactory.CreateLogger("fuseraft.Mcp"); + var managedMcp = ManagedMcpServers.Load(out var managedMcpError); + if (managedMcpError is not null) mcpLogger.LogWarning("{Error}", managedMcpError); + await ConnectManagedMcpServersAsync(config, managedMcp, mcpManager, pluginRegistry, mcpLogger, cancellationToken); EventEmitter? eventEmitter = config.Events is { } evtCfg ? new EventEmitter(evtCfg.Path, loggerFactory.CreateLogger()) diff --git a/src/Infrastructure/Storage/ManagedMcpServers.cs b/src/Infrastructure/Storage/ManagedMcpServers.cs new file mode 100644 index 00000000..aaee1bc7 --- /dev/null +++ b/src/Infrastructure/Storage/ManagedMcpServers.cs @@ -0,0 +1,60 @@ +using System.Text.Json; +using fuseraft.Core.Models.Config; + +namespace fuseraft.Infrastructure.Storage; + +/// +/// MCP servers handed to fuseraft by whatever launched it (fuseraft-web's server-wide MCP servers) through the +/// FUSERAFT_MCP_SERVERS environment variable: a JSON array of . They join the +/// REPL's saved servers and an orchestration config's McpServers, and are never written to either. +/// +public static class ManagedMcpServers +{ + public const string EnvVar = "FUSERAFT_MCP_SERVERS"; + + private static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true }; + + /// The servers in ; says why it couldn't be read. + public static List Load(out string? error) => + Parse(Environment.GetEnvironmentVariable(EnvVar), out error); + + internal static List Parse(string? json, out string? error) + { + error = null; + if (string.IsNullOrWhiteSpace(json)) return []; + try + { + var servers = JsonSerializer.Deserialize>(json, Json) ?? []; + var named = servers.OfType().Where(s => !string.IsNullOrWhiteSpace(s.Name)).ToList(); + if (named.Count < servers.Count) + error = $"{EnvVar} has {servers.Count - named.Count} server(s) without a Name; they were skipped."; + return named; + } + catch (JsonException ex) + { + error = $"{EnvVar} isn't a JSON array of MCP servers ({ex.Message}); none of its servers were connected."; + return []; + } + } + + /// + /// followed by the managed servers whose names it doesn't already use, so a config or a + /// user's saved server keeps a name it chose. + /// + public static List Merge(IEnumerable own, IEnumerable managed) + { + var result = own.ToList(); + var names = new HashSet(result.Select(s => s.Name), StringComparer.OrdinalIgnoreCase); + result.AddRange(managed.Where(s => names.Add(s.Name))); + return result; + } + + /// The managed servers an orchestration's agents name in Plugins, unless its own McpServers uses the name. + public static List ReferencedBy(IEnumerable managed, + IEnumerable own, IEnumerable plugins) + { + var used = new HashSet(plugins, StringComparer.OrdinalIgnoreCase); + var taken = new HashSet(own.Select(s => s.Name), StringComparer.OrdinalIgnoreCase); + return [.. managed.Where(s => used.Contains(s.Name) && taken.Add(s.Name))]; + } +} diff --git a/tests/FuseraftCli.Tests/ManagedMcpServersTests.cs b/tests/FuseraftCli.Tests/ManagedMcpServersTests.cs new file mode 100644 index 00000000..c7341354 --- /dev/null +++ b/tests/FuseraftCli.Tests/ManagedMcpServersTests.cs @@ -0,0 +1,82 @@ +using fuseraft.Core.Models.Config; +using fuseraft.Infrastructure.Storage; + +namespace FuseraftCli.Tests; + +public class ManagedMcpServersTests +{ + [Fact] + public void Parse_ReadsHttpServerWithHeaders() + { + var servers = ManagedMcpServers.Parse(""" + [{"name":"Sql","transport":"http","url":"http://localhost:8080/mcp","transportMode":"streamable-http", + "headers":{"Authorization":"Bearer ${FUSERAFT_WEB_MCP_1_TOKEN}"}}] + """, out var error); + + Assert.Null(error); + var s = Assert.Single(servers); + Assert.Equal("Sql", s.Name); + Assert.Equal("http", s.Transport); + Assert.Equal("streamable-http", s.TransportMode); + Assert.Equal("Bearer ${FUSERAFT_WEB_MCP_1_TOKEN}", s.Headers["Authorization"]); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + public void Parse_UnsetIsEmptyWithoutError(string? json) + { + Assert.Empty(ManagedMcpServers.Parse(json, out var error)); + Assert.Null(error); + } + + [Fact] + public void Parse_InvalidJsonIsEmptyWithError() + { + Assert.Empty(ManagedMcpServers.Parse("{not json", out var error)); + Assert.Contains("isn't a JSON array", error); + } + + [Fact] + public void Parse_SkipsServersWithoutAName() + { + var servers = ManagedMcpServers.Parse("""[{"url":"http://a/mcp"},{"name":"B","transport":"http","url":"http://b/mcp"}]""", out var error); + + Assert.Equal("B", Assert.Single(servers).Name); + Assert.Contains("without a Name", error); + } + + // fuseraft-web passes each server's token as FUSERAFT_WEB_MCP__TOKEN and relies on its value being masked. + [Fact] + public void LauncherTokenVariables_AreMaskedAsSecrets() => + Assert.True(fuseraft.Infrastructure.Plugins.EnvSecretMasker.IsSensitiveName("FUSERAFT_WEB_MCP_1_TOKEN")); + + [Fact] + public void Merge_KeepsOwnServerOfTheSameName() + { + var own = new McpServerConfig { Name = "sql", Url = "http://mine/mcp" }; + var managed = new[] { new McpServerConfig { Name = "Sql", Url = "http://server/mcp" }, new McpServerConfig { Name = "Docs" } }; + + var merged = ManagedMcpServers.Merge([own], managed); + + Assert.Equal(["sql", "Docs"], merged.Select(s => s.Name)); + Assert.Equal("http://mine/mcp", merged[0].Url); + } + + [Fact] + public void ReferencedBy_OnlyServersAnAgentNamesAndTheConfigDoesNotDeclare() + { + var managed = new[] + { + new McpServerConfig { Name = "Sql" }, + new McpServerConfig { Name = "Docs" }, + new McpServerConfig { Name = "Jira" }, + }; + var own = new[] { new McpServerConfig { Name = "docs" } }; + + var wanted = ManagedMcpServers.ReferencedBy(managed, own, ["FileSystem", "sql", "Docs"]); + + Assert.Equal("Sql", Assert.Single(wanted).Name); + } +} diff --git a/tests/FuseraftCli.Tests/OrchestratorBuilderManagedMcpTests.cs b/tests/FuseraftCli.Tests/OrchestratorBuilderManagedMcpTests.cs new file mode 100644 index 00000000..49964c93 --- /dev/null +++ b/tests/FuseraftCli.Tests/OrchestratorBuilderManagedMcpTests.cs @@ -0,0 +1,44 @@ +using fuseraft.Cli; +using fuseraft.Core.Models; +using fuseraft.Core.Models.Config; +using fuseraft.Infrastructure.Mcp; +using fuseraft.Infrastructure.Plugins; +using Microsoft.Extensions.Logging.Abstractions; + +namespace FuseraftCli.Tests; + +public sealed class OrchestratorBuilderManagedMcpTests +{ + [Fact] + public async Task UnreachableServer_IsRegisteredWithNoTools_SoTheAgentStillBuilds() + { + var config = new OrchestrationConfig + { + Agents = [new AgentConfig { Name = "Analyst", Plugins = ["Sql"] }], + }; + // Port 1 on loopback refuses at once. + var managed = new[] { new McpServerConfig { Name = "Sql", Transport = "http", Url = "http://127.0.0.1:1/mcp", TransportMode = "streamable-http" } }; + var registry = new PluginRegistry(); + await using var manager = new McpSessionManager(); + + await OrchestratorBuilder.ConnectManagedMcpServersAsync(config, managed, manager, registry, + NullLogger.Instance, CancellationToken.None); + + Assert.True(registry.TryGetAIFunctions("Sql", out var tools)); + Assert.Empty(tools); + } + + [Fact] + public async Task ServerNoAgentNames_IsNotConnected() + { + var config = new OrchestrationConfig { Agents = [new AgentConfig { Name = "Dev", Plugins = ["FileSystem"] }] }; + var managed = new[] { new McpServerConfig { Name = "Sql", Transport = "http", Url = "http://127.0.0.1:1/mcp" } }; + var registry = new PluginRegistry(); + await using var manager = new McpSessionManager(); + + await OrchestratorBuilder.ConnectManagedMcpServersAsync(config, managed, manager, registry, + NullLogger.Instance, CancellationToken.None); + + Assert.False(registry.TryGetAIFunctions("Sql", out _)); + } +} From 70d35eb59af916c2722a11afc6b85a6c3a777725 Mon Sep 17 00:00:00 2001 From: Scott Stauffer Date: Wed, 11 Nov 2026 22:56:51 -0600 Subject: [PATCH 2/2] fix(mcp): remove and reconnect servers that didn't connect at startup - /mcp remove refused any server not connected this session, so a saved server that was down could never be forgotten - /mcp reconnect only looked in the saved list, so a launcher-provided server that failed at startup couldn't be retried --- src/Cli/Commands/Repl/ReplCommands.Mcp.cs | 27 ++-- .../ReplCommandsMcpServerLifecycleTests.cs | 128 ++++++++++++++++++ 2 files changed, 146 insertions(+), 9 deletions(-) create mode 100644 tests/FuseraftCli.Tests/ReplCommandsMcpServerLifecycleTests.cs diff --git a/src/Cli/Commands/Repl/ReplCommands.Mcp.cs b/src/Cli/Commands/Repl/ReplCommands.Mcp.cs index 09f4ff89..b229a2e8 100644 --- a/src/Cli/Commands/Repl/ReplCommands.Mcp.cs +++ b/src/Cli/Commands/Repl/ReplCommands.Mcp.cs @@ -280,7 +280,8 @@ private static async Task CmdMcpReconnectAsync( return CommandResult.Continue; } - var config = ctx.McpManager?.ConfigOf(name) ?? ReplMcpServerStore.Load() + // One that failed at startup isn't in the manager, so it's looked up where it came from. + var config = ctx.McpManager?.ConfigOf(name) ?? ManagedMcpServers.Merge(ReplMcpServerStore.Load(), ManagedMcpServers.Load(out _)) .FirstOrDefault(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); if (config is null) { @@ -477,18 +478,24 @@ private static async Task CmdMcpRemoveAsync(ReplSessionContext ct } var category = $"{McpCategoryPrefix}{name}"; - if (!ctx.ToolsByCategory.Remove(category)) + var managedOnly = IsManagedOnly(name); + var saved = ReplMcpServerStore.Load(); + var removed = saved.Where(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ToList(); + + // A saved server that couldn't connect this session is still one to forget. + var connected = ctx.ToolsByCategory.Remove(category); + if (!connected && removed.Count == 0) { - AnsiConsole.MarkupLine($"[yellow]No connected MCP server named '{Markup.Escape(name)}'.[/]"); + AnsiConsole.MarkupLine($"[yellow]No MCP server named '{Markup.Escape(name)}' is connected or saved.[/]"); return CommandResult.Continue; } - ctx.DisabledCategories.Remove(category); - ctx.ChatOptions = ctx.BuildChatOptions(); - var managedOnly = IsManagedOnly(name); + if (connected) + { + ctx.DisabledCategories.Remove(category); + ctx.ChatOptions = ctx.BuildChatOptions(); + } - var saved = ReplMcpServerStore.Load(); - var removed = saved.Where(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ToList(); if (removed.Count > 0) { saved.RemoveAll(s => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); @@ -517,7 +524,9 @@ private static async Task CmdMcpRemoveAsync(ReplSessionContext ct AnsiConsole.MarkupLine(disconnected ? $"[green]Removed '{Markup.Escape(name)}'[/] [dim]and closed its connection.[/]" - : $"[green]Removed '{Markup.Escape(name)}'.[/] [dim]Its tools are no longer offered to the model.[/]"); + : connected + ? $"[green]Removed '{Markup.Escape(name)}'.[/] [dim]Its tools are no longer offered to the model.[/]" + : $"[green]Removed '{Markup.Escape(name)}'[/] [dim]from your saved servers.[/]"); if (managedOnly) AnsiConsole.MarkupLine("[dim]Whatever launched fuseraft provides it, so it's back in your next session.[/]"); return CommandResult.Continue; diff --git a/tests/FuseraftCli.Tests/ReplCommandsMcpServerLifecycleTests.cs b/tests/FuseraftCli.Tests/ReplCommandsMcpServerLifecycleTests.cs new file mode 100644 index 00000000..d3317f62 --- /dev/null +++ b/tests/FuseraftCli.Tests/ReplCommandsMcpServerLifecycleTests.cs @@ -0,0 +1,128 @@ +using Microsoft.Extensions.AI; +using fuseraft.Cli.Commands.Repl; +using fuseraft.Core; +using fuseraft.Core.Models.Config; +using fuseraft.Infrastructure.Chat; +using fuseraft.Infrastructure.KeyStore; +using fuseraft.Infrastructure.Storage; + +namespace FuseraftCli.Tests; + +/// /mcp remove and /mcp reconnect for servers that didn't connect when the session started. +[Collection("FuseraftHomeEnv")] +public sealed class ReplCommandsMcpServerLifecycleTests : IDisposable +{ + private readonly string? _originalHome = Environment.GetEnvironmentVariable(FuseraftPaths.HomeOverrideEnvVar); + private readonly string _tempHome = Path.Combine(Path.GetTempPath(), $"fuseraft-test-{Guid.NewGuid():N}"); + private readonly List _contexts = []; + + public ReplCommandsMcpServerLifecycleTests() => + Environment.SetEnvironmentVariable(FuseraftPaths.HomeOverrideEnvVar, _tempHome); + + public void Dispose() + { + Environment.SetEnvironmentVariable(ManagedMcpServers.EnvVar, null); + foreach (var ctx in _contexts) + { + ctx.Emitter.Dispose(); + ctx.Factory.Dispose(); + } + Environment.SetEnvironmentVariable(FuseraftPaths.HomeOverrideEnvVar, _originalHome); + if (Directory.Exists(_tempHome)) Directory.Delete(_tempHome, recursive: true); + } + + private sealed class NoopChatClient : IChatClient + { + public Task GetResponseAsync( + IEnumerable messages, ChatOptions? options = null, CancellationToken cancellationToken = default) + => Task.FromResult(new ChatResponse(new ChatMessage(ChatRole.Assistant, string.Empty))); + public IAsyncEnumerable GetStreamingResponseAsync( + IEnumerable messages, ChatOptions? options = null, CancellationToken cancellationToken = default) + => AsyncEnumerable.Empty(); + public object? GetService(Type serviceType, object? key = null) => null; + public void Dispose() { } + } + + private ReplSessionContext NewContext(Dictionary> toolsByCategory) + { + Directory.CreateDirectory(_tempHome); + var eventsPath = Path.Combine(_tempHome, $"events-{Guid.NewGuid():N}.jsonl"); + var ctx = new ReplSessionContext( + cwd: _tempHome, sessionId: "mcp-remove-session", startedAt: DateTime.UtcNow, + modelId: "test-model", modelConfig: new() { ModelId = "test-model" }, + userCfg: null, client: new NoopChatClient(), factory: new ChatClientFactory(), + keyStore: new UnavailableKeyStore(), + emitter: new EventEmitter(eventsPath), + eventsPath: eventsPath, + memoryStore: MemoryStore.CreateForTest(Path.Combine(_tempHome, "mem")), + toolsByCategory: toolsByCategory, systemPrompt: "test system prompt", pendingSave: false, + adaptiveTrimTracker: new()); + ctx.JsonMode = true; + _contexts.Add(ctx); + return ctx; + } + + private static McpServerConfig Saved(string name) => + new() { Name = name, Transport = "http", Url = "http://127.0.0.1:1/mcp" }; + + [Fact] + public async Task Remove_SavedServerThatIsNotConnected_ForgetsIt() + { + ReplMcpServerStore.Save([Saved("Sql"), Saved("Jira")]); + var ctx = NewContext(new(StringComparer.OrdinalIgnoreCase)); + + await ReplCommands.HandleAsync(ctx, "/mcp", "remove sql", CancellationToken.None); + + Assert.Equal(["Jira"], ReplMcpServerStore.Load().Select(s => s.Name)); + } + + [Fact] + public async Task Remove_ConnectedServer_DropsToolsAndSavedEntry() + { + ReplMcpServerStore.Save([Saved("Sql")]); + var ctx = NewContext(new(StringComparer.OrdinalIgnoreCase) + { + ["mcp:Sql"] = [AIFunctionFactory.Create(() => "ok", "query_database")], + }); + + await ReplCommands.HandleAsync(ctx, "/mcp", "remove Sql", CancellationToken.None); + + Assert.Empty(ReplMcpServerStore.Load()); + Assert.False(ctx.ToolsByCategory.ContainsKey("mcp:Sql")); + } + + [Fact] + public async Task Remove_UnknownServer_LeavesSavedServersAlone() + { + ReplMcpServerStore.Save([Saved("Sql")]); + var ctx = NewContext(new(StringComparer.OrdinalIgnoreCase)); + + await ReplCommands.HandleAsync(ctx, "/mcp", "remove Nope", CancellationToken.None); + + Assert.Equal(["Sql"], ReplMcpServerStore.Load().Select(s => s.Name)); + } + + [Fact] + public async Task Reconnect_LauncherServerThatDidNotConnect_TriesToConnectIt() + { + Environment.SetEnvironmentVariable(ManagedMcpServers.EnvVar, + "[{\"Name\":\"Jira\",\"Transport\":\"http\",\"Url\":\"http://127.0.0.1:1/mcp\"}]"); + var ctx = NewContext(new(StringComparer.OrdinalIgnoreCase)); + + await ReplCommands.HandleAsync(ctx, "/mcp", "reconnect Jira", CancellationToken.None); + + // Only an attempt to connect creates the manager; an unknown name returns before that. + Assert.NotNull(ctx.McpManager); + Assert.False(ctx.ToolsByCategory.ContainsKey("mcp:Jira")); + } + + [Fact] + public async Task Reconnect_UnknownServer_DoesNotTryToConnect() + { + var ctx = NewContext(new(StringComparer.OrdinalIgnoreCase)); + + await ReplCommands.HandleAsync(ctx, "/mcp", "reconnect Nope", CancellationToken.None); + + Assert.Null(ctx.McpManager); + } +}