升级XR插件版本
This commit is contained in:
Sora丶kong
876
Packages/MCPForUnity/Editor/Services/ServerManagementService.cs
Normal file
876
Packages/MCPForUnity/Editor/Services/ServerManagementService.cs
Normal file
@@ -0,0 +1,876 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user