feat: ensuring tool success

Author: CalvinAllen

assets/logo.png

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json.schemastore.org/vsix-publish",
+  "categories": [
+    "coding",
+    "other"
+  ],
+  "identity": {
+    "internalName": "VS-VSMCP"
+  },
+  "overview": "../README.md",
+  "publisher": "CodingWithCalvin",
+  "qna": true,
+  "repo": "https://www.github.com/CodingWithCalvin/VS-VSMCP"
+}

resources/publish.manifest.json

@@ -8,6 +8,9 @@
     <ImplicitUsings>disable</ImplicitUsings>
     <RootNamespace>CodingWithCalvin.VSMCP.Server</RootNamespace>
     <AssemblyName>CodingWithCalvin.VSMCP.Server</AssemblyName>
+    <PublishSingleFile>true</PublishSingleFile>
+    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+    <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
   </PropertyGroup>
 
   <ItemGroup>

src/CodingWithCalvin.VSMCP.Server/CodingWithCalvin.VSMCP.Server.csproj

@@ -1,10 +1,13 @@
 using System;
 using System.CommandLine;
+using System.Threading;
 using System.Threading.Tasks;
 using CodingWithCalvin.VSMCP.Server;
 using CodingWithCalvin.VSMCP.Server.Tools;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using ModelContextProtocol.AspNetCore;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
@@ -16,6 +19,11 @@
     IsRequired = true
 };
 
+var hostOption = new Option<string>(
+    name: "--host",
+    getDefaultValue: () => "localhost",
+    description: "Host address to bind the HTTP server to (e.g., localhost, 0.0.0.0, *)");
+
 var portOption = new Option<int>(
     name: "--port",
     getDefaultValue: () => 5050,
@@ -26,31 +34,55 @@
     getDefaultValue: () => "Visual Studio MCP",
     description: "Server name displayed to MCP clients");
 
+var logLevelOption = new Option<string>(
+    name: "--log-level",
+    getDefaultValue: () => "Information",
+    description: "Minimum log level (Error, Warning, Information, Debug)");
+
 var rootCommand = new RootCommand("Visual Studio MCP Server")
 {
     pipeOption,
+    hostOption,
     portOption,
-    nameOption
+    nameOption,
+    logLevelOption
 };
 
-rootCommand.SetHandler(async (string pipeName, int port, string serverName) =>
+rootCommand.SetHandler(async (string pipeName, string host, int port, string serverName, string logLevel) =>
 {
-    await RunServerAsync(pipeName, port, serverName);
-}, pipeOption, portOption, nameOption);
+    await RunServerAsync(pipeName, host, port, serverName, logLevel);
+}, pipeOption, hostOption, portOption, nameOption, logLevelOption);
 
 return await rootCommand.InvokeAsync(args);
 
-static async Task RunServerAsync(string pipeName, int port, string serverName)
+static async Task RunServerAsync(string pipeName, string host, int port, string serverName, string logLevel)
 {
+    // Parse log level
+    var msLogLevel = logLevel switch
+    {
+        "Error" => LogLevel.Error,
+        "Warning" => LogLevel.Warning,
+        "Debug" => LogLevel.Debug,
+        _ => LogLevel.Information
+    };
+
+    // Create shutdown token for graceful shutdown
+    using var shutdownCts = new CancellationTokenSource();
+
     // Connect to Visual Studio via named pipe
-    var rpcClient = new RpcClient();
+    var rpcClient = new RpcClient(shutdownCts);
     await rpcClient.ConnectAsync(pipeName);
 
     Console.Error.WriteLine($"Connected to Visual Studio via pipe: {pipeName}");
 
     // Build the web application
     var builder = WebApplication.CreateBuilder();
 
+    // Configure logging
+    builder.Logging.SetMinimumLevel(msLogLevel);
+    builder.Logging.AddFilter("Microsoft.AspNetCore", msLogLevel);
+    builder.Logging.AddFilter("ModelContextProtocol", msLogLevel);
+
     builder.Services.AddSingleton(rpcClient);
 
     builder.Services.AddMcpServer(options =>
@@ -70,7 +102,16 @@ static async Task RunServerAsync(string pipeName, int port, string serverName)
 
     app.MapMcp();
 
-    Console.Error.WriteLine($"MCP Server listening on http://localhost:{port}");
+    var bindingUrl = $"http://{host}:{port}";
+    app.Urls.Add(bindingUrl);
+
+    // Register shutdown token to stop the application
+    var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();
+    shutdownCts.Token.Register(() => lifetime.StopApplication());
+
+    Console.Error.WriteLine($"MCP Server listening on {bindingUrl} (LogLevel: {logLevel})");
+
+    await app.RunAsync();
 
-    await app.RunAsync($"http://localhost:{port}");
+    Console.Error.WriteLine("Server shutdown complete");
 }

src/CodingWithCalvin.VSMCP.Server/Program.cs

@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "CodingWithCalvin.VSMCP.Server": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:57573;http://localhost:57574"
+    }
+  }
+}

