570 lines
18 KiB
Plaintext
570 lines
18 KiB
Plaintext
@using LazyBear.MCP.Services.Logging
|
|
@using LazyBear.MCP.Services.ToolRegistry
|
|
@inject ToolRegistryService Registry
|
|
@inject InMemoryLogSink LogSink
|
|
@inject GlobalKeyboardService KeyboardService
|
|
@inject LocalizationService Localization
|
|
@inject IHostApplicationLifetime AppLifetime
|
|
|
|
@implements IDisposable
|
|
|
|
<Rows Expand="true">
|
|
<Panel Title="@($"LazyBear MCP [{Localization.Label}]")"
|
|
TitleColor="@UiPalette.Accent"
|
|
BorderColor="@UiPalette.Frame"
|
|
Expand="true"
|
|
Height="@GetPanelHeight()"
|
|
Padding="@(new Spectre.Console.Padding(1, 0, 1, 0))">
|
|
<Rows Expand="true">
|
|
<Markup Content="@Localization.Current.HintBar" Foreground="@UiPalette.TextMuted" />
|
|
<Markup Content=" " />
|
|
|
|
<Columns>
|
|
@foreach (var tab in _tabs)
|
|
{
|
|
var isActive = _activeTab == tab;
|
|
<Markup Content="@($" {GetTabLabel(tab)} ")"
|
|
Foreground="@(isActive ? UiPalette.SelectionForeground : UiPalette.Text)"
|
|
Background="@(isActive ? UiPalette.Accent : UiPalette.SurfaceMuted)"
|
|
Decoration="@(isActive ? Spectre.Console.Decoration.Bold : Spectre.Console.Decoration.None)" />
|
|
<Markup Content=" " />
|
|
}
|
|
</Columns>
|
|
|
|
<Markup Content=" " />
|
|
|
|
@if (_activeTab == Tab.Overview)
|
|
{
|
|
<OverviewTab Rows="@GetOverviewRows()"
|
|
SelectedIndex="@_overviewSelection"
|
|
SelectedIndexChanged="@OnOverviewSelectionChanged"
|
|
ViewportRows="@GetOverviewViewportRows()"
|
|
Endpoint="@_mcpEndpoint"
|
|
Loc="@Localization.Current" />
|
|
}
|
|
else if (_activeTab == Tab.Logs)
|
|
{
|
|
<LogsTab Entries="@GetFilteredLogEntries()"
|
|
SelectedIndex="@_logSelection"
|
|
SelectedIndexChanged="@OnLogSelectionChanged"
|
|
SelectedFilter="@_logFilters[_logFilterIndex]"
|
|
ViewportRows="@GetLogsViewportRows()"
|
|
IsStickyToBottom="@_logsStickToBottom"
|
|
Loc="@Localization.Current" />
|
|
}
|
|
else
|
|
{
|
|
<SettingsTab Entries="@GetSettingsEntries()"
|
|
SelectedIndex="@_settingsSelection"
|
|
SelectedIndexChanged="@OnSettingsSelectionChanged"
|
|
ViewportRows="@GetSettingsViewportRows()"
|
|
Loc="@Localization.Current" />
|
|
}
|
|
</Rows>
|
|
</Panel>
|
|
</Rows>
|
|
|
|
@code {
|
|
private enum Tab
|
|
{
|
|
Overview,
|
|
Logs,
|
|
Settings
|
|
}
|
|
|
|
private static readonly Tab[] _tabs = [Tab.Overview, Tab.Logs, Tab.Settings];
|
|
private static readonly string[] _logFilters = ["All", "Info", "Warn", "Error"];
|
|
private readonly HashSet<string> _expandedModules = new(StringComparer.Ordinal);
|
|
|
|
private Tab _activeTab = Tab.Overview;
|
|
private int _overviewSelection;
|
|
private int _logFilterIndex;
|
|
private int _logSelection;
|
|
private int _settingsSelection;
|
|
private bool _logsStickToBottom = true;
|
|
|
|
private static readonly string _mcpEndpoint =
|
|
Environment.GetEnvironmentVariable("ASPNETCORE_URLS") ?? "http://localhost:5000";
|
|
|
|
private static int GetPanelHeight() => Math.Max(Console.WindowHeight - 2, 10);
|
|
private static int GetOverviewViewportRows() => Math.Max(Console.WindowHeight - 11, 3);
|
|
private static int GetLogsViewportRows() => Math.Max(Console.WindowHeight - 16, 5);
|
|
private static int GetSettingsViewportRows() => Math.Max(Console.WindowHeight - 13, 5);
|
|
|
|
protected override void OnInitialized()
|
|
{
|
|
Registry.StateChanged += OnRegistryChanged;
|
|
LogSink.OnLog += OnNewLog;
|
|
KeyboardService.OnKeyPressed += OnConsoleKeyPressed;
|
|
Localization.OnChanged += OnLocaleChanged;
|
|
}
|
|
|
|
// Конвертация ConsoleKeyInfo → KeyboardEventArgs для переиспользования существующей логики
|
|
private static KeyboardEventArgs ConvertKey(ConsoleKeyInfo key)
|
|
{
|
|
var name = key.Key switch
|
|
{
|
|
ConsoleKey.UpArrow => "ArrowUp",
|
|
ConsoleKey.DownArrow => "ArrowDown",
|
|
ConsoleKey.LeftArrow => "ArrowLeft",
|
|
ConsoleKey.RightArrow => "ArrowRight",
|
|
ConsoleKey.Enter => "Enter",
|
|
ConsoleKey.Spacebar => " ",
|
|
ConsoleKey.Home => "Home",
|
|
ConsoleKey.End => "End",
|
|
ConsoleKey.PageUp => "PageUp",
|
|
ConsoleKey.PageDown => "PageDown",
|
|
ConsoleKey.Tab => "Tab",
|
|
_ => key.KeyChar == '\0' ? string.Empty : key.KeyChar.ToString()
|
|
};
|
|
|
|
return new KeyboardEventArgs
|
|
{
|
|
Key = name,
|
|
ShiftKey = (key.Modifiers & ConsoleModifiers.Shift) != 0
|
|
};
|
|
}
|
|
|
|
private void OnConsoleKeyPressed(ConsoleKeyInfo key)
|
|
{
|
|
var args = ConvertKey(key);
|
|
if (string.IsNullOrEmpty(args.Key))
|
|
{
|
|
return;
|
|
}
|
|
|
|
InvokeAsync(() =>
|
|
{
|
|
HandleKeyDown(args);
|
|
StateHasChanged();
|
|
});
|
|
}
|
|
|
|
private void OnLocaleChanged() =>
|
|
InvokeAsync(StateHasChanged);
|
|
|
|
private void HandleKeyDown(KeyboardEventArgs args)
|
|
{
|
|
if (string.Equals(args.Key, "Tab", StringComparison.Ordinal))
|
|
{
|
|
ChangeTab(args.ShiftKey ? -1 : 1);
|
|
return;
|
|
}
|
|
|
|
if (args.Key is "l" or "L")
|
|
{
|
|
Localization.SwitchNext();
|
|
return; // StateHasChanged вызовет OnLocaleChanged
|
|
}
|
|
|
|
if (args.Key is "q" or "Q")
|
|
{
|
|
AppLifetime.StopApplication();
|
|
return;
|
|
}
|
|
|
|
switch (_activeTab)
|
|
{
|
|
case Tab.Overview:
|
|
HandleOverviewKey(args);
|
|
break;
|
|
case Tab.Logs:
|
|
HandleLogsKey(args);
|
|
break;
|
|
case Tab.Settings:
|
|
HandleSettingsKey(args);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private Task OnOverviewSelectionChanged(int value)
|
|
{
|
|
var rows = GetOverviewRows();
|
|
_overviewSelection = rows.Count == 0 ? 0 : Math.Clamp(value, 0, rows.Count - 1);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Task OnLogSelectionChanged(int value)
|
|
{
|
|
var entries = GetFilteredLogEntries();
|
|
_logSelection = entries.Count == 0 ? 0 : Math.Clamp(value, 0, entries.Count - 1);
|
|
_logsStickToBottom = entries.Count == 0 || _logSelection >= entries.Count - 1;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Task OnSettingsSelectionChanged(int value)
|
|
{
|
|
var entries = GetSettingsEntries();
|
|
_settingsSelection = entries.Count == 0 ? 0 : Math.Clamp(value, 0, entries.Count - 1);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private void ChangeTab(int step)
|
|
{
|
|
var currentIndex = Array.IndexOf(_tabs, _activeTab);
|
|
if (currentIndex < 0)
|
|
{
|
|
currentIndex = 0;
|
|
}
|
|
|
|
var nextIndex = (currentIndex + step + _tabs.Length) % _tabs.Length;
|
|
_activeTab = _tabs[nextIndex];
|
|
ClampSelections();
|
|
}
|
|
|
|
private void HandleOverviewKey(KeyboardEventArgs args)
|
|
{
|
|
var rows = GetOverviewRows();
|
|
if (rows.Count == 0)
|
|
{
|
|
_overviewSelection = 0;
|
|
return;
|
|
}
|
|
|
|
_overviewSelection = Math.Clamp(_overviewSelection, 0, rows.Count - 1);
|
|
|
|
switch (args.Key)
|
|
{
|
|
case "ArrowUp":
|
|
_overviewSelection = Math.Max(0, _overviewSelection - 1);
|
|
break;
|
|
case "ArrowDown":
|
|
_overviewSelection = Math.Min(rows.Count - 1, _overviewSelection + 1);
|
|
break;
|
|
case "Home":
|
|
_overviewSelection = 0;
|
|
break;
|
|
case "End":
|
|
_overviewSelection = rows.Count - 1;
|
|
break;
|
|
case "Enter":
|
|
_activeTab = Tab.Settings;
|
|
SelectSettingsModule(rows[_overviewSelection].ModuleName);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void HandleLogsKey(KeyboardEventArgs args)
|
|
{
|
|
switch (args.Key)
|
|
{
|
|
case "ArrowLeft":
|
|
_logFilterIndex = (_logFilterIndex - 1 + _logFilters.Length) % _logFilters.Length;
|
|
ResetLogsSelectionToBottom();
|
|
return;
|
|
case "ArrowRight":
|
|
_logFilterIndex = (_logFilterIndex + 1) % _logFilters.Length;
|
|
ResetLogsSelectionToBottom();
|
|
return;
|
|
}
|
|
|
|
var entries = GetFilteredLogEntries();
|
|
if (entries.Count == 0)
|
|
{
|
|
_logSelection = 0;
|
|
_logsStickToBottom = true;
|
|
return;
|
|
}
|
|
|
|
_logSelection = Math.Clamp(_logSelection, 0, entries.Count - 1);
|
|
var page = Math.Max(GetLogsViewportRows() - 1, 1);
|
|
|
|
switch (args.Key)
|
|
{
|
|
case "ArrowUp":
|
|
_logSelection = Math.Max(0, _logSelection - 1);
|
|
break;
|
|
case "ArrowDown":
|
|
_logSelection = Math.Min(entries.Count - 1, _logSelection + 1);
|
|
break;
|
|
case "PageUp":
|
|
_logSelection = Math.Max(0, _logSelection - page);
|
|
break;
|
|
case "PageDown":
|
|
case " ":
|
|
case "Spacebar":
|
|
_logSelection = Math.Min(entries.Count - 1, _logSelection + page);
|
|
break;
|
|
case "Home":
|
|
_logSelection = 0;
|
|
break;
|
|
case "End":
|
|
_logSelection = entries.Count - 1;
|
|
break;
|
|
}
|
|
|
|
_logsStickToBottom = _logSelection >= entries.Count - 1;
|
|
}
|
|
|
|
private void HandleSettingsKey(KeyboardEventArgs args)
|
|
{
|
|
var entries = GetSettingsEntries();
|
|
if (entries.Count == 0)
|
|
{
|
|
_settingsSelection = 0;
|
|
return;
|
|
}
|
|
|
|
_settingsSelection = Math.Clamp(_settingsSelection, 0, entries.Count - 1);
|
|
var selected = entries[_settingsSelection];
|
|
var page = Math.Max(GetSettingsViewportRows() - 1, 1);
|
|
|
|
switch (args.Key)
|
|
{
|
|
case "ArrowUp":
|
|
_settingsSelection = Math.Max(0, _settingsSelection - 1);
|
|
return;
|
|
case "ArrowDown":
|
|
_settingsSelection = Math.Min(entries.Count - 1, _settingsSelection + 1);
|
|
return;
|
|
case "PageUp":
|
|
_settingsSelection = Math.Max(0, _settingsSelection - page);
|
|
return;
|
|
case "PageDown":
|
|
_settingsSelection = Math.Min(entries.Count - 1, _settingsSelection + page);
|
|
return;
|
|
case "Home":
|
|
_settingsSelection = 0;
|
|
return;
|
|
case "End":
|
|
_settingsSelection = entries.Count - 1;
|
|
return;
|
|
case "ArrowRight":
|
|
ExpandModule(selected);
|
|
return;
|
|
case "ArrowLeft":
|
|
CollapseModuleOrFocusParent(selected);
|
|
return;
|
|
case "Enter":
|
|
ToggleExpansion(selected);
|
|
return;
|
|
case " ":
|
|
case "Spacebar":
|
|
ToggleSetting(selected);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void ExpandModule(SettingsEntry entry)
|
|
{
|
|
if (entry.Kind != SettingsEntryKind.Module || entry.IsExpanded)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_expandedModules.Add(entry.ModuleName);
|
|
ClampSelections();
|
|
}
|
|
|
|
private void CollapseModuleOrFocusParent(SettingsEntry entry)
|
|
{
|
|
if (entry.Kind == SettingsEntryKind.Module)
|
|
{
|
|
if (_expandedModules.Remove(entry.ModuleName))
|
|
{
|
|
ClampSelections();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
_expandedModules.Remove(entry.ModuleName);
|
|
SelectSettingsModule(entry.ModuleName);
|
|
}
|
|
|
|
private void ToggleExpansion(SettingsEntry entry)
|
|
{
|
|
if (entry.Kind != SettingsEntryKind.Module)
|
|
{
|
|
ToggleSetting(entry);
|
|
return;
|
|
}
|
|
|
|
if (_expandedModules.Contains(entry.ModuleName))
|
|
{
|
|
_expandedModules.Remove(entry.ModuleName);
|
|
}
|
|
else
|
|
{
|
|
_expandedModules.Add(entry.ModuleName);
|
|
}
|
|
|
|
SelectSettingsModule(entry.ModuleName);
|
|
}
|
|
|
|
private void ToggleSetting(SettingsEntry entry)
|
|
{
|
|
if (entry.Kind == SettingsEntryKind.Module)
|
|
{
|
|
Registry.ToggleModule(entry.ModuleName);
|
|
return;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(entry.ToolName))
|
|
{
|
|
Registry.ToggleTool(entry.ModuleName, entry.ToolName);
|
|
}
|
|
}
|
|
|
|
private void SelectSettingsModule(string moduleName)
|
|
{
|
|
var entries = GetSettingsEntries();
|
|
var index = entries.FindIndex(entry =>
|
|
entry.Kind == SettingsEntryKind.Module &&
|
|
string.Equals(entry.ModuleName, moduleName, StringComparison.Ordinal));
|
|
|
|
_settingsSelection = index >= 0 ? index : 0;
|
|
}
|
|
|
|
private void ResetLogsSelectionToBottom()
|
|
{
|
|
var entries = GetFilteredLogEntries();
|
|
_logSelection = Math.Max(entries.Count - 1, 0);
|
|
_logsStickToBottom = true;
|
|
}
|
|
|
|
private List<OverviewRow> GetOverviewRows() =>
|
|
Registry.GetModules()
|
|
.Select(module =>
|
|
{
|
|
var (configuredTools, totalTools) = Registry.GetConfiguredToolCounts(module.ModuleName);
|
|
return new OverviewRow(
|
|
module.ModuleName,
|
|
module.Description,
|
|
Registry.IsModuleEnabled(module.ModuleName),
|
|
configuredTools,
|
|
totalTools);
|
|
})
|
|
.ToList();
|
|
|
|
private List<SettingsEntry> GetSettingsEntries()
|
|
{
|
|
var entries = new List<SettingsEntry>();
|
|
|
|
foreach (var module in Registry.GetModules())
|
|
{
|
|
var isModuleEnabled = Registry.IsModuleEnabled(module.ModuleName);
|
|
var isExpanded = _expandedModules.Contains(module.ModuleName);
|
|
|
|
entries.Add(new SettingsEntry(
|
|
SettingsEntryKind.Module,
|
|
module.ModuleName,
|
|
null,
|
|
module.ModuleName,
|
|
module.Description,
|
|
isModuleEnabled,
|
|
isModuleEnabled,
|
|
isExpanded,
|
|
0));
|
|
|
|
if (!isExpanded)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach (var toolName in module.ToolNames)
|
|
{
|
|
var isConfigured = Registry.IsToolConfiguredEnabled(module.ModuleName, toolName);
|
|
entries.Add(new SettingsEntry(
|
|
SettingsEntryKind.Tool,
|
|
module.ModuleName,
|
|
toolName,
|
|
toolName,
|
|
isModuleEnabled
|
|
? $"{module.ModuleName} / {toolName}"
|
|
: $"{module.ModuleName} / {toolName} {Localization.Current.ModuleOffPreserved}",
|
|
isConfigured,
|
|
isModuleEnabled,
|
|
false,
|
|
1));
|
|
}
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private List<LogEntry> GetFilteredLogEntries()
|
|
{
|
|
var entries = LogSink.GetEntries();
|
|
return _logFilters[_logFilterIndex] switch
|
|
{
|
|
"Info" => entries.Where(IsInfoLevel).ToList(),
|
|
"Warn" => entries.Where(entry => entry.Level == LogLevel.Warning).ToList(),
|
|
"Error" => entries.Where(entry => entry.Level is LogLevel.Error or LogLevel.Critical).ToList(),
|
|
_ => entries.ToList()
|
|
};
|
|
}
|
|
|
|
private void ClampSelections()
|
|
{
|
|
var overviewRows = GetOverviewRows();
|
|
_overviewSelection = overviewRows.Count == 0
|
|
? 0
|
|
: Math.Clamp(_overviewSelection, 0, overviewRows.Count - 1);
|
|
|
|
var logEntries = GetFilteredLogEntries();
|
|
_logSelection = logEntries.Count == 0
|
|
? 0
|
|
: Math.Clamp(_logSelection, 0, logEntries.Count - 1);
|
|
|
|
var settingsEntries = GetSettingsEntries();
|
|
_settingsSelection = settingsEntries.Count == 0
|
|
? 0
|
|
: Math.Clamp(_settingsSelection, 0, settingsEntries.Count - 1);
|
|
}
|
|
|
|
private void OnRegistryChanged()
|
|
{
|
|
InvokeAsync(() =>
|
|
{
|
|
ClampSelections();
|
|
StateHasChanged();
|
|
});
|
|
}
|
|
|
|
private void OnNewLog(LogEntry entry)
|
|
{
|
|
InvokeAsync(() =>
|
|
{
|
|
if (_logsStickToBottom && MatchesCurrentLogFilter(entry))
|
|
{
|
|
var filteredEntries = GetFilteredLogEntries();
|
|
_logSelection = Math.Max(filteredEntries.Count - 1, 0);
|
|
}
|
|
else
|
|
{
|
|
ClampSelections();
|
|
}
|
|
|
|
StateHasChanged();
|
|
});
|
|
}
|
|
|
|
private bool MatchesCurrentLogFilter(LogEntry entry) =>
|
|
_logFilters[_logFilterIndex] switch
|
|
{
|
|
"Info" => IsInfoLevel(entry),
|
|
"Warn" => entry.Level == LogLevel.Warning,
|
|
"Error" => entry.Level is LogLevel.Error or LogLevel.Critical,
|
|
_ => true
|
|
};
|
|
|
|
private static bool IsInfoLevel(LogEntry entry) =>
|
|
entry.Level is LogLevel.Information or LogLevel.Debug or LogLevel.Trace;
|
|
|
|
private string GetTabLabel(Tab tab) => tab switch
|
|
{
|
|
Tab.Overview => Localization.Current.TabOverview,
|
|
Tab.Logs => Localization.Current.TabLogs,
|
|
_ => Localization.Current.TabSettings
|
|
};
|
|
|
|
public void Dispose()
|
|
{
|
|
Registry.StateChanged -= OnRegistryChanged;
|
|
LogSink.OnLog -= OnNewLog;
|
|
KeyboardService.OnKeyPressed -= OnConsoleKeyPressed;
|
|
Localization.OnChanged -= OnLocaleChanged;
|
|
}
|
|
}
|