using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using MCPForUnity.Editor.Constants;
using MCPForUnity.Editor.Helpers;
using MCPForUnity.Editor.Services.Server;
using UnityEditor;
using UnityEngine;
namespace MCPForUnity.Editor.Services
{
/// <summary>
/// Service for managing MCP server lifecycle
/// </summary>
public class ServerManagementService : IServerManagementService
{
private readonly IProcessDetector _processDetector;
private readonly IPidFileManager _pidFileManager;
private readonly IProcessTerminator _processTerminator;
private readonly IServerCommandBuilder _commandBuilder;
private readonly ITerminalLauncher _terminalLauncher;
/// <summary>
/// Creates a new ServerManagementService with default dependencies.
/// </summary>
public ServerManagementService() : this(null, null, null, null, null) { }
/// <summary>
/// Creates a new ServerManagementService with injected dependencies (for testing).
/// </summary>
/// <param name="processDetector">Process detector implementation (null for default)</param>
/// <param name="pidFileManager">PID file manager implementation (null for default)</param>
/// <param name="processTerminator">Process terminator implementation (null for default)</param>
/// <param name="commandBuilder">Server command builder implementation (null for default)</param>
/// <param name="terminalLauncher">Terminal launcher implementation (null for default)</param>
public ServerManagementService(
IProcessDetector processDetector,
IPidFileManager pidFileManager = null,
IProcessTerminator processTerminator = null,
IServerCommandBuilder commandBuilder = null,
ITerminalLauncher terminalLauncher = null)
{
_processDetector = processDetector ?? new ProcessDetector();
_pidFileManager = pidFileManager ?? new PidFileManager();
_processTerminator = processTerminator ?? new ProcessTerminator(_processDetector);
_commandBuilder = commandBuilder ?? new ServerCommandBuilder();
_terminalLauncher = terminalLauncher ?? new TerminalLauncher();
}
private string QuoteIfNeeded(string s)
{
return _commandBuilder.QuoteIfNeeded(s);
}
private string NormalizeForMatch(string s)
{
return _processDetector.NormalizeForMatch(s);
}
private void ClearLocalServerPidTracking()
{
_pidFileManager.ClearTracking();
}
private void StoreLocalHttpServerHandshake(string pidFilePath, string instanceToken)
{
_pidFileManager.StoreHandshake(pidFilePath, instanceToken);
}
private bool TryGetLocalHttpServerHandshake(out string pidFilePath, out string instanceToken)
{
return _pidFileManager.TryGetHandshake(out pidFilePath, out instanceToken);
}
private string GetLocalHttpServerPidFilePath(int port)
{
return _pidFileManager.GetPidFilePath(port);
}
private bool TryReadPidFromPidFile(string pidFilePath, out int pid)
{
return _pidFileManager.TryReadPid(pidFilePath, out pid);
}
private bool TryProcessCommandLineContainsInstanceToken(int pid, string instanceToken, out bool containsToken)
{
containsToken = false;
if (pid <= 0 || string.IsNullOrEmpty(instanceToken))
{
return false;
}
try
{
string tokenNeedle = instanceToken.ToLowerInvariant();
if (Application.platform == RuntimePlatform.WindowsEditor)
{
// Query full command line so we can validate token (reduces PID reuse risk).
// Use CIM via PowerShell (wmic is deprecated).
string ps = $"(Get-CimInstance Win32_Process -Filter \\\"ProcessId={pid}\\\").CommandLine";
bool ok = ExecPath.TryRun("powershell", $"-NoProfile -Command \"{ps}\"", Application.dataPath, out var stdout, out var stderr, 5000);
string combined = ((stdout ?? string.Empty) + "\n" + (stderr ?? string.Empty)).ToLowerInvariant();
containsToken = combined.Contains(tokenNeedle);
return ok;
}
if (TryGetUnixProcessArgs(pid, out var argsLowerNow))
{
containsToken = argsLowerNow.Contains(NormalizeForMatch(tokenNeedle));
return true;
}
}
catch { }
return false;
}
private string ComputeShortHash(string input)
{
return _pidFileManager.ComputeShortHash(input);
}
private bool TryGetStoredLocalServerPid(int expectedPort, out int pid)
{
return _pidFileManager.TryGetStoredPid(expectedPort, out pid);
}
private string GetStoredArgsHash()
{
return _pidFileManager.GetStoredArgsHash();
}
/// <summary>
/// Clear the local uvx cache for the MCP server package
/// </summary>
/// <returns>True if successful, false otherwise</returns>
public bool ClearUvxCache()
{
try
{
string uvxPath = MCPServiceLocator.Paths.GetUvxPath();
string uvCommand = BuildUvPathFromUvx(uvxPath);
// Get the package name
string packageName = "mcp-for-unity";
// Run uvx cache clean command
string args = $"cache clean {packageName}";
bool success;
string stdout;
string stderr;
success = ExecuteUvCommand(uvCommand, args, out stdout, out stderr);
if (success)
{
McpLog.Info($"uv cache cleared successfully: {stdout}");
return true;
}
string combinedOutput = string.Join(
Environment.NewLine,
new[] { stderr, stdout }.Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()));
string lockHint = (!string.IsNullOrEmpty(combinedOutput) &&
combinedOutput.IndexOf("currently in-use", StringComparison.OrdinalIgnoreCase) >= 0)
? "Another uv process may be holding the cache lock; wait a moment and try again or clear with '--force' from a terminal."
: string.Empty;
if (string.IsNullOrEmpty(combinedOutput))
{
combinedOutput = "Command failed with no output. Ensure uv is installed, on PATH, or set an override in Advanced Settings.";
}
McpLog.Error(
$"Failed to clear uv cache using '{uvCommand} {args}'. " +
$"Details: {combinedOutput}{(string.IsNullOrEmpty(lockHint) ? string.Empty : " Hint: " + lockHint)}");
return false;
}
catch (Exception ex)
{
McpLog.Error($"Error clearing uv cache: {ex.Message}");
return false;
}
}
private bool ExecuteUvCommand(string uvCommand, string args, out string stdout, out string stderr)
{
stdout = null;
stderr = null;
string uvxPath = MCPServiceLocator.Paths.GetUvxPath();
string uvPath = BuildUvPathFromUvx(uvxPath);
if (!string.Equals(uvCommand, uvPath, StringComparison.OrdinalIgnoreCase))
{
return ExecPath.TryRun(uvCommand, args, Application.dataPath, out stdout, out stderr, 30000);
}
string command = $"{uvPath} {args}";
string extraPathPrepend = GetPlatformSpecificPathPrepend();
if (Application.platform == RuntimePlatform.WindowsEditor)
{
return ExecPath.TryRun("cmd.exe", $"/c {command}", Application.dataPath, out stdout, out stderr, 30000, extraPathPrepend);
}
string shell = File.Exists("/bin/bash") ? "/bin/bash" : "/bin/sh";
if (!string.IsNullOrEmpty(shell) && File.Exists(shell))
{
string escaped = command.Replace("\"", "\\\"");
return ExecPath.TryRun(shell, $"-lc \"{escaped}\"", Application.dataPath, out stdout, out stderr, 30000, extraPathPrepend);
}
return ExecPath.TryRun(uvPath, args, Application.dataPath, out stdout, out stderr, 30000, extraPathPrepend);
}
private string BuildUvPathFromUvx(string uvxPath)
{
return _commandBuilder.BuildUvPathFromUvx(uvxPath);
}
private string GetPlatformSpecificPathPrepend()
{
return _commandBuilder.GetPlatformSpecificPathPrepend();
}
/// <summary>
/// Start the local HTTP server in a separate terminal window.
/// Stops any existing server on the port and clears the uvx cache first.
/// </summary>
public bool StartLocalHttpServer()
{
/// Clean stale Python build artifacts when using a local dev server path
AssetPathUtility.CleanLocalServerBuildArtifacts();
if (!TryGetLocalHttpServerCommandParts(out _, out _, out var displayCommand, out var error))
{
EditorUtility.DisplayDialog(
"Cannot Start HTTP Server",
error ?? "The server command could not be constructed with the current settings.",
"OK");
return false;
}
// First, try to stop any existing server (quietly; we'll only warn if the port remains occupied).
StopLocalHttpServerInternal(quiet: true);
// If the port is still occupied, don't start and explain why (avoid confusing "refusing to stop" warnings).
try
{
string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
if (Uri.TryCreate(httpUrl, UriKind.Absolute, out var uri) && uri.Port > 0)
{
var remaining = GetListeningProcessIdsForPort(uri.Port);
if (remaining.Count > 0)
{
EditorUtility.DisplayDialog(
"Port In Use",
$"Cannot start the local HTTP server because port {uri.Port} is already in use by PID(s): " +
$"{string.Join(", ", remaining)}\n\n" +
"MCP For Unity will not terminate unrelated processes. Stop the owning process manually or change the HTTP URL.",
"OK");
return false;
}
}
}
catch { }
// Note: Dev mode cache-busting is handled by `uvx --no-cache --refresh` in the generated command.
// Create a per-launch token + pidfile path so Stop can be deterministic without relying on port/PID heuristics.
string baseUrlForPid = HttpEndpointUtility.GetLocalBaseUrl();
Uri.TryCreate(baseUrlForPid, UriKind.Absolute, out var uriForPid);
int portForPid = uriForPid?.Port ?? 0;
string instanceToken = Guid.NewGuid().ToString("N");
string pidFilePath = portForPid > 0 ? GetLocalHttpServerPidFilePath(portForPid) : null;
string launchCommand = displayCommand;
if (!string.IsNullOrEmpty(pidFilePath))
{
launchCommand = $"{displayCommand} --pidfile {QuoteIfNeeded(pidFilePath)} --unity-instance-token {instanceToken}";
}
if (EditorUtility.DisplayDialog(
"Start Local HTTP Server",
$"This will start the MCP server in HTTP mode in a new terminal window:\n\n{launchCommand}\n\n" +
"Continue?",
"Start Server",
"Cancel"))
{
try
{
// Clear any stale handshake state from prior launches.
ClearLocalServerPidTracking();
// Best-effort: delete stale pidfile if it exists.
try
{
if (!string.IsNullOrEmpty(pidFilePath) && File.Exists(pidFilePath))
{
DeletePidFile(pidFilePath);
}
}
catch { }
// Launch the server in a new terminal window (keeps user-visible logs).
var startInfo = CreateTerminalProcessStartInfo(launchCommand);
System.Diagnostics.Process.Start(startInfo);
if (!string.IsNullOrEmpty(pidFilePath))
{
StoreLocalHttpServerHandshake(pidFilePath, instanceToken);
}
McpLog.Info($"Started local HTTP server in terminal: {launchCommand}");
return true;
}
catch (Exception ex)
{
McpLog.Error($"Failed to start server: {ex.Message}");
EditorUtility.DisplayDialog(
"Error",
$"Failed to start server: {ex.Message}",
"OK");
return false;
}
}
return false;
}
/// <summary>
/// Stop the local HTTP server by finding the process listening on the configured port
/// </summary>
public bool StopLocalHttpServer()
{
return StopLocalHttpServerInternal(quiet: false);
}
public bool StopManagedLocalHttpServer()
{
if (!TryGetLocalHttpServerHandshake(out var pidFilePath, out _))
{
return false;
}
int port = 0;
if (!TryGetPortFromPidFilePath(pidFilePath, out port) || port <= 0)
{
string baseUrl = HttpEndpointUtility.GetLocalBaseUrl();
if (IsLocalUrl(baseUrl)
&& Uri.TryCreate(baseUrl, UriKind.Absolute, out var uri)
&& uri.Port > 0)
{
port = uri.Port;
}
}
if (port <= 0)
{
return false;
}
return StopLocalHttpServerInternal(quiet: true, portOverride: port, allowNonLocalUrl: true);
}
public bool IsLocalHttpServerRunning()
{
try
{
string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
if (!IsLocalUrl(httpUrl))
{
return false;
}
if (!Uri.TryCreate(httpUrl, UriKind.Absolute, out var uri) || uri.Port <= 0)
{
return false;
}
int port = uri.Port;
// Handshake path: if we have a pidfile+token and the PID is still the listener, treat as running.
if (TryGetLocalHttpServerHandshake(out var pidFilePath, out var instanceToken)
&& TryReadPidFromPidFile(pidFilePath, out var pidFromFile)
&& pidFromFile > 0)
{
var pidsNow = GetListeningProcessIdsForPort(port);
if (pidsNow.Contains(pidFromFile))
{
return true;
}
}
var pids = GetListeningProcessIdsForPort(port);
if (pids.Count == 0)
{
return false;
}
// Strong signal: stored PID is still the listener.
if (TryGetStoredLocalServerPid(port, out int storedPid) && storedPid > 0)
{
if (pids.Contains(storedPid))
{
return true;
}
}
// Best-effort: if anything listening looks like our server, treat as running.
foreach (var pid in pids)
{
if (pid <= 0) continue;
if (LooksLikeMcpServerProcess(pid))
{
return true;
}
}
return false;
}
catch
{
return false;
}
}
public bool IsLocalHttpServerReachable()
{
try
{
string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
if (!IsLocalUrl(httpUrl))
{
return false;
}
if (!Uri.TryCreate(httpUrl, UriKind.Absolute, out var uri) || uri.Port <= 0)
{
return false;
}
return TryConnectToLocalPort(uri.Host, uri.Port, timeoutMs: 50);
}
catch
{
return false;
}
}
private static bool TryConnectToLocalPort(string host, int port, int timeoutMs)
{
try
{
if (string.IsNullOrEmpty(host))
{
host = "127.0.0.1";
}
var hosts = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { host };
if (host == "localhost" || host == "0.0.0.0")
{
hosts.Add("127.0.0.1");
}
if (host == "::" || host == "0:0:0:0:0:0:0:0")
{
hosts.Add("::1");
}
foreach (var target in hosts)
{
try
{
using (var client = new TcpClient())
{
var connectTask = client.ConnectAsync(target, port);
if (connectTask.Wait(timeoutMs) && client.Connected)
{
return true;
}
}
}
catch
{
// Ignore per-host failures.
}
}
}
catch
{
// Ignore probe failures and treat as unreachable.
}
return false;
}
private bool StopLocalHttpServerInternal(bool quiet, int? portOverride = null, bool allowNonLocalUrl = false)
{
string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
if (!allowNonLocalUrl && !IsLocalUrl(httpUrl))
{
if (!quiet)
{
McpLog.Warn("Cannot stop server: URL is not local.");
}
return false;
}
try
{
int port = 0;
if (portOverride.HasValue)
{
port = portOverride.Value;
}
else
{
var uri = new Uri(httpUrl);
port = uri.Port;
}
if (port <= 0)
{
if (!quiet)
{
McpLog.Warn("Cannot stop server: Invalid port.");
}
return false;
}
// Guardrails:
// - Never terminate the Unity Editor process.
// - Only terminate processes that look like the MCP server (uv/uvx/python running mcp-for-unity).
// This prevents accidental termination of unrelated services (including Unity itself).
int unityPid = GetCurrentProcessIdSafe();
bool stoppedAny = false;
// Preferred deterministic stop path: if we have a pidfile+token from a Unity-managed launch,
// validate and terminate exactly that PID.
if (TryGetLocalHttpServerHandshake(out var pidFilePath, out var instanceToken))
{
// Prefer deterministic stop when Unity started the server (pidfile+token).
// If the pidfile isn't available yet (fast quit after start), we can optionally fall back
// to port-based heuristics when a port override was supplied (managed-stop path).
if (!TryReadPidFromPidFile(pidFilePath, out var pidFromFile) || pidFromFile <= 0)
{
if (!portOverride.HasValue)
{
if (!quiet)
{
McpLog.Warn(
$"Cannot stop local HTTP server on port {port}: pidfile not available yet at '{pidFilePath}'. " +
"If you just started the server, wait a moment and try again.");
}
return false;
}
// Managed-stop fallback: proceed with port-based heuristics below.
// We intentionally do NOT clear handshake state here; it will be cleared if we successfully
// stop a server process and/or the port is freed.
}
else
{
// Never kill Unity/Hub.
if (unityPid > 0 && pidFromFile == unityPid)
{
if (!quiet)
{
McpLog.Warn($"Refusing to stop port {port}: pidfile PID {pidFromFile} is the Unity Editor process.");
}
}
else
{
var listeners = GetListeningProcessIdsForPort(port);
if (listeners.Count == 0)
{
// Nothing is listening anymore; clear stale handshake state.
try { DeletePidFile(pidFilePath); } catch { }
ClearLocalServerPidTracking();
if (!quiet)
{
McpLog.Info($"No process found listening on port {port}");
}
return false;
}
bool pidIsListener = listeners.Contains(pidFromFile);
bool tokenQueryOk = TryProcessCommandLineContainsInstanceToken(pidFromFile, instanceToken, out bool tokenMatches);
bool allowKill;
if (tokenQueryOk)
{
allowKill = tokenMatches;
}
else
{
// If token validation is unavailable (e.g. Windows CIM permission issues),
// fall back to a stricter heuristic: only allow stop if the PID still looks like our server.
allowKill = LooksLikeMcpServerProcess(pidFromFile);
}
if (pidIsListener && allowKill)
{
if (TerminateProcess(pidFromFile))
{
stoppedAny = true;
try { DeletePidFile(pidFilePath); } catch { }
ClearLocalServerPidTracking();
if (!quiet)
{
McpLog.Info($"Stopped local HTTP server on port {port} (PID: {pidFromFile})");
}
return true;
}
if (!quiet)
{
McpLog.Warn($"Failed to terminate local HTTP server on port {port} (PID: {pidFromFile}).");
}
return false;
}
if (!quiet)
{
McpLog.Warn(
$"Refusing to stop port {port}: pidfile PID {pidFromFile} failed validation " +
$"(listener={pidIsListener}, tokenMatch={tokenMatches}, tokenQueryOk={tokenQueryOk}).");
}
return false;
}
}
}
var pids = GetListeningProcessIdsForPort(port);
if (pids.Count == 0)
{
if (stoppedAny)
{
// We stopped what Unity started; the port is now free.
if (!quiet)
{
McpLog.Info($"Stopped local HTTP server on port {port}");
}
ClearLocalServerPidTracking();
return true;
}
if (!quiet)
{
McpLog.Info($"No process found listening on port {port}");
}
ClearLocalServerPidTracking();
return false;
}
// Prefer killing the PID that we previously observed binding this port (if still valid).
if (TryGetStoredLocalServerPid(port, out int storedPid))
{
if (pids.Contains(storedPid))
{
string expectedHash = string.Empty;
expectedHash = GetStoredArgsHash();
// Prefer a fingerprint match (reduces PID reuse risk). If missing (older installs),
// fall back to a looser check to avoid leaving orphaned servers after domain reload.
if (TryGetUnixProcessArgs(storedPid, out var storedArgsLowerNow))
{
// Never kill Unity/Hub.
// Note: "mcp-for-unity" includes "unity", so detect MCP indicators first.
bool storedMentionsMcp = storedArgsLowerNow.Contains("mcp-for-unity")
|| storedArgsLowerNow.Contains("mcp_for_unity")
|| storedArgsLowerNow.Contains("mcpforunity");
if (storedArgsLowerNow.Contains("unityhub")
|| storedArgsLowerNow.Contains("unity hub")
|| (storedArgsLowerNow.Contains("unity") && !storedMentionsMcp))
{
if (!quiet)
{
McpLog.Warn($"Refusing to stop port {port}: stored PID {storedPid} appears to be a Unity process.");
}
}
else
{
bool allowKill = false;
if (!string.IsNullOrEmpty(expectedHash))
{
allowKill = string.Equals(expectedHash, ComputeShortHash(storedArgsLowerNow), StringComparison.OrdinalIgnoreCase);
}
else
{
// Older versions didn't store a fingerprint; accept common server indicators.
allowKill = storedArgsLowerNow.Contains("uvicorn")
|| storedArgsLowerNow.Contains("fastmcp")
|| storedArgsLowerNow.Contains("mcpforunity")
|| storedArgsLowerNow.Contains("mcp-for-unity")
|| storedArgsLowerNow.Contains("mcp_for_unity")
|| storedArgsLowerNow.Contains("uvx")
|| storedArgsLowerNow.Contains("python");
}
if (allowKill && TerminateProcess(storedPid))
{
if (!quiet)
{
McpLog.Info($"Stopped local HTTP server on port {port} (PID: {storedPid})");
}
stoppedAny = true;
ClearLocalServerPidTracking();
// Refresh the PID list to avoid double-work.
pids = GetListeningProcessIdsForPort(port);
}
else if (!allowKill && !quiet)
{
McpLog.Warn($"Refusing to stop port {port}: stored PID {storedPid} did not match expected server fingerprint.");
}
}
}
}
else
{
// Stale PID (no longer listening). Clear.
ClearLocalServerPidTracking();
}
}
foreach (var pid in pids)
{
if (pid <= 0) continue;
if (unityPid > 0 && pid == unityPid)
{
if (!quiet)
{
McpLog.Warn($"Refusing to stop port {port}: owning PID appears to be the Unity Editor process (PID {pid}).");
}
continue;
}
if (!LooksLikeMcpServerProcess(pid))
{
if (!quiet)
{
McpLog.Warn($"Refusing to stop port {port}: owning PID {pid} does not look like mcp-for-unity.");
}
continue;
}
if (TerminateProcess(pid))
{
McpLog.Info($"Stopped local HTTP server on port {port} (PID: {pid})");
stoppedAny = true;
}
else
{
if (!quiet)
{
McpLog.Warn($"Failed to stop process PID {pid} on port {port}");
}
}
}
if (stoppedAny)
{
ClearLocalServerPidTracking();
}
return stoppedAny;
}
catch (Exception ex)
{
if (!quiet)
{
McpLog.Error($"Failed to stop server: {ex.Message}");
}
return false;
}
}
private bool TryGetUnixProcessArgs(int pid, out string argsLower)
{
return _processDetector.TryGetProcessCommandLine(pid, out argsLower);
}
private bool TryGetPortFromPidFilePath(string pidFilePath, out int port)
{
return _pidFileManager.TryGetPortFromPidFilePath(pidFilePath, out port);
}
private void DeletePidFile(string pidFilePath)
{
_pidFileManager.DeletePidFile(pidFilePath);
}
private List<int> GetListeningProcessIdsForPort(int port)
{
return _processDetector.GetListeningProcessIdsForPort(port);
}
private int GetCurrentProcessIdSafe()
{
return _processDetector.GetCurrentProcessId();
}
private bool LooksLikeMcpServerProcess(int pid)
{
return _processDetector.LooksLikeMcpServerProcess(pid);
}
private bool TerminateProcess(int pid)
{
return _processTerminator.Terminate(pid);
}
/// <summary>
/// Attempts to build the command used for starting the local HTTP server
/// </summary>
public bool TryGetLocalHttpServerCommand(out string command, out string error)
{
command = null;
error = null;
if (!TryGetLocalHttpServerCommandParts(out var fileName, out var args, out var displayCommand, out error))
{
return false;
}
// Maintain existing behavior: return a single command string suitable for display/copy.
command = displayCommand;
return true;
}
private bool TryGetLocalHttpServerCommandParts(out string fileName, out string arguments, out string displayCommand, out string error)
{
return _commandBuilder.TryBuildCommand(out fileName, out arguments, out displayCommand, out error);
}
/// <summary>
/// Check if the configured HTTP URL is a local address
/// </summary>
public bool IsLocalUrl()
{
string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
return IsLocalUrl(httpUrl);
}
/// <summary>
/// Check if a URL is local (localhost, 127.0.0.1, 0.0.0.0)
/// </summary>
private static bool IsLocalUrl(string url)
{
if (string.IsNullOrEmpty(url)) return false;
try
{
var uri = new Uri(url);
string host = uri.Host.ToLower();
return host == "localhost" || host == "127.0.0.1" || host == "0.0.0.0" || host == "::1";
}
catch
{
return false;
}
}
/// <summary>
/// Check if the local HTTP server can be started
/// </summary>
public bool CanStartLocalServer()
{
bool useHttpTransport = EditorConfigurationCache.Instance.UseHttpTransport;
return useHttpTransport && IsLocalUrl();
}
private System.Diagnostics.ProcessStartInfo CreateTerminalProcessStartInfo(string command)
{
return _terminalLauncher.CreateTerminalProcessStartInfo(command);
}
}
}
