468 lines
19 KiB
C#
468 lines
19 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using MCPForUnity.Editor.Constants;
|
|
using MCPForUnity.Editor.Helpers;
|
|
using MCPForUnity.Editor.Services;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace MCPForUnity.Editor.Windows.Components.Advanced
|
|
{
|
|
/// <summary>
|
|
/// Controller for the Advanced Settings section.
|
|
/// Handles path overrides, server source configuration, dev mode, and package deployment.
|
|
/// </summary>
|
|
public class McpAdvancedSection
|
|
{
|
|
// UI Elements
|
|
private TextField uvxPathOverride;
|
|
private Button browseUvxButton;
|
|
private Button clearUvxButton;
|
|
private VisualElement uvxPathStatus;
|
|
private TextField gitUrlOverride;
|
|
private Button browseGitUrlButton;
|
|
private Button clearGitUrlButton;
|
|
private Toggle debugLogsToggle;
|
|
private Toggle devModeForceRefreshToggle;
|
|
private Toggle useBetaServerToggle;
|
|
private TextField deploySourcePath;
|
|
private Button browseDeploySourceButton;
|
|
private Button clearDeploySourceButton;
|
|
private Button deployButton;
|
|
private Button deployRestoreButton;
|
|
private Label deployTargetLabel;
|
|
private Label deployBackupLabel;
|
|
private Label deployStatusLabel;
|
|
private VisualElement healthIndicator;
|
|
private Label healthStatus;
|
|
private Button testConnectionButton;
|
|
|
|
// Events
|
|
public event Action OnGitUrlChanged;
|
|
public event Action OnHttpServerCommandUpdateRequested;
|
|
public event Action OnTestConnectionRequested;
|
|
public event Action<bool> OnBetaModeChanged;
|
|
|
|
public VisualElement Root { get; private set; }
|
|
|
|
public McpAdvancedSection(VisualElement root)
|
|
{
|
|
Root = root;
|
|
CacheUIElements();
|
|
InitializeUI();
|
|
RegisterCallbacks();
|
|
}
|
|
|
|
private void CacheUIElements()
|
|
{
|
|
uvxPathOverride = Root.Q<TextField>("uv-path-override");
|
|
browseUvxButton = Root.Q<Button>("browse-uv-button");
|
|
clearUvxButton = Root.Q<Button>("clear-uv-button");
|
|
uvxPathStatus = Root.Q<VisualElement>("uv-path-status");
|
|
gitUrlOverride = Root.Q<TextField>("git-url-override");
|
|
browseGitUrlButton = Root.Q<Button>("browse-git-url-button");
|
|
clearGitUrlButton = Root.Q<Button>("clear-git-url-button");
|
|
debugLogsToggle = Root.Q<Toggle>("debug-logs-toggle");
|
|
devModeForceRefreshToggle = Root.Q<Toggle>("dev-mode-force-refresh-toggle");
|
|
useBetaServerToggle = Root.Q<Toggle>("use-beta-server-toggle");
|
|
deploySourcePath = Root.Q<TextField>("deploy-source-path");
|
|
browseDeploySourceButton = Root.Q<Button>("browse-deploy-source-button");
|
|
clearDeploySourceButton = Root.Q<Button>("clear-deploy-source-button");
|
|
deployButton = Root.Q<Button>("deploy-button");
|
|
deployRestoreButton = Root.Q<Button>("deploy-restore-button");
|
|
deployTargetLabel = Root.Q<Label>("deploy-target-label");
|
|
deployBackupLabel = Root.Q<Label>("deploy-backup-label");
|
|
deployStatusLabel = Root.Q<Label>("deploy-status-label");
|
|
healthIndicator = Root.Q<VisualElement>("health-indicator");
|
|
healthStatus = Root.Q<Label>("health-status");
|
|
testConnectionButton = Root.Q<Button>("test-connection-button");
|
|
}
|
|
|
|
private void InitializeUI()
|
|
{
|
|
// Set tooltips for fields
|
|
if (uvxPathOverride != null)
|
|
uvxPathOverride.tooltip = "Override path to uvx executable. Leave empty for auto-detection.";
|
|
if (gitUrlOverride != null)
|
|
gitUrlOverride.tooltip = "Override server source for uvx --from. Leave empty to use default PyPI package. Example local dev: /path/to/unity-mcp/Server";
|
|
if (debugLogsToggle != null)
|
|
{
|
|
debugLogsToggle.tooltip = "Enable verbose debug logging to the Unity Console.";
|
|
var debugLabel = debugLogsToggle?.parent?.Q<Label>();
|
|
if (debugLabel != null)
|
|
debugLabel.tooltip = debugLogsToggle.tooltip;
|
|
}
|
|
if (devModeForceRefreshToggle != null)
|
|
{
|
|
devModeForceRefreshToggle.tooltip = "When enabled, generated uvx commands add '--no-cache --refresh' before launching (slower startup, but avoids stale cached builds while iterating on the Server).";
|
|
var forceRefreshLabel = devModeForceRefreshToggle?.parent?.Q<Label>();
|
|
if (forceRefreshLabel != null)
|
|
forceRefreshLabel.tooltip = devModeForceRefreshToggle.tooltip;
|
|
}
|
|
if (useBetaServerToggle != null)
|
|
{
|
|
useBetaServerToggle.tooltip = "When enabled, uvx will fetch the latest beta server version from PyPI. Enable this on the beta branch to get the matching server version.";
|
|
var betaServerLabel = useBetaServerToggle?.parent?.Q<Label>();
|
|
if (betaServerLabel != null)
|
|
betaServerLabel.tooltip = useBetaServerToggle.tooltip;
|
|
}
|
|
if (testConnectionButton != null)
|
|
testConnectionButton.tooltip = "Test the connection between Unity and the MCP server.";
|
|
if (deploySourcePath != null)
|
|
deploySourcePath.tooltip = "Copy a MCPForUnity folder into this project's package location.";
|
|
|
|
// Set tooltips for buttons
|
|
if (browseUvxButton != null)
|
|
browseUvxButton.tooltip = "Browse for uvx executable";
|
|
if (clearUvxButton != null)
|
|
clearUvxButton.tooltip = "Clear override and use auto-detection";
|
|
if (browseGitUrlButton != null)
|
|
browseGitUrlButton.tooltip = "Select local server source folder";
|
|
if (clearGitUrlButton != null)
|
|
clearGitUrlButton.tooltip = "Clear override and use default PyPI package";
|
|
if (browseDeploySourceButton != null)
|
|
browseDeploySourceButton.tooltip = "Select MCPForUnity source folder";
|
|
if (clearDeploySourceButton != null)
|
|
clearDeploySourceButton.tooltip = "Clear deployment source path";
|
|
if (deployButton != null)
|
|
deployButton.tooltip = "Copy MCPForUnity to this project's package location";
|
|
if (deployRestoreButton != null)
|
|
deployRestoreButton.tooltip = "Restore the last backup before deployment";
|
|
|
|
gitUrlOverride.value = EditorPrefs.GetString(EditorPrefKeys.GitUrlOverride, "");
|
|
|
|
bool debugEnabled = EditorPrefs.GetBool(EditorPrefKeys.DebugLogs, false);
|
|
debugLogsToggle.value = debugEnabled;
|
|
McpLog.SetDebugLoggingEnabled(debugEnabled);
|
|
|
|
devModeForceRefreshToggle.value = EditorPrefs.GetBool(EditorPrefKeys.DevModeForceServerRefresh, false);
|
|
useBetaServerToggle.value = EditorConfigurationCache.Instance.UseBetaServer;
|
|
UpdatePathOverrides();
|
|
UpdateDeploymentSection();
|
|
}
|
|
|
|
private void RegisterCallbacks()
|
|
{
|
|
browseUvxButton.clicked += OnBrowseUvxClicked;
|
|
clearUvxButton.clicked += OnClearUvxClicked;
|
|
browseGitUrlButton.clicked += OnBrowseGitUrlClicked;
|
|
|
|
gitUrlOverride.RegisterValueChangedCallback(evt =>
|
|
{
|
|
string url = evt.newValue?.Trim();
|
|
if (string.IsNullOrEmpty(url))
|
|
{
|
|
EditorPrefs.DeleteKey(EditorPrefKeys.GitUrlOverride);
|
|
}
|
|
else
|
|
{
|
|
EditorPrefs.SetString(EditorPrefKeys.GitUrlOverride, url);
|
|
}
|
|
OnGitUrlChanged?.Invoke();
|
|
OnHttpServerCommandUpdateRequested?.Invoke();
|
|
});
|
|
|
|
clearGitUrlButton.clicked += () =>
|
|
{
|
|
gitUrlOverride.value = string.Empty;
|
|
EditorPrefs.DeleteKey(EditorPrefKeys.GitUrlOverride);
|
|
OnGitUrlChanged?.Invoke();
|
|
OnHttpServerCommandUpdateRequested?.Invoke();
|
|
};
|
|
|
|
debugLogsToggle.RegisterValueChangedCallback(evt =>
|
|
{
|
|
McpLog.SetDebugLoggingEnabled(evt.newValue);
|
|
});
|
|
|
|
devModeForceRefreshToggle.RegisterValueChangedCallback(evt =>
|
|
{
|
|
EditorPrefs.SetBool(EditorPrefKeys.DevModeForceServerRefresh, evt.newValue);
|
|
OnHttpServerCommandUpdateRequested?.Invoke();
|
|
});
|
|
|
|
useBetaServerToggle.RegisterValueChangedCallback(evt =>
|
|
{
|
|
EditorConfigurationCache.Instance.SetUseBetaServer(evt.newValue);
|
|
OnHttpServerCommandUpdateRequested?.Invoke();
|
|
OnBetaModeChanged?.Invoke(evt.newValue);
|
|
});
|
|
|
|
deploySourcePath.RegisterValueChangedCallback(evt =>
|
|
{
|
|
string path = evt.newValue?.Trim();
|
|
if (string.IsNullOrEmpty(path) || path == "Not set")
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
MCPServiceLocator.Deployment.SetStoredSourcePath(path);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
EditorUtility.DisplayDialog("Invalid Source", ex.Message, "OK");
|
|
UpdateDeploymentSection();
|
|
}
|
|
});
|
|
|
|
browseDeploySourceButton.clicked += OnBrowseDeploySourceClicked;
|
|
clearDeploySourceButton.clicked += OnClearDeploySourceClicked;
|
|
deployButton.clicked += OnDeployClicked;
|
|
deployRestoreButton.clicked += OnRestoreBackupClicked;
|
|
testConnectionButton.clicked += () => OnTestConnectionRequested?.Invoke();
|
|
}
|
|
|
|
public void UpdatePathOverrides()
|
|
{
|
|
var pathService = MCPServiceLocator.Paths;
|
|
|
|
bool hasOverride = pathService.HasUvxPathOverride;
|
|
bool hasFallback = pathService.HasUvxPathFallback;
|
|
string uvxPath = hasOverride ? pathService.GetUvxPath() : null;
|
|
|
|
// Determine display text based on override and fallback status
|
|
if (hasOverride)
|
|
{
|
|
if (hasFallback)
|
|
{
|
|
// Override path invalid, using system fallback
|
|
string overridePath = EditorPrefs.GetString(EditorPrefKeys.UvxPathOverride, string.Empty);
|
|
uvxPathOverride.value = $"Invalid override path: {overridePath} (fallback to uvx path) {uvxPath}";
|
|
}
|
|
else if (!string.IsNullOrEmpty(uvxPath))
|
|
{
|
|
// Override path valid
|
|
uvxPathOverride.value = uvxPath;
|
|
}
|
|
else
|
|
{
|
|
// Override set but invalid, no fallback available
|
|
string overridePath = EditorPrefs.GetString(EditorPrefKeys.UvxPathOverride, string.Empty);
|
|
uvxPathOverride.value = $"Invalid override path: {overridePath}, no uv found";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uvxPathOverride.value = "uvx (uses PATH)";
|
|
}
|
|
|
|
uvxPathStatus.RemoveFromClassList("valid");
|
|
uvxPathStatus.RemoveFromClassList("invalid");
|
|
uvxPathStatus.RemoveFromClassList("warning");
|
|
|
|
if (hasOverride)
|
|
{
|
|
if (hasFallback)
|
|
{
|
|
// Using fallback - show as warning (yellow)
|
|
uvxPathStatus.AddToClassList("warning");
|
|
}
|
|
else
|
|
{
|
|
// Override mode: validate the override path
|
|
string overridePath = EditorPrefs.GetString(EditorPrefKeys.UvxPathOverride, string.Empty);
|
|
if (pathService.TryValidateUvxExecutable(overridePath, out _))
|
|
{
|
|
uvxPathStatus.AddToClassList("valid");
|
|
}
|
|
else
|
|
{
|
|
uvxPathStatus.AddToClassList("invalid");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// PATH mode: validate system uvx
|
|
string systemUvxPath = pathService.GetUvxPath();
|
|
if (!string.IsNullOrEmpty(systemUvxPath) && pathService.TryValidateUvxExecutable(systemUvxPath, out _))
|
|
{
|
|
uvxPathStatus.AddToClassList("valid");
|
|
}
|
|
else
|
|
{
|
|
uvxPathStatus.AddToClassList("invalid");
|
|
}
|
|
}
|
|
|
|
gitUrlOverride.value = EditorPrefs.GetString(EditorPrefKeys.GitUrlOverride, "");
|
|
debugLogsToggle.value = EditorPrefs.GetBool(EditorPrefKeys.DebugLogs, false);
|
|
devModeForceRefreshToggle.value = EditorPrefs.GetBool(EditorPrefKeys.DevModeForceServerRefresh, false);
|
|
useBetaServerToggle.value = EditorConfigurationCache.Instance.UseBetaServer;
|
|
UpdateDeploymentSection();
|
|
}
|
|
|
|
private void OnBrowseUvxClicked()
|
|
{
|
|
string suggested = RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
|
|
? "/opt/homebrew/bin"
|
|
: Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
|
|
string picked = EditorUtility.OpenFilePanel("Select uv Executable", suggested, "");
|
|
if (!string.IsNullOrEmpty(picked))
|
|
{
|
|
try
|
|
{
|
|
MCPServiceLocator.Paths.SetUvxPathOverride(picked);
|
|
UpdatePathOverrides();
|
|
McpLog.Info($"uv path override set to: {picked}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
EditorUtility.DisplayDialog("Invalid Path", ex.Message, "OK");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnClearUvxClicked()
|
|
{
|
|
MCPServiceLocator.Paths.ClearUvxPathOverride();
|
|
UpdatePathOverrides();
|
|
McpLog.Info("uv path override cleared");
|
|
}
|
|
|
|
private void OnBrowseGitUrlClicked()
|
|
{
|
|
string picked = EditorUtility.OpenFolderPanel("Select Server folder", string.Empty, string.Empty);
|
|
if (!string.IsNullOrEmpty(picked))
|
|
{
|
|
gitUrlOverride.value = picked;
|
|
EditorPrefs.SetString(EditorPrefKeys.GitUrlOverride, picked);
|
|
OnGitUrlChanged?.Invoke();
|
|
OnHttpServerCommandUpdateRequested?.Invoke();
|
|
McpLog.Info($"Server source override set to: {picked}");
|
|
}
|
|
}
|
|
|
|
private void UpdateDeploymentSection()
|
|
{
|
|
var deployService = MCPServiceLocator.Deployment;
|
|
|
|
string sourcePath = deployService.GetStoredSourcePath();
|
|
deploySourcePath.value = sourcePath ?? string.Empty;
|
|
|
|
deployTargetLabel.text = $"Target: {deployService.GetTargetDisplayPath()}";
|
|
|
|
string backupPath = deployService.GetLastBackupPath();
|
|
if (deployService.HasBackup())
|
|
{
|
|
// Use forward slashes to avoid backslash escape sequence issues in UI text
|
|
deployBackupLabel.text = $"Last backup: {backupPath?.Replace('\\', '/')}";
|
|
}
|
|
else
|
|
{
|
|
deployBackupLabel.text = "Last backup: none";
|
|
}
|
|
|
|
deployRestoreButton?.SetEnabled(deployService.HasBackup());
|
|
}
|
|
|
|
private void OnBrowseDeploySourceClicked()
|
|
{
|
|
string picked = EditorUtility.OpenFolderPanel("Select MCPForUnity folder", string.Empty, string.Empty);
|
|
if (string.IsNullOrEmpty(picked))
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
MCPServiceLocator.Deployment.SetStoredSourcePath(picked);
|
|
SetDeployStatus($"Source set: {picked}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
EditorUtility.DisplayDialog("Invalid Source", ex.Message, "OK");
|
|
SetDeployStatus("Source selection failed");
|
|
}
|
|
|
|
UpdateDeploymentSection();
|
|
}
|
|
|
|
private void OnClearDeploySourceClicked()
|
|
{
|
|
MCPServiceLocator.Deployment.ClearStoredSourcePath();
|
|
UpdateDeploymentSection();
|
|
SetDeployStatus("Source cleared");
|
|
}
|
|
|
|
private void OnDeployClicked()
|
|
{
|
|
var result = MCPServiceLocator.Deployment.DeployFromStoredSource();
|
|
SetDeployStatus(result.Message, !result.Success);
|
|
|
|
if (!result.Success)
|
|
{
|
|
EditorUtility.DisplayDialog("Deployment Failed", result.Message, "OK");
|
|
}
|
|
else
|
|
{
|
|
EditorUtility.DisplayDialog("Deployment Complete", result.Message + (string.IsNullOrEmpty(result.BackupPath) ? string.Empty : $"\nBackup: {result.BackupPath}"), "OK");
|
|
}
|
|
|
|
UpdateDeploymentSection();
|
|
}
|
|
|
|
private void OnRestoreBackupClicked()
|
|
{
|
|
var result = MCPServiceLocator.Deployment.RestoreLastBackup();
|
|
SetDeployStatus(result.Message, !result.Success);
|
|
|
|
if (!result.Success)
|
|
{
|
|
EditorUtility.DisplayDialog("Restore Failed", result.Message, "OK");
|
|
}
|
|
else
|
|
{
|
|
EditorUtility.DisplayDialog("Restore Complete", result.Message, "OK");
|
|
}
|
|
|
|
UpdateDeploymentSection();
|
|
}
|
|
|
|
private void SetDeployStatus(string message, bool isError = false)
|
|
{
|
|
if (deployStatusLabel == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
deployStatusLabel.text = message;
|
|
deployStatusLabel.style.color = isError
|
|
? new StyleColor(new Color(0.85f, 0.2f, 0.2f))
|
|
: StyleKeyword.Null;
|
|
}
|
|
|
|
public void UpdateHealthStatus(bool isHealthy, string statusText)
|
|
{
|
|
if (healthStatus != null)
|
|
{
|
|
healthStatus.text = statusText;
|
|
}
|
|
|
|
if (healthIndicator != null)
|
|
{
|
|
healthIndicator.RemoveFromClassList("healthy");
|
|
healthIndicator.RemoveFromClassList("disconnected");
|
|
healthIndicator.RemoveFromClassList("unknown");
|
|
|
|
if (isHealthy)
|
|
{
|
|
healthIndicator.AddToClassList("healthy");
|
|
}
|
|
else if (statusText == HealthStatus.Unknown)
|
|
{
|
|
healthIndicator.AddToClassList("unknown");
|
|
}
|
|
else
|
|
{
|
|
healthIndicator.AddToClassList("disconnected");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|