src/CodingWithCalvin.VSMCP.Server/Properties/launchSettings.json

@@ -1,22 +1,34 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO.Pipes;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using CodingWithCalvin.VSMCP.Shared;
 using CodingWithCalvin.VSMCP.Shared.Models;
+using ModelContextProtocol.Server;
 using StreamJsonRpc;
 
 namespace CodingWithCalvin.VSMCP.Server;
 
-public class RpcClient : IVisualStudioRpc, IDisposable
+public class RpcClient : IVisualStudioRpc, IServerRpc, IDisposable
 {
+    private readonly CancellationTokenSource _shutdownCts;
     private NamedPipeClientStream? _pipeClient;
     private JsonRpc? _jsonRpc;
     private IVisualStudioRpc? _proxy;
     private bool _disposed;
+    private List<ToolInfo>? _cachedTools;
 
     public bool IsConnected => _pipeClient?.IsConnected ?? false;
 
+    public RpcClient(CancellationTokenSource shutdownCts)
+    {
+        _shutdownCts = shutdownCts;
+    }
+
     public async Task ConnectAsync(string pipeName, int timeoutMs = 10000)
     {
         _pipeClient = new NamedPipeClientStream(
@@ -27,7 +39,7 @@ public async Task ConnectAsync(string pipeName, int timeoutMs = 10000)
 
         await _pipeClient.ConnectAsync(timeoutMs);
 
-        _jsonRpc = JsonRpc.Attach(_pipeClient);
+        _jsonRpc = JsonRpc.Attach(_pipeClient, this);
         _proxy = _jsonRpc.Attach<IVisualStudioRpc>();
     }
 
@@ -45,6 +57,54 @@ public void Dispose()
 
     private IVisualStudioRpc Proxy => _proxy ?? throw new InvalidOperationException("Not connected to Visual Studio");
 
+    #region IServerRpc Implementation
+
+    public Task<List<ToolInfo>> GetAvailableToolsAsync()
+    {
+        if (_cachedTools != null)
+        {
+            return Task.FromResult(_cachedTools);
+        }
+
+        var tools = new List<ToolInfo>();
+        var toolTypes = new[] { typeof(Tools.SolutionTools), typeof(Tools.DocumentTools), typeof(Tools.BuildTools) };
+
+        foreach (var toolType in toolTypes)
+        {
+            var category = toolType.Name.Replace("Tools", "");
+
+            foreach (var method in toolType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
+            {
+                var toolAttr = method.GetCustomAttribute<McpServerToolAttribute>();
+                if (toolAttr == null)
+                {
+                    continue;
+                }
+
+                var descAttr = method.GetCustomAttribute<DescriptionAttribute>();
+
+                tools.Add(new ToolInfo
+                {
+                    Name = toolAttr.Name ?? method.Name,
+                    Description = descAttr?.Description ?? string.Empty,
+                    Category = category
+                });
+            }
+        }
+
+        _cachedTools = tools;
+        return Task.FromResult(tools);
+    }
+
+    public Task ShutdownAsync()
+    {
+        Console.Error.WriteLine("Shutdown requested via RPC");
+        _shutdownCts.Cancel();
+        return Task.CompletedTask;
+    }
+
+    #endregion
+
     #region IVisualStudioRpc Implementation
 
     public Task<SolutionInfo?> GetSolutionInfoAsync() => Proxy.GetSolutionInfoAsync();
@@ -68,7 +128,7 @@ public Task<List<FindResult>> FindAsync(string searchText, bool matchCase, bool
     public Task<bool> BuildSolutionAsync() => Proxy.BuildSolutionAsync();
     public Task<bool> BuildProjectAsync(string projectName) => Proxy.BuildProjectAsync(projectName);
     public Task<bool> CleanSolutionAsync() => Proxy.CleanSolutionAsync();
-    public Task CancelBuildAsync() => Proxy.CancelBuildAsync();
+    public Task<bool> CancelBuildAsync() => Proxy.CancelBuildAsync();
     public Task<BuildStatus> GetBuildStatusAsync() => Proxy.GetBuildStatusAsync();
 
     #endregion

src/CodingWithCalvin.VSMCP.Server/RpcClient.cs

@@ -9,50 +9,52 @@ namespace CodingWithCalvin.VSMCP.Server.Tools;
 public class BuildTools
 {
     private readonly RpcClient _rpcClient;
+    private readonly JsonSerializerOptions _jsonOptions;
 
     public BuildTools(RpcClient rpcClient)
     {
         _rpcClient = rpcClient;
+        _jsonOptions = new JsonSerializerOptions { WriteIndented = true };
     }
 
-    [McpServerTool]
+    [McpServerTool(Name = "build_solution")]
     [Description("Build the entire solution")]
-    public async Task<string> build_solution()
+    public async Task<string> BuildSolutionAsync()
     {
         var success = await _rpcClient.BuildSolutionAsync();
         return success ? "Build started" : "Failed to start build (is a solution open?)";
     }
 
-    [McpServerTool]
+    [McpServerTool(Name = "build_project")]
     [Description("Build a specific project")]
-    public async Task<string> build_project(
+    public async Task<string> BuildProjectAsync(
         [Description("The name of the project to build")] string projectName)
     {
         var success = await _rpcClient.BuildProjectAsync(projectName);
         return success ? $"Build started for project: {projectName}" : $"Failed to build project: {projectName}";
     }
 
-    [McpServerTool]
+    [McpServerTool(Name = "clean_solution")]
     [Description("Clean the entire solution (remove build outputs)")]
-    public async Task<string> clean_solution()
+    public async Task<string> CleanSolutionAsync()
     {
         var success = await _rpcClient.CleanSolutionAsync();
         return success ? "Clean started" : "Failed to start clean (is a solution open?)";
     }
 
-    [McpServerTool]
+    [McpServerTool(Name = "build_cancel")]
     [Description("Cancel the current build operation")]
-    public async Task<string> build_cancel()
+    public async Task<string> CancelBuildAsync()
     {
-        await _rpcClient.CancelBuildAsync();
-        return "Build cancel requested";
+        var cancelled = await _rpcClient.CancelBuildAsync();
+        return cancelled ? "Build cancelled" : "No build is currently in progress";
     }
 
-    [McpServerTool]
+    [McpServerTool(Name = "build_status")]
     [Description("Get the current build status")]
-    public async Task<string> build_status()
+    public async Task<string> GetBuildStatusAsync()
     {
         var status = await _rpcClient.GetBuildStatusAsync();
-        return JsonSerializer.Serialize(status, new JsonSerializerOptions { WriteIndented = true });
+        return JsonSerializer.Serialize(status, _jsonOptions);
     }
 }