CommandServer.cs

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace VSCommandServer;

public class CommandServer(ICommandExecutor commandExecutor) : IDisposable
{
	private HttpListener _listener;
	private CancellationTokenSource _cancellationTokenSource;
	private readonly ICommandExecutor _commandExecutor = commandExecutor ?? throw new ArgumentNullException(nameof(commandExecutor));

	public int Port { get; private set; }

	public bool IsRunning { get; private set; }

	public Task<int> StartAsync(int preferredPort = 3000, int maxRetries = 3)
	{
		if (IsRunning)
			return Task.FromResult(Port);

		Port = FindAvailablePort(preferredPort, maxRetries);
		_listener = new HttpListener();
		_listener.Prefixes.Add($"http://127.0.0.1:{Port}/");
            
		_cancellationTokenSource = new CancellationTokenSource();
            
		try
		{
			_listener.Start();
			IsRunning = true;
			_ = ProcessRequestsAsync(_cancellationTokenSource.Token);
			return Task.FromResult(Port);
		}
		catch (Exception)
		{
			_listener?.Close();
			throw;
		}
	}

	public void Stop()
	{
		if (!IsRunning)
			return;

		_cancellationTokenSource?.Cancel();
		_listener?.Stop();
		_listener?.Close();
		IsRunning = false;
	}

	private static int FindAvailablePort(int startPort, int maxRetries)
	{
	for (var port = startPort; port < startPort + maxRetries; port++)
	{
		try
		{
			var testListener = new HttpListener();
			testListener.Prefixes.Add($"http://127.0.0.1:{port}/");
			testListener.Start();
			testListener.Stop();
			testListener.Close();
			return port;
		}
		catch
		{
			// continue
		}
	}
	throw new InvalidOperationException($"Could not find available port after {maxRetries} attempts starting from {startPort}");
	}

	private async Task ProcessRequestsAsync(CancellationToken cancellationToken)
	{
		while (!cancellationToken.IsCancellationRequested && _listener.IsListening)
		{
			try
			{
				var context = await _listener.GetContextAsync();
				_ = HandleRequestAsync(context);
			}
			catch (HttpListenerException) when (cancellationToken.IsCancellationRequested)
			{
				break;
			}
			catch (ObjectDisposedException)
			{
				break;
			}
			catch (Exception)
			{
				// continue
			}
		}
	}

	private async Task HandleRequestAsync(HttpListenerContext context)
	{
		var request = context.Request;
		var response = context.Response;

		response.Headers.Add("Access-Control-Allow-Origin", "*");
		response.Headers.Add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
		response.Headers.Add("Access-Control-Allow-Headers", "Content-Type");

		if (request.HttpMethod == "OPTIONS")
		{
			response.StatusCode = 200;
			response.Close();
			return;
		}

		try
		{
			object result;
			var path = request.Url.AbsolutePath.TrimEnd('/');

			switch (path)
			{
				case "":
				case "/":
					result = HandleStatus();
					break;
				case "/info":
					result = await HandleInfoAsync();
					break;
				case "/commands":
					result = await HandleGetCommandsAsync();
					break;
				case "/execute":
					if (request.HttpMethod != "POST")
					{
						result = new ApiResponse { Success = false, Error = "Method not allowed. Use POST." };
						response.StatusCode = 405;
					}
					else
					{
						result = await HandleExecuteAsync(request);
					}
					break;
				default:
					result = new ApiResponse { Success = false, Error = "Not found" };
					response.StatusCode = 404;
					break;
			}

			await WriteJsonResponseAsync(response, result);
		}
		catch (Exception ex)
		{
			response.StatusCode = 500;
			await WriteJsonResponseAsync(response, new ApiResponse 
			{ 
				Success = false, 
				Error = ex.Message 
			});
		}
	}

	private static ApiResponse HandleStatus()
	{
		return new ApiResponse
		{
			Success = true,
			Result = "VS Command Server is running"
		};
	}

	private async Task<ApiResponse> HandleInfoAsync()
	{
		return new ServerInfo
		{
			Success = true,
			Port = Port,
			ProcessId = System.Diagnostics.Process.GetCurrentProcess().Id,
			SolutionPath = await _commandExecutor.GetSolutionPathAsync(),
			VisualStudioVersion = await _commandExecutor.GetVisualStudioVersionAsync()
		};
	}

	private async Task<ApiResponse> HandleGetCommandsAsync()
	{
		try
		{
			var commands = await _commandExecutor.GetAvailableCommandsAsync();
			return new CommandListResponse
			{
				Success = true,
				Commands = commands
			};
		}
		catch (Exception ex)
		{
			return new ApiResponse
			{
				Success = false,
				Error = ex.Message
			};
		}
	}

	private async Task<ApiResponse> HandleExecuteAsync(HttpListenerRequest request)
	{
		string body;
		using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
		{
			body = await reader.ReadToEndAsync();
		}

		ExecuteRequest executeRequest;
		try
		{
			executeRequest = JsonConvert.DeserializeObject<ExecuteRequest>(body);
		}
		catch (Exception ex)
		{
			return new ApiResponse
			{
				Success = false,
				Error = $"Invalid JSON: {ex.Message}"
			};
		}

		if (string.IsNullOrWhiteSpace(executeRequest?.Command))
		{
			return new ApiResponse
			{
				Success = false,
				Error = "Command is required"
			};
		}

		try
		{
			var result = await _commandExecutor.ExecuteCommandAsync(executeRequest.Command, executeRequest.Args);
			return new ApiResponse
			{
				Success = true,
				Command = executeRequest.Command,
				Result = result
			};
		}
		catch (Exception ex)
		{
			return new ApiResponse
			{
				Success = false,
				Command = executeRequest.Command,
				Error = ex.Message
			};
		}
	}

	private static async Task WriteJsonResponseAsync(HttpListenerResponse response, object data)
	{
		response.ContentType = "application/json";
		var json = JsonConvert.SerializeObject(data, Formatting.Indented);
		var buffer = Encoding.UTF8.GetBytes(json);
		response.ContentLength64 = buffer.Length;
		await response.OutputStream.WriteAsync(buffer, 0, buffer.Length);
		response.Close();
	}

	public void Dispose()
	{
		Stop();
		_cancellationTokenSource?.Dispose();
	}
}