Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++

feat(windows): port full MCP Server from macOS (phases 1-7, testable)

DangHuynh2070bceb48c3
diff --git a/windows/Gridex/App.xaml.cpp b/windows/Gridex/App.xaml.cpp
index 1fe8d64..8a62124 100644
--- a/windows/Gridex/App.xaml.cpp
+++ b/windows/Gridex/App.xaml.cpp
@@ -3,9 +3,13 @@
#include "App.xaml.h"
#include "MainWindow.xaml.h"
#include "UpdateService.h"
+#include "Models/AppSettings.h"
+#include "Services/MCP/MCPServerHost.h"
+#include "GridexVersion.h"
#include <shellapi.h>
#include <string>
#include <cwchar>
+#include <condition_variable>
using namespace winrt;
using namespace Microsoft::UI::Xaml;
@@ -84,6 +88,17 @@ namespace winrt::Gridex::implementation
}
HWND App::MainHwnd = nullptr;
+
+ // GRIDEX_VERSION is wide; MCPServer needs narrow for JSON-RPC.
+ static std::string GridexVersionAscii()
+ {
+ std::wstring w(GRIDEX_VERSION);
+ std::string out;
+ out.reserve(w.size());
+ for (wchar_t c : w) out.push_back(static_cast<char>(c & 0x7F));
+ return out;
+ }
+
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
@@ -121,12 +136,73 @@ namespace winrt::Gridex::implementation
/// Invoked when the application is launched.
/// </summary>
/// <param name="e">Details about the launch request and process.</param>
+ // Detect `--mcp-stdio` anywhere in the command line. WinUI 3
+ // packs args into `LaunchActivatedEventArgs::Arguments()` but for
+ // unpackaged runs we also look at the Win32 command line.
+ static bool IsMcpStdioMode()
+ {
+ LPWSTR cmd = GetCommandLineW();
+ if (!cmd) return false;
+ int argc = 0;
+ LPWSTR* argv = CommandLineToArgvW(cmd, &argc);
+ if (!argv) return false;
+ bool hit = false;
+ for (int i = 1; i < argc; ++i)
+ if (wcscmp(argv[i], L"--mcp-stdio") == 0) { hit = true; break; }
+ LocalFree(argv);
+ return hit;
+ }
+
void App::OnLaunched([[maybe_unused]] LaunchActivatedEventArgs const& e)
{
+ if (IsMcpStdioMode())
+ {
+ // Headless MCP server mode — spawned by Claude Desktop /
+ // other MCP clients with stdin/stdout piped. No XAML
+ // window is created; we block the main thread until the
+ // reader hits EOF and then exit.
+ auto s = DBModels::AppSettings::Load();
+ DBModels::MCPServerHost::ensureCreated(
+ s,
+ GridexVersionAscii(),
+ DBModels::MCPTransportMode::Stdio);
+ DBModels::MCPServerHost::start();
+
+ // Park the main thread; stdio reader runs on its own
+ // thread inside the server. Exit when the reader thread
+ // signals shutdown (EOF or "shutdown" JSON-RPC).
+ std::mutex mtx; std::condition_variable cv; bool done = false;
+ std::thread waiter([&]{
+ while (auto* srv = DBModels::MCPServerHost::instance())
+ {
+ if (!srv->isRunning()) break;
+ std::this_thread::sleep_for(std::chrono::seconds(1));
+ }
+ { std::lock_guard<std::mutex> lk(mtx); done = true; }
+ cv.notify_all();
+ });
+ std::unique_lock<std::mutex> lk(mtx);
+ cv.wait(lk, [&]{ return done; });
+ waiter.join();
+ DBModels::MCPServerHost::stop();
+ ExitProcess(0);
+ }
+
window = make<MainWindow>();
window.Activate();
auto windowNative = window.as<IWindowNative>();
windowNative->get_WindowHandle(&MainHwnd);
+
+ // Auto-start MCP server if user enabled it last session.
+ auto settings = DBModels::AppSettings::Load();
+ if (settings.mcpEnabled)
+ {
+ DBModels::MCPServerHost::ensureCreated(
+ settings,
+ GridexVersionAscii(),
+ DBModels::MCPTransportMode::HttpOnly);
+ DBModels::MCPServerHost::start();
+ }
}
}
diff --git a/windows/Gridex/AppSettings.cpp b/windows/Gridex/AppSettings.cpp
index 1e9fcdb..80e9e99 100644
--- a/windows/Gridex/AppSettings.cpp
+++ b/windows/Gridex/AppSettings.cpp
@@ -326,6 +326,41 @@ namespace DBModels
s.rowLimit = extractInt(json, L"rowLimit", 100);
s.lastPageBeforeSettings = extractString(json, L"lastPageBeforeSettings");
s.connectionGroups = extractStringArray(json, L"connectionGroups");
+
+ // MCP — all fields optional for forward compat with 0.1.3 settings.
+ s.mcpEnabled = extractBool(json, L"mcpEnabled", false);
+ s.mcpHttpEnabled = extractBool(json, L"mcpHttpEnabled", false);
+ s.mcpHttpPort = extractInt(json, L"mcpHttpPort", 3333);
+ s.mcpAllowRemoteHTTP = extractBool(json, L"mcpAllowRemoteHTTP", false);
+ s.mcpRequireApprovalForWrites = extractBool(json, L"mcpRequireApprovalForWrites", true);
+ s.mcpQueriesPerMinute = extractInt(json, L"mcpQueriesPerMinute", 60);
+ s.mcpQueriesPerHour = extractInt(json, L"mcpQueriesPerHour", 1000);
+ s.mcpWritesPerMinute = extractInt(json, L"mcpWritesPerMinute", 10);
+ s.mcpDdlPerMinute = extractInt(json, L"mcpDdlPerMinute", 1);
+ s.mcpQueryTimeout = extractInt(json, L"mcpQueryTimeout", 30);
+ s.mcpApprovalTimeout = extractInt(json, L"mcpApprovalTimeout", 60);
+ s.mcpConnectionTimeout = extractInt(json, L"mcpConnectionTimeout", 10);
+ s.mcpAuditRetentionDays = extractInt(json, L"mcpAuditRetentionDays", 90);
+ s.mcpAuditMaxSizeMB = extractInt(json, L"mcpAuditMaxSizeMB", 100);
+ // 64-bit unix seconds: extractInt returns 32-bit; for mcpStartTime
+ // we bounce through wide-stoll to cover dates past 2038.
+ {
+ std::wstring needle = L"\"mcpStartTime\":";
+ size_t pos = json.find(needle);
+ if (pos != std::wstring::npos)
+ {
+ pos += needle.size();
+ while (pos < json.size() && (json[pos] == L' ' || json[pos] == L'\t')) pos++;
+ std::wstring num;
+ if (pos < json.size() && (json[pos] == L'-' || iswdigit(json[pos])))
+ {
+ num += json[pos++];
+ while (pos < json.size() && iswdigit(json[pos])) num += json[pos++];
+ }
+ if (!num.empty()) { try { s.mcpStartTime = std::stoll(num); } catch (...) {} }
+ }
+ }
+
return s;
}
@@ -352,7 +387,26 @@ namespace DBModels
if (i > 0) ss << L", ";
ss << L"\"" << escapeJson(connectionGroups[i]) << L"\"";
}
- ss << L"]\n";
+ ss << L"],\n";
+
+ // MCP block. Booleans written as literal true/false; ints
+ // as plain numbers. Group at the end to minimize diff churn
+ // if we add more prefs later.
+ ss << L" \"mcpEnabled\": " << (mcpEnabled ? L"true" : L"false") << L",\n";
+ ss << L" \"mcpHttpEnabled\": " << (mcpHttpEnabled ? L"true" : L"false") << L",\n";
+ ss << L" \"mcpHttpPort\": " << mcpHttpPort << L",\n";
+ ss << L" \"mcpAllowRemoteHTTP\": " << (mcpAllowRemoteHTTP ? L"true" : L"false") << L",\n";
+ ss << L" \"mcpRequireApprovalForWrites\": " << (mcpRequireApprovalForWrites ? L"true" : L"false") << L",\n";
+ ss << L" \"mcpQueriesPerMinute\": " << mcpQueriesPerMinute << L",\n";
+ ss << L" \"mcpQueriesPerHour\": " << mcpQueriesPerHour << L",\n";
+ ss << L" \"mcpWritesPerMinute\": " << mcpWritesPerMinute << L",\n";
+ ss << L" \"mcpDdlPerMinute\": " << mcpDdlPerMinute << L",\n";
+ ss << L" \"mcpQueryTimeout\": " << mcpQueryTimeout << L",\n";
+ ss << L" \"mcpApprovalTimeout\": " << mcpApprovalTimeout << L",\n";
+ ss << L" \"mcpConnectionTimeout\": " << mcpConnectionTimeout << L",\n";
+ ss << L" \"mcpAuditRetentionDays\": " << mcpAuditRetentionDays << L",\n";
+ ss << L" \"mcpAuditMaxSizeMB\": " << mcpAuditMaxSizeMB << L",\n";
+ ss << L" \"mcpStartTime\": " << mcpStartTime << L"\n";
ss << L"}\n";
std::string utf8 = toUtf8(ss.str());
diff --git a/windows/Gridex/Gridex.items.props b/windows/Gridex/Gridex.items.props
index 6ef0a8d..479fc71 100644
--- a/windows/Gridex/Gridex.items.props
+++ b/windows/Gridex/Gridex.items.props
@@ -20,6 +20,40 @@
<ClInclude Include="$(MSBuildThisFileDirectory)Models\RowValue.h" />
<ClInclude Include="$(MSBuildThisFileDirectory)Models\TableInfo.h" />
<ClInclude Include="$(MSBuildThisFileDirectory)Models\QueryParameter.h" />
+ <!-- MCP Phase 1 — core types (header-only, no ClCompile yet). -->
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPConnectionMode.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPPermissionTier.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPErrorCode.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPProtocol.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPServerInfo.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPToolDefinition.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPToolError.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Models\MCP\MCPAuditEntry.h" />
+ <!-- MCP Phase 2 — security. -->
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPSQLSanitizer.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPIdentifierValidator.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPPermissionResult.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPPermissionEngine.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPRateLimiter.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPApprovalGate.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPRowCountEstimator.h" />
+ <!-- MCP Phase 3 — audit. -->
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Audit\MCPAuditLogger.h" />
+ <!-- MCP Phase 4 — transport + server. HTTP transport TBD (Phase 4d). -->
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\MCPConnectionPool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\MCPServer.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPTool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPToolRegistry.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Transport\StdioTransport.h" />
+ <!-- MCP Phase 5 — tools (subset: list_connections, list_tables,
+ describe_table, query). Tier 3 write tools land in a follow-up. -->
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPToolHelpers.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPBuiltinTools.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\ListConnectionsTool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\ListTablesTool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\DescribeTableTool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier2\QueryTool.h" />
+ <ClInclude Include="$(MSBuildThisFileDirectory)Services\MCP\MCPServerHost.h" />
<ClInclude Include="$(MSBuildThisFileDirectory)Models\DatabaseAdapter.h" />
<ClInclude Include="$(MSBuildThisFileDirectory)Models\ConnectionManager.h" />
<ClInclude Include="$(MSBuildThisFileDirectory)Models\PostgreSQLAdapter.h" />
@@ -43,6 +77,10 @@
<DependentUpon>SettingsPage.xaml</DependentUpon>
<SubType>Code</SubType>
</ClInclude>
+ <ClInclude Include="$(MSBuildThisFileDirectory)MCPPage.h">
+ <DependentUpon>MCPPage.xaml</DependentUpon>
+ <SubType>Code</SubType>
+ </ClInclude>
<ClInclude Include="$(MSBuildThisFileDirectory)ConnectionCard.h">
<DependentUpon>ConnectionCard.xaml</DependentUpon>
<SubType>Code</SubType>
@@ -150,6 +188,9 @@
<Page Include="$(MSBuildThisFileDirectory)SettingsPage.xaml">
<SubType>Designer</SubType>
</Page>
+ <Page Include="$(MSBuildThisFileDirectory)MCPPage.xaml">
+ <SubType>Designer</SubType>
+ </Page>
</ItemGroup>
<ItemGroup>
<ClCompile Include="$(MSBuildThisFileDirectory)ConnectionCard.cpp">
@@ -258,6 +299,64 @@
<ClCompile Include="$(MSBuildThisFileDirectory)DumpRestoreService.cpp">
<PrecompiledHeader>NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPSQLSanitizer.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPIdentifierValidator.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPPermissionEngine.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPRateLimiter.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPApprovalGate.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Security\MCPRowCountEstimator.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Audit\MCPAuditLogger.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\MCPConnectionPool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\MCPServer.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPTool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPToolRegistry.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Transport\StdioTransport.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\MCPBuiltinTools.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\ListConnectionsTool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\ListTablesTool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier1\DescribeTableTool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\Tools\Tier2\QueryTool.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <ClCompile Include="$(MSBuildThisFileDirectory)Services\MCP\MCPServerHost.cpp">
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ </ClCompile>
+ <!-- MCP Phase 6 UI — WinUI 3 Page with 5 tabs. -->
+ <ClCompile Include="$(MSBuildThisFileDirectory)MCPPage.cpp">
+ <DependentUpon>MCPPage.xaml</DependentUpon>
+ </ClCompile>
<ClCompile Include="$(MSBuildThisFileDirectory)ERDiagramService.cpp">
<PrecompiledHeader>NotUsing</PrecompiledHeader>
</ClCompile>
@@ -333,5 +432,9 @@
<DependentUpon>SettingsPage.xaml</DependentUpon>
<SubType>Code</SubType>
</Midl>
+ <Midl Include="$(MSBuildThisFileDirectory)MCPPage.idl">
+ <DependentUpon>MCPPage.xaml</DependentUpon>
+ <SubType>Code</SubType>
+ </Midl>
</ItemGroup>
</Project>
diff --git a/windows/Gridex/HomePage.cpp b/windows/Gridex/HomePage.cpp
index 834c7cb..1ba1a67 100644
--- a/windows/Gridex/HomePage.cpp
+++ b/windows/Gridex/HomePage.cpp
@@ -467,6 +467,29 @@ namespace winrt::Gridex::implementation
frame.Navigate(pageType);
}
+ void HomePage::OpenMcp_Click(
+ winrt::Windows::Foundation::IInspectable const&, mux::RoutedEventArgs const&)
+ {
+ muxc::Frame frame{ nullptr };
+ auto fe = this->try_as<mux::FrameworkElement>();
+ while (fe)
+ {
+ if (auto f = fe.try_as<muxc::Frame>()) { frame = f; break; }
+ fe = fe.Parent().try_as<mux::FrameworkElement>();
+ }
+ if (!frame) frame = this->Frame();
+ if (!frame) return;
+
+ auto s = DBModels::AppSettings::Load();
+ s.lastPageBeforeSettings = L"Gridex.HomePage";
+ s.Save();
+
+ winrt::Windows::UI::Xaml::Interop::TypeName pageType;
+ pageType.Name = L"Gridex.MCPPage";
+ pageType.Kind = winrt::Windows::UI::Xaml::Interop::TypeKind::Metadata;
+ frame.Navigate(pageType);
+ }
+
void HomePage::ConnectionItem_Click(
winrt::Windows::Foundation::IInspectable const&, muxc::ItemClickEventArgs const& e)
{
diff --git a/windows/Gridex/HomePage.h b/windows/Gridex/HomePage.h
index befa32f..072b6f8 100644
--- a/windows/Gridex/HomePage.h
+++ b/windows/Gridex/HomePage.h
@@ -20,6 +20,9 @@ namespace winrt::Gridex::implementation
void Settings_Click(
winrt::Windows::Foundation::IInspectable const& sender,
winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+ void OpenMcp_Click(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
void ConnectionItem_Click(
winrt::Windows::Foundation::IInspectable const& sender,
winrt::Microsoft::UI::Xaml::Controls::ItemClickEventArgs const& e);
diff --git a/windows/Gridex/HomePage.xaml b/windows/Gridex/HomePage.xaml
index 70b3a57..59b67de 100644
--- a/windows/Gridex/HomePage.xaml
+++ b/windows/Gridex/HomePage.xaml
@@ -65,6 +65,20 @@
Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
</StackPanel>
</Button>
+ <Button HorizontalAlignment="Stretch"
+ HorizontalContentAlignment="Left"
+ Padding="8,8"
+ Background="Transparent"
+ BorderThickness="0"
+ Click="OpenMcp_Click"
+ ToolTipService.ToolTip="MCP Server — let AI clients query your databases">
+ <StackPanel Orientation="Horizontal" Spacing="10">
+ <FontIcon Glyph="&#xE703;" FontSize="14"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ <TextBlock Text="MCP Server"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ </StackPanel>
+ </Button>
<Button HorizontalAlignment="Stretch"
HorizontalContentAlignment="Left"
Padding="8,8"
diff --git a/windows/Gridex/MCPPage.cpp b/windows/Gridex/MCPPage.cpp
new file mode 100644
index 0000000..b4f46cf
--- /dev/null
+++ b/windows/Gridex/MCPPage.cpp
@@ -0,0 +1,223 @@
+#include "pch.h"
+#include "xaml-includes.h"
+#include "MCPPage.h"
+#if __has_include("MCPPage.g.cpp")
+#include "MCPPage.g.cpp"
+#endif
+
+#include "Models/AppSettings.h"
+#include "Models/ConnectionStore.h"
+#include "Services/MCP/MCPServerHost.h"
+#include "GridexVersion.h"
+#include <winrt/Windows.ApplicationModel.DataTransfer.h>
+#include <winrt/Windows.UI.h>
+
+namespace winrt::Gridex::implementation
+{
+ namespace mux = winrt::Microsoft::UI::Xaml;
+ namespace muxc = winrt::Microsoft::UI::Xaml::Controls;
+ namespace wadt = winrt::Windows::ApplicationModel::DataTransfer;
+
+ // GRIDEX_VERSION is a wide-string literal in GridexVersion.h — we
+ // need the server version as UTF-8 for the JSON handshake.
+ static std::string versionUtf8()
+ {
+ std::wstring w(GRIDEX_VERSION);
+ std::string out;
+ out.reserve(w.size());
+ for (wchar_t c : w) out.push_back(static_cast<char>(c & 0x7F));
+ return out;
+ }
+
+ MCPPage::MCPPage()
+ {
+ InitializeComponent();
+
+ this->Loaded([this](auto&&, auto&&) { RefreshUI(); });
+ }
+
+ void MCPPage::RefreshUI()
+ {
+ auto settings = DBModels::AppSettings::Load();
+
+ // Populate controls from persisted settings.
+ HttpToggle().IsOn(settings.mcpHttpEnabled);
+ HttpPortBox().Value(static_cast<double>(settings.mcpHttpPort));
+ HttpPortRow().Visibility(settings.mcpHttpEnabled
+ ? mux::Visibility::Visible : mux::Visibility::Collapsed);
+
+ QpmBox().Value(static_cast<double>(settings.mcpQueriesPerMinute));
+ QphBox().Value(static_cast<double>(settings.mcpQueriesPerHour));
+ WpmBox().Value(static_cast<double>(settings.mcpWritesPerMinute));
+ DdlBox().Value(static_cast<double>(settings.mcpDdlPerMinute));
+ RetentionBox().Value(static_cast<double>(settings.mcpAuditRetentionDays));
+ MaxSizeBox().Value(static_cast<double>(settings.mcpAuditMaxSizeMB));
+
+ // Count connections per MCP mode.
+ int locked = 0, ro = 0, rw = 0;
+ auto configs = DBModels::ConnectionStore::Load();
+ for (const auto& c : configs)
+ {
+ switch (c.mcpMode)
+ {
+ case DBModels::MCPConnectionMode::Locked: ++locked; break;
+ case DBModels::MCPConnectionMode::ReadOnly: ++ro; break;
+ case DBModels::MCPConnectionMode::ReadWrite: ++rw; break;
+ }
+ }
+ LockedCount().Text(winrt::hstring(std::to_wstring(locked)));
+ ReadOnlyCount().Text(winrt::hstring(std::to_wstring(ro)));
+ ReadWriteCount().Text(winrt::hstring(std::to_wstring(rw)));
+
+ // Server state.
+ auto* srv = DBModels::MCPServerHost::instance();
+ const bool running = srv && srv->isRunning();
+ ApplyStartStopButton(running);
+ if (running)
+ {
+ const auto tools = srv->toolRegistry().definitions().size();
+ ToolsCountText().Text(winrt::hstring(std::to_wstring(tools) + L" tools"));
+ }
+ else
+ {
+ ToolsCountText().Text(L"0 tools (server stopped)");
+ }
+
+ // Setup tab — show the stdio config snippet for Claude Desktop.
+ wchar_t exePath[MAX_PATH] = {};
+ GetModuleFileNameW(nullptr, exePath, MAX_PATH);
+ std::wstring exe(exePath);
+ // Escape backslashes for JSON embedding.
+ std::wstring escaped;
+ escaped.reserve(exe.size() * 2);
+ for (wchar_t c : exe) { if (c == L'\\') escaped += L"\\\\"; else escaped += c; }
+
+ std::wstring cfg =
+ L"{\n"
+ L" \"mcpServers\": {\n"
+ L" \"gridex\": {\n"
+ L" \"command\": \"" + escaped + L"\",\n"
+ L" \"args\": [\"--mcp-stdio\"]\n"
+ L" }\n"
+ L" }\n"
+ L"}";
+ SetupConfigBox().Text(winrt::hstring(cfg));
+
+ SetupPathText().Text(
+ L"Default Claude Desktop config: %APPDATA%\\Claude\\claude_desktop_config.json");
+
+ ActivityPathText().Text(
+ L"Audit log: %APPDATA%\\Gridex\\mcp-audit.jsonl");
+ }
+
+ void MCPPage::ApplyStartStopButton(bool running)
+ {
+ StartStopBtn().Content(
+ winrt::box_value(winrt::hstring(running ? L"Stop Server" : L"Start Server")));
+ StatusText().Text(running ? L"Running" : L"Stopped");
+ RunningTitle().Text(running
+ ? L"MCP Server is running" : L"MCP Server is stopped");
+ RunningSubtitle().Text(running
+ ? L"AI clients can now see Gridex as an MCP server."
+ : L"Enable below to let AI clients connect.");
+ StatusDot().Fill(
+ mux::Media::SolidColorBrush(
+ winrt::Windows::UI::Colors::Gray()));
+ // Green when running.
+ if (running)
+ {
+ StatusDot().Fill(
+ mux::Media::SolidColorBrush(
+ winrt::Windows::UI::ColorHelper::FromArgb(255, 76, 175, 80)));
+ }
+ }
+
+ void MCPPage::Back_Click(
+ winrt::Windows::Foundation::IInspectable const&,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const&)
+ {
+ if (auto frame = this->Frame())
+ {
+ if (frame.CanGoBack()) frame.GoBack();
+ }
+ }
+
+ void MCPPage::StartStop_Click(
+ winrt::Windows::Foundation::IInspectable const&,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const&)
+ {
+ auto settings = DBModels::AppSettings::Load();
+ auto* srv = DBModels::MCPServerHost::instance();
+
+ if (srv && srv->isRunning())
+ {
+ // Stop.
+ DBModels::MCPServerHost::stop();
+ settings.mcpEnabled = false;
+ settings.Save();
+ }
+ else
+ {
+ // Start — always in HttpOnly mode from the GUI. The
+ // --mcp-stdio CLI path uses a separate bootstrap.
+ DBModels::MCPServerHost::ensureCreated(
+ settings,
+ versionUtf8(),
+ DBModels::MCPTransportMode::HttpOnly);
+
+ // Hook XamlRoot + dispatcher so approval dialogs can open.
+ auto* running = DBModels::MCPServerHost::instance();
+ if (running)
+ {
+ auto content = this->XamlRoot();
+ // Forward pointers as void* — MCPApprovalGate stores
+ // winrt handles internally. We pass the same object
+ // each time; lifetime outlives the server.
+ static winrt::Microsoft::UI::Dispatching::DispatcherQueue dq{ nullptr };
+ static winrt::Microsoft::UI::Xaml::XamlRoot xr{ nullptr };
+ dq = this->DispatcherQueue();
+ xr = content;
+ running->setUIContext(&dq, &xr);
+ }
+
+ DBModels::MCPServerHost::start();
+ settings.mcpEnabled = true;
+ settings.Save();
+ }
+ RefreshUI();
+ }
+
+ void MCPPage::HttpToggle_Toggled(
+ winrt::Windows::Foundation::IInspectable const&,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const&)
+ {
+ HttpPortRow().Visibility(HttpToggle().IsOn()
+ ? mux::Visibility::Visible : mux::Visibility::Collapsed);
+ }
+
+ void MCPPage::CopyConfig_Click(
+ winrt::Windows::Foundation::IInspectable const&,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const&)
+ {
+ wadt::DataPackage pkg;
+ pkg.SetText(SetupConfigBox().Text());
+ wadt::Clipboard::SetContent(pkg);
+ }
+
+ void MCPPage::SaveConfig_Click(
+ winrt::Windows::Foundation::IInspectable const&,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const&)
+ {
+ auto s = DBModels::AppSettings::Load();
+ s.mcpHttpEnabled = HttpToggle().IsOn();
+ s.mcpHttpPort = static_cast<int>(HttpPortBox().Value());
+ s.mcpQueriesPerMinute = static_cast<int>(QpmBox().Value());
+ s.mcpQueriesPerHour = static_cast<int>(QphBox().Value());
+ s.mcpWritesPerMinute = static_cast<int>(WpmBox().Value());
+ s.mcpDdlPerMinute = static_cast<int>(DdlBox().Value());
+ s.mcpAuditRetentionDays = static_cast<int>(RetentionBox().Value());
+ s.mcpAuditMaxSizeMB = static_cast<int>(MaxSizeBox().Value());
+ s.Save();
+ SaveConfigStatusText().Text(L"Saved. Restart the server to apply rate-limit / audit changes.");
+ }
+}
diff --git a/windows/Gridex/MCPPage.h b/windows/Gridex/MCPPage.h
new file mode 100644
index 0000000..67e6fc9
--- /dev/null
+++ b/windows/Gridex/MCPPage.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "MCPPage.g.h"
+
+namespace winrt::Gridex::implementation
+{
+ // MCPPage — Gridex MCP Server dashboard (5 tabs, mirrors macOS).
+ // Overview tab is fully wired; Connections / Activity / Setup / Config
+ // have minimum viable bodies and will grow in follow-up sprints.
+ struct MCPPage : MCPPageT<MCPPage>
+ {
+ MCPPage();
+
+ void Back_Click(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+ void StartStop_Click(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+ void HttpToggle_Toggled(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+ void CopyConfig_Click(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+ void SaveConfig_Click(
+ winrt::Windows::Foundation::IInspectable const& sender,
+ winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+ private:
+ void RefreshUI();
+ void ApplyStartStopButton(bool running);
+ };
+}
+
+namespace winrt::Gridex::factory_implementation
+{
+ struct MCPPage : MCPPageT<MCPPage, implementation::MCPPage> {};
+}
diff --git a/windows/Gridex/MCPPage.idl b/windows/Gridex/MCPPage.idl
new file mode 100644
index 0000000..aa50280
--- /dev/null
+++ b/windows/Gridex/MCPPage.idl
@@ -0,0 +1,8 @@
+namespace Gridex
+{
+ [default_interface]
+ runtimeclass MCPPage : Microsoft.UI.Xaml.Controls.Page
+ {
+ MCPPage();
+ }
+}
diff --git a/windows/Gridex/MCPPage.xaml b/windows/Gridex/MCPPage.xaml
new file mode 100644
index 0000000..716d122
--- /dev/null
+++ b/windows/Gridex/MCPPage.xaml
@@ -0,0 +1,302 @@
+<Page
+ x:Class="Gridex.MCPPage"
+ xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+ xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+ xmlns:local="using:Gridex"
+ Background="Transparent">
+
+ <Grid RowSpacing="0">
+ <Grid.RowDefinitions>
+ <RowDefinition Height="Auto" />
+ <RowDefinition Height="*" />
+ </Grid.RowDefinitions>
+
+ <!-- Header: back button + title + server status pill + Start/Stop -->
+ <Grid Grid.Row="0" Padding="24,16,24,12">
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="Auto" />
+ <ColumnDefinition Width="Auto" />
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+
+ <Button x:Name="BackBtn" Grid.Column="0"
+ Background="Transparent" BorderThickness="0"
+ Padding="8,4" VerticalAlignment="Center"
+ ToolTipService.ToolTip="Back"
+ Click="Back_Click">
+ <StackPanel Orientation="Horizontal" Spacing="6">
+ <FontIcon Glyph="&#xE72B;" FontSize="14" />
+ <TextBlock Text="Back" FontSize="13" />
+ </StackPanel>
+ </Button>
+
+ <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="10"
+ VerticalAlignment="Center" Margin="16,0,0,0">
+ <!-- Status dot — gray (off) / green (running) / orange (pending). -->
+ <Ellipse x:Name="StatusDot" Width="10" Height="10"
+ Fill="Gray" />
+ <StackPanel>
+ <TextBlock Text="MCP Server" FontSize="18" FontWeight="SemiBold" />
+ <TextBlock x:Name="StatusText"
+ Text="Stopped"
+ FontSize="12"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ </StackPanel>
+ </StackPanel>
+
+ <Button x:Name="StartStopBtn" Grid.Column="3"
+ Padding="16,6"
+ Content="Start Server"
+ Click="StartStop_Click"
+ Style="{StaticResource AccentButtonStyle}" />
+ </Grid>
+
+ <!-- Pivot = 5 tabs matching mac. Each tab body is its own
+ panel — Overview is wired fully, the rest show a
+ placeholder until the implementation catches up. -->
+ <Pivot Grid.Row="1" x:Name="Tabs" Margin="16,0,16,16">
+ <PivotItem Header="Overview">
+ <ScrollViewer>
+ <StackPanel Spacing="20" MaxWidth="820" HorizontalAlignment="Stretch">
+
+ <!-- Running card -->
+ <Border Padding="16"
+ Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+ CornerRadius="8"
+ BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+ BorderThickness="1">
+ <StackPanel Orientation="Horizontal" Spacing="12">
+ <FontIcon x:Name="RunningIcon" Glyph="&#xE711;"
+ FontSize="22"
+ Foreground="{ThemeResource TextFillColorTertiaryBrush}" />
+ <StackPanel>
+ <TextBlock x:Name="RunningTitle"
+ Text="MCP Server is stopped"
+ FontSize="14" FontWeight="SemiBold" />
+ <TextBlock x:Name="RunningSubtitle"
+ Text="Enable below to let AI clients connect."
+ FontSize="12"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ </StackPanel>
+ </StackPanel>
+ </Border>
+
+ <!-- Access summary (per-mode connection counts) -->
+ <StackPanel Spacing="8">
+ <TextBlock Text="Access" FontSize="14" FontWeight="SemiBold" />
+ <Border Padding="16" CornerRadius="8"
+ Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+ BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+ BorderThickness="1">
+ <StackPanel Spacing="10">
+ <Grid>
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="Locked" Grid.Column="0" />
+ <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="6">
+ <Ellipse Width="8" Height="8" Fill="Red" />
+ <TextBlock x:Name="LockedCount" Text="0" />
+ </StackPanel>
+ </Grid>
+ <Grid>
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="Read-only" Grid.Column="0" />
+ <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="6">
+ <Ellipse Width="8" Height="8" Fill="DodgerBlue" />
+ <TextBlock x:Name="ReadOnlyCount" Text="0" />
+ </StackPanel>
+ </Grid>
+ <Grid>
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="Read-write" Grid.Column="0" />
+ <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="6">
+ <Ellipse Width="8" Height="8" Fill="SeaGreen" />
+ <TextBlock x:Name="ReadWriteCount" Text="0" />
+ </StackPanel>
+ </Grid>
+ </StackPanel>
+ </Border>
+ </StackPanel>
+
+ <!-- Transport -->
+ <StackPanel Spacing="8">
+ <TextBlock Text="Transport" FontSize="14" FontWeight="SemiBold" />
+ <Border Padding="16" CornerRadius="8"
+ Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+ BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+ BorderThickness="1">
+ <StackPanel Spacing="10">
+ <Grid>
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="stdio" Grid.Column="0" />
+ <TextBlock Text="Local clients ✓"
+ Grid.Column="1"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ </Grid>
+ <Grid>
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="HTTP" Grid.Column="0" />
+ <ToggleSwitch x:Name="HttpToggle"
+ Grid.Column="1"
+ Toggled="HttpToggle_Toggled"
+ OffContent="" OnContent="" />
+ </Grid>
+ <Grid x:Name="HttpPortRow" Visibility="Collapsed">
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="Auto" />
+ </Grid.ColumnDefinitions>
+ <TextBlock Text="Port" Grid.Column="0" />
+ <NumberBox x:Name="HttpPortBox"
+ Grid.Column="1"
+ Minimum="1024" Maximum="65535"
+ Value="3333" Width="120" />
+ </Grid>
+ </StackPanel>
+ </Border>
+ </StackPanel>
+
+ <!-- Tool inventory -->
+ <StackPanel Spacing="4">
+ <TextBlock Text="Tools registered"
+ FontSize="12"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ <TextBlock x:Name="ToolsCountText"
+ Text="0 tools"
+ FontSize="13" />
+ </StackPanel>
+ </StackPanel>
+ </ScrollViewer>
+ </PivotItem>
+
+ <PivotItem Header="Connections">
+ <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center" Spacing="8">
+ <FontIcon Glyph="&#xE968;" FontSize="36"
+ Foreground="{ThemeResource TextFillColorTertiaryBrush}" />
+ <TextBlock Text="Per-connection access mode"
+ HorizontalAlignment="Center" FontSize="14" />
+ <TextBlock Text="Set per-connection Locked / Read-only / Read-write in the Connection Settings dialog for now. This full table view is coming next."
+ HorizontalAlignment="Center" FontSize="12" TextWrapping="Wrap"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+ MaxWidth="520" TextAlignment="Center" />
+ </StackPanel>
+ </PivotItem>
+
+ <PivotItem Header="Activity">
+ <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center" Spacing="8">
+ <FontIcon Glyph="&#xE9D9;" FontSize="36"
+ Foreground="{ThemeResource TextFillColorTertiaryBrush}" />
+ <TextBlock Text="Audit log viewer coming next"
+ HorizontalAlignment="Center" FontSize="14" />
+ <TextBlock x:Name="ActivityPathText"
+ HorizontalAlignment="Center" FontSize="11"
+ Foreground="{ThemeResource TextFillColorTertiaryBrush}"
+ IsTextSelectionEnabled="True" />
+ </StackPanel>
+ </PivotItem>
+
+ <PivotItem Header="Setup">
+ <ScrollViewer>
+ <StackPanel Spacing="16" MaxWidth="820">
+ <TextBlock Text="Paste this JSON into your Claude Desktop config file"
+ FontSize="14" FontWeight="SemiBold" />
+ <TextBlock x:Name="SetupPathText"
+ FontSize="12"
+ IsTextSelectionEnabled="True"
+ Foreground="{ThemeResource TextFillColorSecondaryBrush}" />
+ <Border Padding="12" CornerRadius="6"
+ Background="{ThemeResource CardBackgroundFillColorSecondaryBrush}">
+ <TextBox x:Name="SetupConfigBox"
+ IsReadOnly="True"
+ AcceptsReturn="True"
+ FontFamily="Consolas"
+ FontSize="12"
+ TextWrapping="NoWrap"
+ MinHeight="160" />
+ </Border>
+ <Button x:Name="CopyConfigBtn"
+ Content="Copy Config"
+ Click="CopyConfig_Click"
+ HorizontalAlignment="Left" />
+ </StackPanel>
+ </ScrollViewer>
+ </PivotItem>
+
+ <PivotItem Header="Config">
+ <ScrollViewer>
+ <StackPanel Spacing="16" MaxWidth="820">
+ <TextBlock Text="Rate Limits" FontSize="14" FontWeight="SemiBold" />
+ <Grid ColumnSpacing="16" RowSpacing="8">
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="140" />
+ </Grid.ColumnDefinitions>
+ <Grid.RowDefinitions>
+ <RowDefinition Height="Auto" />
+ <RowDefinition Height="Auto" />
+ <RowDefinition Height="Auto" />
+ <RowDefinition Height="Auto" />
+ </Grid.RowDefinitions>
+
+ <TextBlock Text="Queries per minute" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="QpmBox" Grid.Row="0" Grid.Column="1"
+ Minimum="10" Maximum="500" Value="60" />
+ <TextBlock Text="Queries per hour" Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="QphBox" Grid.Row="1" Grid.Column="1"
+ Minimum="100" Maximum="10000" Value="1000" />
+ <TextBlock Text="Writes per minute" Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="WpmBox" Grid.Row="2" Grid.Column="1"
+ Minimum="1" Maximum="100" Value="10" />
+ <TextBlock Text="DDL per minute" Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="DdlBox" Grid.Row="3" Grid.Column="1"
+ Minimum="1" Maximum="20" Value="1" />
+ </Grid>
+
+ <TextBlock Text="Audit Log" FontSize="14" FontWeight="SemiBold" Margin="0,8,0,0" />
+ <Grid ColumnSpacing="16" RowSpacing="8">
+ <Grid.ColumnDefinitions>
+ <ColumnDefinition Width="*" />
+ <ColumnDefinition Width="140" />
+ </Grid.ColumnDefinitions>
+ <Grid.RowDefinitions>
+ <RowDefinition Height="Auto" />
+ <RowDefinition Height="Auto" />
+ </Grid.RowDefinitions>
+ <TextBlock Text="Retention (days)" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="RetentionBox" Grid.Row="0" Grid.Column="1"
+ Minimum="0" Maximum="3650" Value="90" />
+ <TextBlock Text="Max log size (MB)" Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" />
+ <NumberBox x:Name="MaxSizeBox" Grid.Row="1" Grid.Column="1"
+ Minimum="10" Maximum="1000" Value="100" />
+ </Grid>
+
+ <Button x:Name="SaveConfigBtn"
+ Content="Save Config"
+ Style="{StaticResource AccentButtonStyle}"
+ HorizontalAlignment="Left"
+ Margin="0,8,0,0"
+ Click="SaveConfig_Click" />
+ <TextBlock x:Name="SaveConfigStatusText"
+ FontSize="11"
+ Foreground="{ThemeResource TextFillColorTertiaryBrush}" />
+ </StackPanel>
+ </ScrollViewer>
+ </PivotItem>
+ </Pivot>
+ </Grid>
+</Page>
diff --git a/windows/Gridex/Models/AppSettings.h b/windows/Gridex/Models/AppSettings.h
index 402da1d..ee36af8 100644
--- a/windows/Gridex/Models/AppSettings.h
+++ b/windows/Gridex/Models/AppSettings.h
@@ -26,6 +26,36 @@ namespace DBModels
// Connection groups (user-defined labels)
std::vector<std::wstring> connectionGroups;
+ // ── MCP Server ───────────────────────────────────────
+ // All MCP prefs live in the same settings.json as the rest
+ // of the app (no separate file). Defaults mirror macOS so
+ // first-launch behavior is identical across platforms.
+
+ // Transport / server lifecycle
+ bool mcpEnabled = false;
+ bool mcpHttpEnabled = false;
+ int mcpHttpPort = 3333; // localhost by default
+ bool mcpAllowRemoteHTTP = false; // flips bind to 0.0.0.0
+ int64_t mcpStartTime = 0; // unix seconds; uptime tracking
+
+ // Security
+ bool mcpRequireApprovalForWrites = true;
+
+ // Rate limits (mac defaults)
+ int mcpQueriesPerMinute = 60;
+ int mcpQueriesPerHour = 1000;
+ int mcpWritesPerMinute = 10;
+ int mcpDdlPerMinute = 1;
+
+ // Timeouts (seconds)
+ int mcpQueryTimeout = 30;
+ int mcpApprovalTimeout = 60;
+ int mcpConnectionTimeout = 10;
+
+ // Audit log rotation (JSONL at %APPDATA%\Gridex\mcp-audit.jsonl)
+ int mcpAuditRetentionDays = 90;
+ int mcpAuditMaxSizeMB = 100;
+
// Load from file (returns default if file missing)
static AppSettings Load();
diff --git a/windows/Gridex/Models/ConnectionConfig.h b/windows/Gridex/Models/ConnectionConfig.h
index 605ad44..e90346b 100644
--- a/windows/Gridex/Models/ConnectionConfig.h
+++ b/windows/Gridex/Models/ConnectionConfig.h
@@ -4,6 +4,7 @@
#include <cstdint>
#include "DatabaseType.h"
#include "ColorTag.h"
+#include "MCP/MCPConnectionMode.h"
namespace DBModels
{
@@ -59,6 +60,11 @@ namespace DBModels
std::wstring mongoOptions;
std::optional<SSHTunnelConfig> sshConfig;
+ // Per-connection MCP access gate. Default Locked — every new
+ // connection must be explicitly opened up in MCPConnectionsView.
+ // Mirrors mac's ConnectionConfig.mcpMode.
+ MCPConnectionMode mcpMode = MCPConnectionMode::Locked;
+
std::wstring subtitle() const
{
if (databaseType == DatabaseType::SQLite)
diff --git a/windows/Gridex/Models/ConnectionStore.h b/windows/Gridex/Models/ConnectionStore.h
index 51f547b..72942d5 100644
--- a/windows/Gridex/Models/ConnectionStore.h
+++ b/windows/Gridex/Models/ConnectionStore.h
@@ -30,7 +30,7 @@ namespace DBModels
"sort_order, created_at, last_connected_at, connection_uri, "
"mongo_options, "
"ssh_host, ssh_port, ssh_username, ssh_password_enc, "
- "ssh_auth_method, ssh_key_path "
+ "ssh_auth_method, ssh_key_path, mcp_mode "
"FROM connections ORDER BY sort_order, name";
sqlite3_stmt* stmt = nullptr;
@@ -72,6 +72,9 @@ namespace DBModels
c.sshConfig = ssh;
}
}
+ // Column 24: per-connection MCP mode. Defaults to
+ // Locked (0) for rows created before the migration.
+ c.mcpMode = static_cast<MCPConnectionMode>(sqlite3_column_int(stmt, 24));
results.push_back(c);
}
sqlite3_finalize(stmt);
@@ -98,10 +101,10 @@ namespace DBModels
"sort_order, created_at, last_connected_at, connection_uri, "
"mongo_options, "
"ssh_host, ssh_port, ssh_username, ssh_password_enc, "
- "ssh_auth_method, ssh_key_path) "
+ "ssh_auth_method, ssh_key_path, mcp_mode) "
"VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,0, "
"COALESCE((SELECT created_at FROM connections WHERE id=?), datetime('now')), "
- "datetime('now'), ?, ?, ?,?,?,?,?,?)";
+ "datetime('now'), ?, ?, ?,?,?,?,?,?,?)";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) == SQLITE_OK)
@@ -143,6 +146,9 @@ namespace DBModels
sqlite3_bind_int(stmt, 21, 0);
BindText(stmt, 22, "");
}
+ // Placeholder 23: per-connection MCP mode. Defaults
+ // to Locked so new rows never auto-expose data to AI.
+ sqlite3_bind_int(stmt, 23, static_cast<int>(c.mcpMode));
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
@@ -215,6 +221,10 @@ namespace DBModels
sqlite3_exec(db, "ALTER TABLE connections ADD COLUMN ssh_password_enc TEXT DEFAULT ''", nullptr, nullptr, nullptr);
sqlite3_exec(db, "ALTER TABLE connections ADD COLUMN ssh_auth_method INTEGER DEFAULT 0", nullptr, nullptr, nullptr);
sqlite3_exec(db, "ALTER TABLE connections ADD COLUMN ssh_key_path TEXT DEFAULT ''", nullptr, nullptr, nullptr);
+ // Migration: per-connection MCP access mode (0=Locked, 1=ReadOnly, 2=ReadWrite).
+ // Default 0 keeps existing connections firewalled from AI until the
+ // user explicitly opens them up in the MCP Connections tab.
+ sqlite3_exec(db, "ALTER TABLE connections ADD COLUMN mcp_mode INTEGER DEFAULT 0", nullptr, nullptr, nullptr);
}
static std::wstring GetDbPath()
diff --git a/windows/Gridex/Models/MCP/MCPAuditEntry.h b/windows/Gridex/Models/MCP/MCPAuditEntry.h
new file mode 100644
index 0000000..93ed2a0
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPAuditEntry.h
@@ -0,0 +1,166 @@
+#pragma once
+//
+// MCPAuditEntry.h
+// Gridex
+//
+// Audit log entry for MCP tool invocations. One of these is
+// serialized per line in mcp-audit.jsonl. Mirrors
+// macos/Core/Models/MCP/MCPAuditEntry.swift.
+//
+// IMPORTANT: this JSONL is cross-platform — the mac and Windows
+// builds write to the same format so `jq` and future sync work
+// uniformly. DO NOT rename or retype fields.
+
+#include <string>
+#include <optional>
+#include <vector>
+#include <chrono>
+#include <cstdint>
+#include <nlohmann/json.hpp>
+#include "MCPPermissionTier.h"
+#include "MCPConnectionMode.h"
+
+namespace DBModels
+{
+ // Raw status values match Swift MCPAuditStatus.
+ enum class MCPAuditStatus { Success, Error, Denied, Timeout };
+
+ inline std::string mcpAuditStatusRaw(MCPAuditStatus s)
+ {
+ switch (s)
+ {
+ case MCPAuditStatus::Success: return "success";
+ case MCPAuditStatus::Error: return "error";
+ case MCPAuditStatus::Denied: return "denied";
+ case MCPAuditStatus::Timeout: return "timeout";
+ }
+ return "success";
+ }
+
+ inline MCPAuditStatus mcpAuditStatusFromRaw(const std::string& raw)
+ {
+ if (raw == "error") return MCPAuditStatus::Error;
+ if (raw == "denied") return MCPAuditStatus::Denied;
+ if (raw == "timeout") return MCPAuditStatus::Timeout;
+ return MCPAuditStatus::Success;
+ }
+
+ struct MCPAuditClient
+ {
+ std::string name = "unknown";
+ std::string version = "0.0.0";
+ std::string transport = "stdio"; // "stdio" | "http"
+ };
+
+ // `sqlPreview` is truncated to 200 chars at construction so
+ // secrets can never leak through oversized logs. `inputHash`
+ // is a non-cryptographic correlation aid (std::hash), NOT a
+ // security primitive — documented explicitly for auditors.
+ struct MCPAuditInput
+ {
+ std::optional<std::string> sqlPreview;
+ std::optional<int> paramsCount;
+ std::optional<std::string> inputHash;
+
+ static MCPAuditInput fromSQL(const std::string& sql, std::optional<int> paramsCount = std::nullopt)
+ {
+ MCPAuditInput i;
+ if (!sql.empty())
+ {
+ const std::string preview = sql.size() > 200 ? sql.substr(0, 200) + "..." : sql;
+ i.sqlPreview = preview;
+ const std::size_t h = std::hash<std::string>{}(sql);
+ i.inputHash = "h64:" + std::to_string(h);
+ }
+ i.paramsCount = paramsCount;
+ return i;
+ }
+ };
+
+ struct MCPAuditResult
+ {
+ MCPAuditStatus status = MCPAuditStatus::Success;
+ std::optional<int> rowsAffected;
+ std::optional<int> rowsReturned;
+ int durationMs = 0;
+ std::optional<int64_t> bytesReturned;
+ };
+
+ struct MCPAuditSecurity
+ {
+ MCPConnectionMode permissionMode = MCPConnectionMode::Locked;
+ std::optional<bool> userApproved;
+ std::optional<std::string> approvalSessionId;
+ std::optional<std::vector<std::string>> scopesApplied;
+ };
+
+ struct MCPAuditEntry
+ {
+ // ISO-8601 UTC — formatted lazily in to_json so we don't
+ // depend on C++20 chrono formatters.
+ std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now();
+ std::string eventId; // UUID-like string (UuidCreate → hex)
+ MCPAuditClient client;
+ std::string tool;
+ int tier = 1; // MCPPermissionTier::Schema
+ std::optional<std::string> connectionId;
+ std::optional<std::string> connectionType; // "postgres"/"mysql"/...
+ MCPAuditInput input;
+ MCPAuditResult result;
+ MCPAuditSecurity security;
+ std::optional<std::string> error;
+ };
+
+ // ── Serialization ─────────────────────────────────────────
+ // These write the same field names Swift uses so mac + Windows
+ // logs are indistinguishable on disk.
+
+ inline std::string mcpFormatIso8601(std::chrono::system_clock::time_point tp)
+ {
+ // strftime-based path — portable across MSVC versions where
+ // std::format chrono support varies. Emits "YYYY-MM-DDTHH:MM:SSZ".
+ const std::time_t t = std::chrono::system_clock::to_time_t(tp);
+ std::tm tm{};
+#if defined(_WIN32)
+ gmtime_s(&tm, &t);
+#else
+ gmtime_r(&t, &tm);
+#endif
+ char buf[32];
+ std::strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%SZ", &tm);
+ return std::string(buf);
+ }
+
+ inline void to_json(nlohmann::json& j, const MCPAuditEntry& e)
+ {
+ j = nlohmann::json{
+ {"timestamp", mcpFormatIso8601(e.timestamp)},
+ {"eventId", e.eventId},
+ {"tool", e.tool},
+ {"tier", e.tier},
+ {"client", {
+ {"name", e.client.name},
+ {"version", e.client.version},
+ {"transport", e.client.transport}
+ }},
+ {"result", {
+ {"status", mcpAuditStatusRaw(e.result.status)},
+ {"durationMs", e.result.durationMs}
+ }},
+ {"security", {
+ {"permissionMode", mcpRawString(e.security.permissionMode)}
+ }}
+ };
+ if (e.connectionId.has_value()) j["connectionId"] = *e.connectionId;
+ if (e.connectionType.has_value()) j["connectionType"] = *e.connectionType;
+ if (e.input.sqlPreview.has_value()) j["input"]["sqlPreview"] = *e.input.sqlPreview;
+ if (e.input.paramsCount.has_value()) j["input"]["paramsCount"] = *e.input.paramsCount;
+ if (e.input.inputHash.has_value()) j["input"]["inputHash"] = *e.input.inputHash;
+ if (e.result.rowsAffected.has_value()) j["result"]["rowsAffected"] = *e.result.rowsAffected;
+ if (e.result.rowsReturned.has_value()) j["result"]["rowsReturned"] = *e.result.rowsReturned;
+ if (e.result.bytesReturned.has_value()) j["result"]["bytesReturned"] = *e.result.bytesReturned;
+ if (e.security.userApproved.has_value()) j["security"]["userApproved"] = *e.security.userApproved;
+ if (e.security.approvalSessionId.has_value()) j["security"]["approvalSessionId"] = *e.security.approvalSessionId;
+ if (e.error.has_value()) j["error"] = *e.error;
+ }
+}
diff --git a/windows/Gridex/Models/MCP/MCPConnectionMode.h b/windows/Gridex/Models/MCP/MCPConnectionMode.h
new file mode 100644
index 0000000..3fadf1c
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPConnectionMode.h
@@ -0,0 +1,75 @@
+#pragma once
+//
+// MCPConnectionMode.h
+// Gridex
+//
+// MCP access mode for database connections. Mirrors
+// macos/Core/Enums/MCPConnectionMode.swift 1:1 so the on-disk raw
+// strings ("locked" / "read_only" / "read_write") are identical
+// between platforms — this keeps audit JSONL grep-friendly and
+// makes future cloud-sync trivial.
+
+#include <string>
+
+namespace DBModels
+{
+ enum class MCPConnectionMode
+ {
+ Locked = 0,
+ ReadOnly = 1,
+ ReadWrite = 2
+ };
+
+ inline std::wstring mcpDisplayName(MCPConnectionMode mode)
+ {
+ switch (mode)
+ {
+ case MCPConnectionMode::Locked: return L"Locked";
+ case MCPConnectionMode::ReadOnly: return L"Read-only";
+ case MCPConnectionMode::ReadWrite: return L"Read-write";
+ }
+ return L"Unknown";
+ }
+
+ inline std::wstring mcpDescription(MCPConnectionMode mode)
+ {
+ switch (mode)
+ {
+ case MCPConnectionMode::Locked:
+ return L"AI cannot access this connection";
+ case MCPConnectionMode::ReadOnly:
+ return L"AI can query but not modify (recommended for production)";
+ case MCPConnectionMode::ReadWrite:
+ return L"AI can modify with your approval (use for dev only)";
+ }
+ return L"";
+ }
+
+ // Cross-platform raw string used in audit JSONL + REST payloads.
+ // MUST match macOS Swift rawValue ("locked", "read_only", "read_write").
+ inline std::string mcpRawString(MCPConnectionMode mode)
+ {
+ switch (mode)
+ {
+ case MCPConnectionMode::Locked: return "locked";
+ case MCPConnectionMode::ReadOnly: return "read_only";
+ case MCPConnectionMode::ReadWrite: return "read_write";
+ }
+ return "locked";
+ }
+
+ inline MCPConnectionMode mcpModeFromRawString(const std::string& raw)
+ {
+ if (raw == "read_only") return MCPConnectionMode::ReadOnly;
+ if (raw == "read_write") return MCPConnectionMode::ReadWrite;
+ return MCPConnectionMode::Locked;
+ }
+
+ // Per-tier allowance. Matches Swift `allowsTierN` exactly — do
+ // not drift; the permission engine in Phase 2 relies on these.
+ inline bool mcpAllowsTier1(MCPConnectionMode m) { return m != MCPConnectionMode::Locked; }
+ inline bool mcpAllowsTier2(MCPConnectionMode m) { return m != MCPConnectionMode::Locked; }
+ inline bool mcpAllowsTier3(MCPConnectionMode m) { return m == MCPConnectionMode::ReadWrite; }
+ inline bool mcpAllowsTier4(MCPConnectionMode m) { return m == MCPConnectionMode::ReadWrite; }
+ inline bool mcpAllowsTier5(MCPConnectionMode m) { return m != MCPConnectionMode::Locked; }
+}
diff --git a/windows/Gridex/Models/MCP/MCPErrorCode.h b/windows/Gridex/Models/MCP/MCPErrorCode.h
new file mode 100644
index 0000000..5732012
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPErrorCode.h
@@ -0,0 +1,26 @@
+#pragma once
+//
+// MCPErrorCode.h
+// Gridex
+//
+// Gridex-specific JSON-RPC error codes. The integer values are part
+// of the MCP client contract and MUST match macOS
+// (macos/Core/Models/MCP/MCPProtocol.swift : MCPErrorCode) exactly.
+// Claude Desktop, Cursor, etc. surface these codes to the user, so
+// renumbering would silently break downstream clients.
+
+namespace DBModels
+{
+ enum class MCPErrorCode : int
+ {
+ PermissionDenied = -32001,
+ ApprovalTimeout = -32002,
+ ApprovalDenied = -32003,
+ ConnectionError = -32004,
+ SyntaxError = -32005,
+ NotFound = -32006,
+ RateLimitExceeded = -32007,
+ ScopeDenied = -32008,
+ QueryTimeout = -32009
+ };
+}
diff --git a/windows/Gridex/Models/MCP/MCPPermissionTier.h b/windows/Gridex/Models/MCP/MCPPermissionTier.h
new file mode 100644
index 0000000..63f4aa5
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPPermissionTier.h
@@ -0,0 +1,49 @@
+#pragma once
+//
+// MCPPermissionTier.h
+// Gridex
+//
+// Permission tiers for MCP tools. Mirrors
+// macos/Core/Enums/MCPPermissionTier.swift.
+//
+// Tier numbering is part of the client-facing audit contract — do
+// NOT renumber. New tiers append at the end.
+
+#include <string>
+
+namespace DBModels
+{
+ enum class MCPPermissionTier
+ {
+ Schema = 1, // Schema introspection (read-only, no approval)
+ Read = 2, // Query execution (read, no approval by default)
+ Write = 3, // Data modification (REQUIRES approval)
+ DDL = 4, // Schema change (CRITICAL approval)
+ Advanced = 5 // Reserved for future (EXPLAIN, etc.)
+ };
+
+ inline std::wstring mcpTierDisplayName(MCPPermissionTier t)
+ {
+ switch (t)
+ {
+ case MCPPermissionTier::Schema: return L"Schema";
+ case MCPPermissionTier::Read: return L"Read";
+ case MCPPermissionTier::Write: return L"Write";
+ case MCPPermissionTier::DDL: return L"DDL";
+ case MCPPermissionTier::Advanced: return L"Advanced";
+ }
+ return L"";
+ }
+
+ inline bool mcpTierRequiresApproval(MCPPermissionTier t)
+ {
+ return t == MCPPermissionTier::Write
+ || t == MCPPermissionTier::DDL
+ || t == MCPPermissionTier::Advanced;
+ }
+
+ inline bool mcpTierIsReadOnly(MCPPermissionTier t)
+ {
+ return t == MCPPermissionTier::Schema || t == MCPPermissionTier::Read;
+ }
+}
diff --git a/windows/Gridex/Models/MCP/MCPProtocol.h b/windows/Gridex/Models/MCP/MCPProtocol.h
new file mode 100644
index 0000000..41693a0
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPProtocol.h
@@ -0,0 +1,147 @@
+#pragma once
+//
+// MCPProtocol.h
+// Gridex
+//
+// JSON-RPC 2.0 types for MCP. Mirrors the Swift structs in
+// macos/Core/Models/MCP/MCPProtocol.swift. All shapes use
+// nlohmann::json for dynamic fields (params, id, result) — this
+// avoids the hand-rolled JSONValue sum type on Swift side and
+// keeps codec glue trivial.
+//
+// All types live in namespace DBModels and ship ADL-compatible
+// `to_json` / `from_json` so nlohmann's generic `json(req)` and
+// `j.get<JSONRPCRequest>()` round-trip losslessly.
+
+#include <string>
+#include <optional>
+#include <nlohmann/json.hpp>
+#include "MCPErrorCode.h"
+
+namespace DBModels
+{
+ // ── JSON-RPC core ──────────────────────────────────────────
+
+ struct JSONRPCError
+ {
+ int code = 0;
+ std::string message;
+ nlohmann::json data; // optional arbitrary payload
+
+ // Canonical JSON-RPC 2.0 errors (see spec).
+ static JSONRPCError parseError() { return { -32700, "Parse error", nullptr }; }
+ static JSONRPCError invalidRequest() { return { -32600, "Invalid Request", nullptr }; }
+ static JSONRPCError methodNotFound() { return { -32601, "Method not found", nullptr }; }
+ static JSONRPCError invalidParams() { return { -32602, "Invalid params", nullptr }; }
+ static JSONRPCError internalError() { return { -32603, "Internal error", nullptr }; }
+
+ static JSONRPCError fromCode(MCPErrorCode c, const std::string& msg)
+ {
+ return { static_cast<int>(c), msg, nullptr };
+ }
+ };
+
+ inline void to_json(nlohmann::json& j, const JSONRPCError& e)
+ {
+ j = nlohmann::json{{"code", e.code}, {"message", e.message}};
+ if (!e.data.is_null()) j["data"] = e.data;
+ }
+
+ inline void from_json(const nlohmann::json& j, JSONRPCError& e)
+ {
+ e.code = j.value("code", 0);
+ e.message = j.value("message", std::string{});
+ e.data = j.value("data", nlohmann::json{});
+ }
+
+ struct JSONRPCRequest
+ {
+ std::string jsonrpc = "2.0";
+ nlohmann::json id; // int | string | null (notification)
+ std::string method;
+ nlohmann::json params; // object | array | null
+ };
+
+ inline void to_json(nlohmann::json& j, const JSONRPCRequest& r)
+ {
+ j = nlohmann::json{{"jsonrpc", r.jsonrpc}, {"method", r.method}};
+ if (!r.id.is_null()) j["id"] = r.id;
+ if (!r.params.is_null()) j["params"] = r.params;
+ }
+
+ inline void from_json(const nlohmann::json& j, JSONRPCRequest& r)
+ {
+ r.jsonrpc = j.value("jsonrpc", std::string{"2.0"});
+ r.id = j.value("id", nlohmann::json{});
+ r.method = j.value("method", std::string{});
+ r.params = j.value("params", nlohmann::json{});
+ }
+
+ struct JSONRPCResponse
+ {
+ std::string jsonrpc = "2.0";
+ nlohmann::json id; // echoed from request
+ std::optional<nlohmann::json> result; // success
+ std::optional<JSONRPCError> error; // failure (mutually exclusive)
+
+ static JSONRPCResponse ok(const nlohmann::json& id, const nlohmann::json& result)
+ {
+ JSONRPCResponse r;
+ r.id = id;
+ r.result = result;
+ return r;
+ }
+
+ static JSONRPCResponse fail(const nlohmann::json& id, const JSONRPCError& err)
+ {
+ JSONRPCResponse r;
+ r.id = id;
+ r.error = err;
+ return r;
+ }
+ };
+
+ inline void to_json(nlohmann::json& j, const JSONRPCResponse& r)
+ {
+ j = nlohmann::json{{"jsonrpc", r.jsonrpc}, {"id", r.id}};
+ if (r.result.has_value()) j["result"] = *r.result;
+ if (r.error.has_value())
+ {
+ nlohmann::json ej;
+ to_json(ej, *r.error);
+ j["error"] = ej;
+ }
+ }
+
+ inline void from_json(const nlohmann::json& j, JSONRPCResponse& r)
+ {
+ r.jsonrpc = j.value("jsonrpc", std::string{"2.0"});
+ r.id = j.value("id", nlohmann::json{});
+ if (j.contains("result")) r.result = j.at("result");
+ if (j.contains("error"))
+ {
+ JSONRPCError e;
+ from_json(j.at("error"), e);
+ r.error = e;
+ }
+ }
+
+ // ── Client info ────────────────────────────────────────────
+
+ struct MCPClientInfo
+ {
+ std::string name = "unknown";
+ std::string version = "0.0.0";
+ };
+
+ inline void to_json(nlohmann::json& j, const MCPClientInfo& c)
+ {
+ j = nlohmann::json{{"name", c.name}, {"version", c.version}};
+ }
+
+ inline void from_json(const nlohmann::json& j, MCPClientInfo& c)
+ {
+ c.name = j.value("name", std::string{"unknown"});
+ c.version = j.value("version", std::string{"0.0.0"});
+ }
+}
diff --git a/windows/Gridex/Models/MCP/MCPServerInfo.h b/windows/Gridex/Models/MCP/MCPServerInfo.h
new file mode 100644
index 0000000..98e4d1f
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPServerInfo.h
@@ -0,0 +1,44 @@
+#pragma once
+//
+// MCPServerInfo.h
+// Gridex
+//
+// Server advertisement returned in `initialize` handshake. Mirrors
+// MCPServerInfo.gridex() in macos/Core/Models/MCP/MCPProtocol.swift.
+// The `protocolVersion` string is dictated by the MCP spec (see
+// https://spec.modelcontextprotocol.io) — do NOT bump without
+// first validating that Claude Desktop / Cursor / etc still accept
+// the new value.
+
+#include <string>
+#include <nlohmann/json.hpp>
+
+namespace DBModels
+{
+ struct MCPServerInfo
+ {
+ std::string name = "gridex";
+ std::string version;
+ std::string protocolVersion = "2024-11-05";
+
+ static MCPServerInfo gridex(const std::string& appVersion)
+ {
+ MCPServerInfo s;
+ s.version = appVersion;
+ return s;
+ }
+ };
+
+ // Capabilities advertised in `initialize` result. Matches
+ // macOS handleInitialize() — exposes tools + resources +
+ // prompts + logging capability flags.
+ inline nlohmann::json mcpDefaultCapabilities()
+ {
+ return {
+ {"tools", {{"listChanged", true}}},
+ {"resources", {{"subscribe", true}, {"listChanged", true}}},
+ {"prompts", {{"listChanged", true}}},
+ {"logging", nlohmann::json::object()}
+ };
+ }
+}
diff --git a/windows/Gridex/Models/MCP/MCPToolDefinition.h b/windows/Gridex/Models/MCP/MCPToolDefinition.h
new file mode 100644
index 0000000..7dbc9f9
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPToolDefinition.h
@@ -0,0 +1,90 @@
+#pragma once
+//
+// MCPToolDefinition.h
+// Gridex
+//
+// Tool metadata + execution result for the MCP tools/list and
+// tools/call protocol methods. Mirrors MCPToolDefinition / MCPContent
+// / MCPToolResult in macos/Core/Models/MCP/MCPProtocol.swift.
+
+#include <string>
+#include <vector>
+#include <optional>
+#include <nlohmann/json.hpp>
+
+namespace DBModels
+{
+ // Emitted by tools/list. `inputSchema` is a JSON Schema object
+ // the AI client uses to validate arguments before calling.
+ struct MCPToolDefinition
+ {
+ std::string name;
+ std::string description;
+ nlohmann::json inputSchema; // JSON Schema object
+ };
+
+ inline void to_json(nlohmann::json& j, const MCPToolDefinition& t)
+ {
+ j = nlohmann::json{
+ {"name", t.name},
+ {"description", t.description},
+ {"inputSchema", t.inputSchema}
+ };
+ }
+
+ // Single content chunk in a tool result. Matches the MCP spec
+ // encoding for type="text" | "image" | "resource" items.
+ struct MCPContent
+ {
+ std::string type = "text"; // "text" | "image" | ...
+ std::optional<std::string> text;
+ std::optional<std::string> data; // base64 for image
+ std::optional<std::string> mimeType; // for image / resource
+ };
+
+ inline void to_json(nlohmann::json& j, const MCPContent& c)
+ {
+ j = nlohmann::json{{"type", c.type}};
+ if (c.text.has_value()) j["text"] = *c.text;
+ if (c.data.has_value()) j["data"] = *c.data;
+ if (c.mimeType.has_value()) j["mimeType"] = *c.mimeType;
+ }
+
+ // Full tool result — one or more content chunks + error flag.
+ // `isError` makes the client surface the text as an AI-visible
+ // error rather than a normal tool success output.
+ struct MCPToolResult
+ {
+ std::vector<MCPContent> content;
+ bool isError = false;
+
+ static MCPToolResult text(const std::string& s, bool err = false)
+ {
+ MCPToolResult r;
+ MCPContent c;
+ c.type = "text";
+ c.text = s;
+ r.content.push_back(std::move(c));
+ r.isError = err;
+ return r;
+ }
+
+ static MCPToolResult error(const std::string& message)
+ {
+ return text(message, true);
+ }
+ };
+
+ inline void to_json(nlohmann::json& j, const MCPToolResult& r)
+ {
+ nlohmann::json arr = nlohmann::json::array();
+ for (const auto& c : r.content)
+ {
+ nlohmann::json cj;
+ to_json(cj, c);
+ arr.push_back(cj);
+ }
+ j = nlohmann::json{{"content", arr}};
+ if (r.isError) j["isError"] = true;
+ }
+}
diff --git a/windows/Gridex/Models/MCP/MCPToolError.h b/windows/Gridex/Models/MCP/MCPToolError.h
new file mode 100644
index 0000000..d109fc2
--- /dev/null
+++ b/windows/Gridex/Models/MCP/MCPToolError.h
@@ -0,0 +1,84 @@
+#pragma once
+//
+// MCPToolError.h
+// Gridex
+//
+// Typed exception thrown by MCP tools. The MCPServer catches these
+// and folds them into MCPToolResult::error(...) so the AI client
+// sees a structured failure message. Mirrors MCPToolError in
+// macos/Services/MCP/Tools/MCPTool.swift.
+//
+// Tools should throw via the static factories rather than
+// constructing directly — this keeps the message format consistent
+// with macOS.
+
+#include <stdexcept>
+#include <string>
+
+namespace DBModels
+{
+ class MCPToolError : public std::runtime_error
+ {
+ public:
+ enum class Kind
+ {
+ ConnectionNotFound,
+ ConnectionNotConnected,
+ TableNotFound,
+ InvalidParameters,
+ PermissionDenied,
+ QueryFailed,
+ RateLimitExceeded
+ };
+
+ Kind kind;
+ int retryAfterSeconds = 0; // only meaningful for RateLimitExceeded
+
+ MCPToolError(Kind k, const std::string& msg, int retryAfter = 0)
+ : std::runtime_error(msg), kind(k), retryAfterSeconds(retryAfter) {}
+
+ // ── Factories — keep messages identical to Swift for UX parity ──
+
+ static MCPToolError connectionNotFound(const std::string& id)
+ {
+ return MCPToolError(Kind::ConnectionNotFound,
+ "Connection '" + id + "' not found. Use list_connections to see available connections.");
+ }
+
+ static MCPToolError connectionNotConnected(const std::string& id)
+ {
+ return MCPToolError(Kind::ConnectionNotConnected,
+ "Connection '" + id + "' is not active. The user needs to connect first.");
+ }
+
+ static MCPToolError tableNotFound(const std::string& name)
+ {
+ return MCPToolError(Kind::TableNotFound,
+ "Table '" + name + "' not found.");
+ }
+
+ static MCPToolError invalidParameters(const std::string& msg)
+ {
+ return MCPToolError(Kind::InvalidParameters,
+ "Invalid parameters: " + msg);
+ }
+
+ static MCPToolError permissionDenied(const std::string& msg)
+ {
+ return MCPToolError(Kind::PermissionDenied, msg);
+ }
+
+ static MCPToolError queryFailed(const std::string& msg)
+ {
+ return MCPToolError(Kind::QueryFailed,
+ "Query failed: " + msg);
+ }
+
+ static MCPToolError rateLimitExceeded(int retryAfter)
+ {
+ return MCPToolError(Kind::RateLimitExceeded,
+ "Rate limit exceeded. Retry after " + std::to_string(retryAfter) + " seconds.",
+ retryAfter);
+ }
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.cpp b/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.cpp
new file mode 100644
index 0000000..c7bb79a
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.cpp
@@ -0,0 +1,203 @@
+//
+// MCPAuditLogger.cpp
+//
+// File I/O uses plain std::ofstream/ifstream. Path is under
+// %APPDATA%\Gridex\ — the same folder ConnectionStore uses — so
+// backups sit next to the connections DB.
+
+#include "MCPAuditLogger.h"
+
+#include <windows.h>
+#include <shlobj.h>
+#include <fstream>
+#include <sstream>
+#include <filesystem>
+#include <chrono>
+#include <ctime>
+
+namespace fs = std::filesystem;
+
+namespace DBModels
+{
+ MCPAuditLogger::MCPAuditLogger(int maxSizeMB, int retentionDays)
+ : maxSizeBytes_(maxSizeMB > 0 ? maxSizeMB * 1024 * 1024 : 100 * 1024 * 1024),
+ retentionDays_(retentionDays)
+ {
+ const std::wstring dir = resolveAppDataPath();
+ CreateDirectoryW(dir.c_str(), nullptr);
+ path_ = dir + L"\\mcp-audit.jsonl";
+ purgeOldBackups();
+ }
+
+ std::wstring MCPAuditLogger::resolveAppDataPath()
+ {
+ wchar_t* appData = nullptr;
+ if (SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appData) != S_OK)
+ return L".";
+ std::wstring p = std::wstring(appData) + L"\\Gridex";
+ CoTaskMemFree(appData);
+ return p;
+ }
+
+ std::wstring MCPAuditLogger::logFilePath() const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ return path_;
+ }
+
+ std::string MCPAuditLogger::isoTimestampForFilename()
+ {
+ const std::time_t t = std::chrono::system_clock::to_time_t(
+ std::chrono::system_clock::now());
+ std::tm tm{};
+ gmtime_s(&tm, &t);
+ char buf[32];
+ // Colons are invalid in Win32 filenames — use dashes instead.
+ std::strftime(buf, sizeof(buf), "%Y-%m-%dT%H-%M-%SZ", &tm);
+ return std::string(buf);
+ }
+
+ void MCPAuditLogger::log(const MCPAuditEntry& entry)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ try
+ {
+ rotateIfNeeded();
+
+ nlohmann::json j;
+ to_json(j, entry);
+ std::string line = j.dump() + "\n";
+
+ std::ofstream out(path_, std::ios::app | std::ios::binary);
+ if (!out.is_open()) return;
+ out.write(line.data(), static_cast<std::streamsize>(line.size()));
+ }
+ catch (...) { /* never crash on audit */ }
+ }
+
+ void MCPAuditLogger::rotateIfNeeded()
+ {
+ std::error_code ec;
+ if (!fs::exists(path_, ec)) return;
+ const auto size = fs::file_size(path_, ec);
+ if (ec || static_cast<int64_t>(size) < static_cast<int64_t>(maxSizeBytes_)) return;
+
+ const std::string ts = isoTimestampForFilename();
+ fs::path backup = fs::path(path_).parent_path() /
+ (std::string("mcp-audit-") + ts + ".jsonl");
+ fs::rename(path_, backup, ec);
+ }
+
+ void MCPAuditLogger::purgeOldBackups()
+ {
+ if (retentionDays_ <= 0) return;
+ std::error_code ec;
+ const fs::path dir = fs::path(path_).parent_path();
+ if (!fs::exists(dir, ec)) return;
+
+ const auto cutoff = std::chrono::system_clock::now()
+ - std::chrono::hours(24 * retentionDays_);
+
+ for (auto it = fs::directory_iterator(dir, ec);
+ !ec && it != fs::directory_iterator();
+ ++it)
+ {
+ const auto& p = it->path();
+ const auto name = p.filename().string();
+ // Only touch our own rotated backups.
+ if (name.rfind("mcp-audit-", 0) != 0) continue;
+ if (p.extension() != ".jsonl") continue;
+
+ const auto ft = fs::last_write_time(p, ec);
+ if (ec) continue;
+ // Convert file_time_type → system_clock::time_point
+ // (portable approximation — good enough for day-level retention).
+ const auto sys = std::chrono::system_clock::now()
+ - (fs::file_time_type::clock::now() - ft);
+ if (sys < cutoff) fs::remove(p, ec);
+ }
+ }
+
+ void MCPAuditLogger::close()
+ {
+ // std::ofstream is opened per-log() call, nothing persistent.
+ }
+
+ void MCPAuditLogger::clearAll()
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ std::error_code ec;
+ fs::remove(path_, ec);
+ }
+
+ std::vector<MCPAuditEntry> MCPAuditLogger::recentEntries(int limit)
+ {
+ std::vector<MCPAuditEntry> out;
+ std::lock_guard<std::mutex> lk(mtx_);
+ std::ifstream in(path_, std::ios::binary);
+ if (!in.is_open()) return out;
+
+ // Read all lines (for human-scale logs this is fine — a full
+ // 100MB log would still fit in RAM, and the UI caps at 500).
+ std::vector<std::string> lines;
+ std::string line;
+ while (std::getline(in, line))
+ {
+ if (!line.empty() && line.back() == '\r') line.pop_back();
+ if (!line.empty()) lines.push_back(std::move(line));
+ }
+
+ const size_t start = lines.size() > static_cast<size_t>(limit)
+ ? lines.size() - static_cast<size_t>(limit) : 0;
+ for (size_t i = lines.size(); i > start; --i)
+ {
+ try
+ {
+ auto j = nlohmann::json::parse(lines[i - 1]);
+ MCPAuditEntry e;
+ e.tool = j.value("tool", std::string{});
+ e.tier = j.value("tier", 1);
+ e.eventId = j.value("eventId", std::string{});
+ if (j.contains("connectionId") && j["connectionId"].is_string())
+ e.connectionId = j["connectionId"].get<std::string>();
+ if (j.contains("connectionType") && j["connectionType"].is_string())
+ e.connectionType = j["connectionType"].get<std::string>();
+ if (j.contains("error") && j["error"].is_string())
+ e.error = j["error"].get<std::string>();
+
+ if (j.contains("client"))
+ {
+ const auto& c = j["client"];
+ e.client.name = c.value("name", std::string{"unknown"});
+ e.client.version = c.value("version", std::string{"0.0.0"});
+ e.client.transport = c.value("transport", std::string{"stdio"});
+ }
+ if (j.contains("result"))
+ {
+ const auto& r = j["result"];
+ e.result.status = mcpAuditStatusFromRaw(r.value("status", std::string{"success"}));
+ e.result.durationMs = r.value("durationMs", 0);
+ if (r.contains("rowsAffected")) e.result.rowsAffected = r["rowsAffected"].get<int>();
+ if (r.contains("rowsReturned")) e.result.rowsReturned = r["rowsReturned"].get<int>();
+ }
+ if (j.contains("security"))
+ {
+ const auto& s = j["security"];
+ e.security.permissionMode = mcpModeFromRawString(
+ s.value("permissionMode", std::string{"locked"}));
+ if (s.contains("userApproved")) e.security.userApproved = s["userApproved"].get<bool>();
+ }
+ if (j.contains("input"))
+ {
+ const auto& in_ = j["input"];
+ if (in_.contains("sqlPreview")) e.input.sqlPreview = in_["sqlPreview"].get<std::string>();
+ if (in_.contains("paramsCount")) e.input.paramsCount = in_["paramsCount"].get<int>();
+ if (in_.contains("inputHash")) e.input.inputHash = in_["inputHash"].get<std::string>();
+ }
+ out.push_back(std::move(e));
+ }
+ catch (...) { /* skip malformed line */ }
+ }
+ return out;
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.h b/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.h
new file mode 100644
index 0000000..ae86e5b
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Audit/MCPAuditLogger.h
@@ -0,0 +1,56 @@
+#pragma once
+//
+// MCPAuditLogger.h
+// Gridex
+//
+// Append-only JSONL audit log at %APPDATA%\Gridex\mcp-audit.jsonl.
+// Mirrors macos/Services/MCP/Audit/MCPAuditLogger.swift format 1:1
+// so `jq` over the file works cross-platform.
+//
+// Rotation: when the file reaches `maxSizeMB` the current file is
+// renamed to `mcp-audit-<ISO-timestamp>.jsonl` and a fresh file
+// is started. Retention is enforced at startup (deleting backups
+// older than `retentionDays`; 0 means forever).
+
+#include <string>
+#include <vector>
+#include <mutex>
+#include "../../../Models/MCP/MCPAuditEntry.h"
+
+namespace DBModels
+{
+ class MCPAuditLogger
+ {
+ public:
+ // Sizes in MB, retention in days. 0 retention = keep forever.
+ MCPAuditLogger(int maxSizeMB = 100, int retentionDays = 90);
+
+ // Thread-safe append. Swallows exceptions — audit must
+ // never crash the app.
+ void log(const MCPAuditEntry& entry);
+
+ // Close the underlying handle (called on server shutdown).
+ void close();
+
+ // Tail the last `limit` entries (most recent first). Returns
+ // empty vector on error.
+ std::vector<MCPAuditEntry> recentEntries(int limit = 100);
+
+ // Delete the current log (testing / UI "Clear Log" button).
+ void clearAll();
+
+ // Absolute path of the current log file.
+ std::wstring logFilePath() const;
+
+ private:
+ mutable std::mutex mtx_;
+ std::wstring path_;
+ int maxSizeBytes_;
+ int retentionDays_;
+
+ void rotateIfNeeded();
+ void purgeOldBackups();
+ static std::wstring resolveAppDataPath();
+ static std::string isoTimestampForFilename();
+ };
+}
diff --git a/windows/Gridex/Services/MCP/MCPConnectionPool.cpp b/windows/Gridex/Services/MCP/MCPConnectionPool.cpp
new file mode 100644
index 0000000..28679f4
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPConnectionPool.cpp
@@ -0,0 +1,78 @@
+//
+// MCPConnectionPool.cpp
+//
+// This duplicates ConnectionManager::createAdapter intentionally —
+// keeping the pool decoupled avoids a circular include (Services →
+// ConnectionManager → Services again once MCP hooks are added).
+
+#include "MCPConnectionPool.h"
+#include "../../Models/PostgreSQLAdapter.h"
+#include "../../Models/MySQLAdapter.h"
+#include "../../Models/SQLiteAdapter.h"
+#include "../../Models/RedisAdapter.h"
+#include "../../Models/MongoDBAdapter.h"
+#include "../../Models/MSSQLAdapter.h"
+
+namespace DBModels
+{
+ std::shared_ptr<DatabaseAdapter> MCPConnectionPool::createAdapter(DatabaseType t)
+ {
+ switch (t)
+ {
+ case DatabaseType::PostgreSQL: return std::make_shared<PostgreSQLAdapter>();
+ case DatabaseType::MySQL: return std::make_shared<MySQLAdapter>();
+ case DatabaseType::SQLite: return std::make_shared<SQLiteAdapter>();
+ case DatabaseType::Redis: return std::make_shared<RedisAdapter>();
+ case DatabaseType::MongoDB: return std::make_shared<MongoDBAdapter>();
+ case DatabaseType::MSSQLServer:return std::make_shared<MSSQLAdapter>();
+ }
+ throw DatabaseError(DatabaseError::Code::ConnectionFailed,
+ "Unsupported database type");
+ }
+
+ std::shared_ptr<DatabaseAdapter> MCPConnectionPool::acquire(
+ const ConnectionConfig& config, const std::wstring& password)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ auto it = adapters_.find(config.id);
+ if (it != adapters_.end() && it->second && it->second->isConnected())
+ return it->second;
+
+ // Either missing or stale — create fresh and connect.
+ auto adapter = createAdapter(config.databaseType);
+ adapter->connect(config, password);
+ adapters_[config.id] = adapter;
+ return adapter;
+ }
+
+ void MCPConnectionPool::release(const std::wstring& id)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ auto it = adapters_.find(id);
+ if (it != adapters_.end())
+ {
+ try { if (it->second) it->second->disconnect(); } catch (...) {}
+ adapters_.erase(it);
+ }
+ }
+
+ void MCPConnectionPool::releaseAll()
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ for (auto& [_, a] : adapters_)
+ try { if (a) a->disconnect(); } catch (...) {}
+ adapters_.clear();
+ }
+
+ bool MCPConnectionPool::isCached(const std::wstring& id) const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ return adapters_.count(id) != 0;
+ }
+
+ size_t MCPConnectionPool::cachedCount() const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ return adapters_.size();
+ }
+}
diff --git a/windows/Gridex/Services/MCP/MCPConnectionPool.h b/windows/Gridex/Services/MCP/MCPConnectionPool.h
new file mode 100644
index 0000000..2c6cbaf
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPConnectionPool.h
@@ -0,0 +1,54 @@
+#pragma once
+//
+// MCPConnectionPool.h
+// Gridex
+//
+// Per-MCP adapter cache, separate from ConnectionManager (which
+// only holds the GUI's single active connection). Tools borrow
+// warm adapters from this pool keyed by connectionId — avoids
+// 200-800ms reconnect latency per invocation and preserves
+// Redis/Mongo session state.
+//
+// Thread-safe: invoked from stdio reader thread + HTTP worker
+// threads concurrently.
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include "../../Models/DatabaseAdapter.h"
+#include "../../Models/ConnectionConfig.h"
+
+namespace DBModels
+{
+ class MCPConnectionPool
+ {
+ public:
+ // Returns an adapter for `config`, opening a new connection
+ // if one isn't cached. Throws DatabaseError on connect failure.
+ // `password` is already resolved by the caller via CredentialManager.
+ std::shared_ptr<DatabaseAdapter> acquire(
+ const ConnectionConfig& config,
+ const std::wstring& password);
+
+ // Close + drop one cached adapter (e.g. when connection is
+ // deleted from ConnectionStore).
+ void release(const std::wstring& connectionId);
+
+ // Close + drop everything (server shutdown).
+ void releaseAll();
+
+ // Introspection for status UI.
+ bool isCached(const std::wstring& connectionId) const;
+ size_t cachedCount() const;
+
+ private:
+ mutable std::mutex mtx_;
+ std::unordered_map<std::wstring, std::shared_ptr<DatabaseAdapter>> adapters_;
+
+ // Helper: creates the adapter matching `config.databaseType`.
+ // Same switch used by ConnectionManager::createAdapter — we
+ // duplicate here to avoid a circular dep on ConnectionManager.cpp.
+ static std::shared_ptr<DatabaseAdapter> createAdapter(DatabaseType type);
+ };
+}
diff --git a/windows/Gridex/Services/MCP/MCPServer.cpp b/windows/Gridex/Services/MCP/MCPServer.cpp
new file mode 100644
index 0000000..e76a460
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPServer.cpp
@@ -0,0 +1,310 @@
+//
+// MCPServer.cpp
+//
+
+#include "MCPServer.h"
+#include "../../Models/ConnectionStore.h"
+#include "Tools/MCPBuiltinTools.h"
+
+#include <chrono>
+#include <regex>
+
+// For UUID generation (eventId).
+#include <windows.h>
+#include <rpc.h>
+#pragma comment(lib, "Rpcrt4.lib")
+
+namespace DBModels
+{
+ namespace
+ {
+ std::string generateEventId()
+ {
+ UUID u; UuidCreate(&u);
+ char* s = nullptr;
+ UuidToStringA(&u, reinterpret_cast<RPC_CSTR*>(&s));
+ std::string out = s ? s : "";
+ if (s) RpcStringFreeA(reinterpret_cast<RPC_CSTR*>(&s));
+ return out;
+ }
+
+ std::wstring utf8ToWide(const std::string& s)
+ {
+ if (s.empty()) return {};
+ int sz = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0);
+ std::wstring out(sz, L'\0');
+ MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &out[0], sz);
+ return out;
+ }
+
+ std::string wideToUtf8(const std::wstring& s)
+ {
+ if (s.empty()) return {};
+ int sz = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), (int)s.size(),
+ nullptr, 0, nullptr, nullptr);
+ std::string out(sz, '\0');
+ WideCharToMultiByte(CP_UTF8, 0, s.c_str(), (int)s.size(), &out[0], sz, nullptr, nullptr);
+ return out;
+ }
+ }
+
+ MCPServer::MCPServer(AppSettings settings, std::string serverVersion, MCPTransportMode mode)
+ : settings_(std::move(settings)),
+ serverVersion_(std::move(serverVersion)),
+ mode_(mode),
+ rateLimiter_(MCPRateLimiterConfig{
+ settings_.mcpQueriesPerMinute,
+ settings_.mcpQueriesPerHour,
+ settings_.mcpWritesPerMinute,
+ settings_.mcpDdlPerMinute
+ }),
+ auditLogger_(settings_.mcpAuditMaxSizeMB, settings_.mcpAuditRetentionDays)
+ {
+ }
+
+ void MCPServer::start()
+ {
+ if (running_.exchange(true)) return;
+
+ // Load per-connection MCP modes into the permission engine.
+ for (const auto& c : ConnectionStore::Load())
+ permissionEngine_.setMode(c.id, c.mcpMode);
+
+ registerBuiltinTools();
+
+ if (mode_ == MCPTransportMode::Stdio)
+ {
+ stdio_.setRequestHandler([this](const JSONRPCRequest& r){ handleRequest(r); });
+ stdio_.start();
+ }
+ // HTTP transport start — Phase 4d (TODO).
+ }
+
+ void MCPServer::stop()
+ {
+ if (!running_.exchange(false)) return;
+ stdio_.stop();
+ auditLogger_.close();
+ pool_.releaseAll();
+ }
+
+ void MCPServer::setUIContext(void* dq, void* xr)
+ {
+ approvalGate_.setUIContext(dq, xr);
+ }
+
+ // Phase 5 hooks register real tools here. Leaving empty avoids
+ // a forward-include chain on every Tier1/2/3 header until Phase 5
+ // lands — tools will add themselves via
+ // toolRegistry().registerTool(...) from a helper TU.
+ void MCPServer::registerBuiltinTools()
+ {
+ MCPBuiltinTools::registerAll(toolRegistry_);
+ }
+
+ // ── Request dispatch ─────────────────────────────────────
+
+ void MCPServer::handleRequest(const JSONRPCRequest& req)
+ {
+ JSONRPCResponse resp = JSONRPCResponse::fail(req.id, JSONRPCError::methodNotFound());
+ const std::string& m = req.method;
+
+ if (m == "initialize") resp = handleInitialize(req);
+ else if (m == "initialized") return; // notification — no response
+ else if (m == "tools/list") resp = handleToolsList(req);
+ else if (m == "tools/call") resp = handleToolsCall(req);
+ else if (m == "ping")
+ resp = JSONRPCResponse::ok(req.id, nlohmann::json{{"pong", true}});
+ else if (m == "shutdown")
+ {
+ resp = JSONRPCResponse::ok(req.id, nullptr);
+ sendResponse(resp);
+ stop();
+ return;
+ }
+
+ sendResponse(resp);
+ }
+
+ JSONRPCResponse MCPServer::handleInitialize(const JSONRPCRequest& req)
+ {
+ if (req.params.is_object() && req.params.contains("clientInfo"))
+ {
+ const auto& ci = req.params["clientInfo"];
+ clientInfo_.name = ci.value("name", std::string{"unknown"});
+ clientInfo_.version = ci.value("version", std::string{"0.0.0"});
+ }
+
+ const auto info = MCPServerInfo::gridex(serverVersion_);
+ const nlohmann::json result{
+ {"serverInfo",
+ {{"name", info.name}, {"version", info.version}}},
+ {"protocolVersion", info.protocolVersion},
+ {"capabilities", mcpDefaultCapabilities()}
+ };
+ return JSONRPCResponse::ok(req.id, result);
+ }
+
+ JSONRPCResponse MCPServer::handleToolsList(const JSONRPCRequest& req)
+ {
+ auto defs = toolRegistry_.definitions();
+ nlohmann::json arr = nlohmann::json::array();
+ for (const auto& d : defs)
+ {
+ nlohmann::json dj;
+ to_json(dj, d);
+ arr.push_back(dj);
+ }
+ return JSONRPCResponse::ok(req.id, nlohmann::json{{"tools", arr}});
+ }
+
+ JSONRPCResponse MCPServer::handleToolsCall(const JSONRPCRequest& req)
+ {
+ if (!req.params.is_object() ||
+ !req.params.contains("name") || !req.params["name"].is_string())
+ return JSONRPCResponse::fail(req.id, JSONRPCError::invalidParams());
+
+ const std::string name = req.params["name"].get<std::string>();
+ const nlohmann::json args = req.params.value("arguments", nlohmann::json::object());
+
+ auto tool = toolRegistry_.get(name);
+ if (!tool)
+ {
+ JSONRPCError e;
+ e.code = static_cast<int>(MCPErrorCode::NotFound);
+ e.message = "Tool '" + name + "' not found";
+ return JSONRPCResponse::fail(req.id, e);
+ }
+
+ const auto startTime = std::chrono::steady_clock::now();
+
+ MCPAuditClient auditClient{
+ clientInfo_.name,
+ clientInfo_.version,
+ mode_ == MCPTransportMode::Stdio ? "stdio" : "http"
+ };
+ MCPToolContext ctx{ pool_, permissionEngine_, rateLimiter_,
+ approvalGate_, auditLogger_, auditClient };
+
+ // Best-effort extraction for audit entry fields.
+ std::optional<std::string> connIdStr;
+ std::optional<std::string> connTypeStr;
+ if (args.contains("connection_id") && args["connection_id"].is_string())
+ {
+ connIdStr = args["connection_id"].get<std::string>();
+ // Try to resolve type (non-fatal).
+ try
+ {
+ auto wid = utf8ToWide(*connIdStr);
+ auto configs = ConnectionStore::Load();
+ for (const auto& c : configs)
+ if (c.id == wid)
+ { connTypeStr = wideToUtf8(DatabaseTypeDisplayName(c.databaseType)); break; }
+ }
+ catch (...) {}
+ }
+
+ MCPAuditEntry audit;
+ audit.eventId = generateEventId();
+ audit.client = auditClient;
+ audit.tool = name;
+ audit.tier = static_cast<int>(tool->tier());
+ audit.connectionId = connIdStr;
+ audit.connectionType = connTypeStr;
+
+ if (args.contains("sql") && args["sql"].is_string())
+ {
+ std::optional<int> pc;
+ if (args.contains("params") && args["params"].is_array())
+ pc = static_cast<int>(args["params"].size());
+ audit.input = MCPAuditInput::fromSQL(args["sql"].get<std::string>(), pc);
+ }
+
+ try
+ {
+ auto result = tool->execute(args, ctx);
+ const auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::steady_clock::now() - startTime).count();
+ audit.result.durationMs = static_cast<int>(dur);
+ audit.result.status = result.isError
+ ? MCPAuditStatus::Error : MCPAuditStatus::Success;
+
+ // Record mode + usage.
+ if (connIdStr)
+ {
+ const auto wid = utf8ToWide(*connIdStr);
+ audit.security.permissionMode = permissionEngine_.getMode(wid);
+ rateLimiter_.recordUsage(tool->tier(), wid);
+ }
+ auditLogger_.log(audit);
+
+ nlohmann::json rj;
+ to_json(rj, result);
+ return JSONRPCResponse::ok(req.id, rj);
+ }
+ catch (const MCPToolError& e)
+ {
+ const auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::steady_clock::now() - startTime).count();
+ const std::string err = sanitizeError(e.what());
+
+ audit.result.durationMs = static_cast<int>(dur);
+ audit.result.status = MCPAuditStatus::Error;
+ audit.error = err;
+ if (connIdStr)
+ audit.security.permissionMode =
+ permissionEngine_.getMode(utf8ToWide(*connIdStr));
+ auditLogger_.log(audit);
+
+ // Tool errors surface as tool result with isError=true
+ // (mac behavior) rather than JSON-RPC errors, so the AI
+ // client sees the message content.
+ auto tr = MCPToolResult::error(err);
+ nlohmann::json rj;
+ to_json(rj, tr);
+ return JSONRPCResponse::ok(req.id, rj);
+ }
+ catch (const std::exception& e)
+ {
+ const auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::steady_clock::now() - startTime).count();
+ const std::string err = sanitizeError(e.what());
+
+ audit.result.durationMs = static_cast<int>(dur);
+ audit.result.status = MCPAuditStatus::Error;
+ audit.error = err;
+ auditLogger_.log(audit);
+
+ auto tr = MCPToolResult::error(err);
+ nlohmann::json rj;
+ to_json(rj, tr);
+ return JSONRPCResponse::ok(req.id, rj);
+ }
+ }
+
+ void MCPServer::sendResponse(const JSONRPCResponse& resp)
+ {
+ if (mode_ == MCPTransportMode::Stdio)
+ stdio_.send(resp);
+ // HTTP transport: Phase 4d.
+ }
+
+ std::string MCPServer::sanitizeError(const std::string& msg)
+ {
+ static const std::regex reUsers(R"(/Users/[^/\s]+)");
+ static const std::regex reHome(R"(/home/[^/\s]+)");
+ static const std::regex reWinUser(R"([Cc]:\\Users\\[^\\\s]+)");
+ static const std::regex rePG(R"(postgres://[^\s]+)");
+ static const std::regex reMY(R"(mysql://[^\s]+)");
+ static const std::regex reMG(R"(mongodb://[^\s]+)");
+
+ std::string s = msg;
+ s = std::regex_replace(s, reUsers, "[path]");
+ s = std::regex_replace(s, reHome, "[path]");
+ s = std::regex_replace(s, reWinUser,"[path]");
+ s = std::regex_replace(s, rePG, "[connection]");
+ s = std::regex_replace(s, reMY, "[connection]");
+ s = std::regex_replace(s, reMG, "[connection]");
+ return s;
+ }
+}
diff --git a/windows/Gridex/Services/MCP/MCPServer.h b/windows/Gridex/Services/MCP/MCPServer.h
new file mode 100644
index 0000000..7d67559
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPServer.h
@@ -0,0 +1,101 @@
+#pragma once
+//
+// MCPServer.h
+// Gridex
+//
+// Orchestrator. Owns registry + security + audit + pool + transports.
+// Handles the three MCP protocol verbs: initialize, tools/list,
+// tools/call. Mirrors macos/Services/MCP/MCPServer.swift.
+//
+// Transport modes:
+// - Stdio: CLI `--mcp-stdio`. Uses stdin/stdout, no UI.
+// Tier 3 tools auto-deny (no window for ContentDialog).
+// - HttpOnly: GUI mode. HTTP endpoint (Phase 4d, TBD) on 127.0.0.1:port.
+// Tier 3 tools can open the approval dialog on MainWindow.
+
+#include <memory>
+#include <atomic>
+#include <string>
+#include "MCPConnectionPool.h"
+#include "Tools/MCPTool.h"
+#include "Tools/MCPToolRegistry.h"
+#include "Security/MCPPermissionEngine.h"
+#include "Security/MCPRateLimiter.h"
+#include "Security/MCPApprovalGate.h"
+#include "Audit/MCPAuditLogger.h"
+#include "Transport/StdioTransport.h"
+#include "../../Models/MCP/MCPProtocol.h"
+#include "../../Models/MCP/MCPServerInfo.h"
+#include "../../Models/AppSettings.h"
+
+namespace DBModels
+{
+ enum class MCPTransportMode
+ {
+ Stdio, // CLI mode — stdin/stdout
+ HttpOnly // GUI mode — HTTP transport only
+ };
+
+ class MCPServer
+ {
+ public:
+ MCPServer(AppSettings settings,
+ std::string serverVersion,
+ MCPTransportMode mode);
+
+ // Start accepting requests.
+ void start();
+
+ // Graceful shutdown — closes transports, flushes audit,
+ // releases pool adapters.
+ void stop();
+
+ bool isRunning() const { return running_.load(); }
+
+ // Expose the subsystems for the UI (MCPWindow needs pool
+ // stats, audit entries, permission modes).
+ MCPPermissionEngine& permissionEngine() { return permissionEngine_; }
+ MCPRateLimiter& rateLimiter() { return rateLimiter_; }
+ MCPAuditLogger& auditLogger() { return auditLogger_; }
+ MCPConnectionPool& pool() { return pool_; }
+ MCPApprovalGate& approvalGate() { return approvalGate_; }
+ MCPToolRegistry& toolRegistry() { return toolRegistry_; }
+
+ // Called by MainWindow once it is activated.
+ void setUIContext(void* dispatcherQueue, void* xamlRoot);
+
+ // Register all built-in tools. Called from start() — made
+ // public so tests can wire up selectively.
+ void registerBuiltinTools();
+
+ private:
+ AppSettings settings_;
+ std::string serverVersion_;
+ MCPTransportMode mode_;
+ std::atomic<bool> running_{false};
+
+ MCPConnectionPool pool_;
+ MCPPermissionEngine permissionEngine_;
+ MCPRateLimiter rateLimiter_;
+ MCPApprovalGate approvalGate_;
+ MCPAuditLogger auditLogger_;
+ MCPToolRegistry toolRegistry_;
+ StdioTransport stdio_;
+
+ MCPClientInfo clientInfo_; // populated on initialize
+
+ // Request dispatch.
+ void handleRequest(const JSONRPCRequest& req);
+ JSONRPCResponse handleInitialize(const JSONRPCRequest& req);
+ JSONRPCResponse handleToolsList(const JSONRPCRequest& req);
+ JSONRPCResponse handleToolsCall(const JSONRPCRequest& req);
+
+ // Sends back via the active transport.
+ void sendResponse(const JSONRPCResponse& resp);
+
+ // Strip filesystem paths / connection strings from error
+ // messages before the client sees them. Matches mac's
+ // sanitizeError.
+ static std::string sanitizeError(const std::string& msg);
+ };
+}
diff --git a/windows/Gridex/Services/MCP/MCPServerHost.cpp b/windows/Gridex/Services/MCP/MCPServerHost.cpp
new file mode 100644
index 0000000..5f8a3fb
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPServerHost.cpp
@@ -0,0 +1,46 @@
+//
+// MCPServerHost.cpp
+//
+
+#include "MCPServerHost.h"
+
+namespace DBModels { namespace MCPServerHost {
+
+namespace {
+ std::mutex g_mtx;
+ std::unique_ptr<MCPServer> g_server;
+}
+
+MCPServer* ensureCreated(const AppSettings& settings,
+ const std::string& version,
+ MCPTransportMode mode)
+{
+ std::lock_guard<std::mutex> lk(g_mtx);
+ if (!g_server)
+ g_server = std::make_unique<MCPServer>(settings, version, mode);
+ return g_server.get();
+}
+
+MCPServer* instance()
+{
+ std::lock_guard<std::mutex> lk(g_mtx);
+ return g_server.get();
+}
+
+void start()
+{
+ std::lock_guard<std::mutex> lk(g_mtx);
+ if (g_server) g_server->start();
+}
+
+void stop()
+{
+ std::lock_guard<std::mutex> lk(g_mtx);
+ if (g_server)
+ {
+ g_server->stop();
+ g_server.reset();
+ }
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/MCPServerHost.h b/windows/Gridex/Services/MCP/MCPServerHost.h
new file mode 100644
index 0000000..645b353
--- /dev/null
+++ b/windows/Gridex/Services/MCP/MCPServerHost.h
@@ -0,0 +1,35 @@
+#pragma once
+//
+// MCPServerHost.h
+// Gridex
+//
+// Process-wide singleton that owns the MCPServer instance. Created
+// lazily at first start(), kept alive until app exit. Lets
+// MainWindow, MCPPage, HomePage, and the CLI entry point share the
+// same server without passing it through every constructor.
+//
+// Thread-safe: start/stop take an internal mutex.
+
+#include <memory>
+#include <mutex>
+#include "MCPServer.h"
+
+namespace DBModels { namespace MCPServerHost {
+
+// Ensures a server exists (creating on demand with the supplied
+// settings + mode) and returns a non-owning pointer. Safe to call
+// repeatedly — subsequent calls just return the existing instance.
+MCPServer* ensureCreated(const AppSettings& settings,
+ const std::string& version,
+ MCPTransportMode mode);
+
+// Returns the shared server, or nullptr if it has never been created.
+MCPServer* instance();
+
+// Starts the shared server (idempotent).
+void start();
+
+// Stops + destroys the shared server. Called from app shutdown.
+void stop();
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Security/MCPApprovalGate.cpp b/windows/Gridex/Services/MCP/Security/MCPApprovalGate.cpp
new file mode 100644
index 0000000..572b849
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPApprovalGate.cpp
@@ -0,0 +1,158 @@
+//
+// MCPApprovalGate.cpp
+//
+// Implementation marshals a ContentDialog onto the MainWindow
+// DispatcherQueue. winrt com_ptr handles are stored in opaque
+// void* members of MCPApprovalGate so the header stays free of
+// winrt includes.
+
+#include "MCPApprovalGate.h"
+
+#include <windows.h>
+#include <winrt/Microsoft.UI.Dispatching.h>
+#include <winrt/Microsoft.UI.Xaml.h>
+#include <winrt/Microsoft.UI.Xaml.Controls.h>
+#include <winrt/Windows.Foundation.h>
+#include <atomic>
+#include <memory>
+
+namespace mux = winrt::Microsoft::UI::Xaml;
+namespace mxc = winrt::Microsoft::UI::Xaml::Controls;
+namespace mxd = winrt::Microsoft::UI::Dispatching;
+
+namespace DBModels
+{
+ void MCPApprovalGate::setUIContext(void* dispatcherQueue, void* xamlRoot)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ dispatcher_ = dispatcherQueue;
+ xamlRoot_ = xamlRoot;
+ }
+
+ void MCPApprovalGate::revokeSessionApproval(const std::wstring& connectionId)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ for (auto it = sessionApprovals_.begin(); it != sessionApprovals_.end(); )
+ {
+ if (it->first.first == connectionId) it = sessionApprovals_.erase(it);
+ else ++it;
+ }
+ }
+
+ void MCPApprovalGate::revokeAllSessionApprovals()
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ sessionApprovals_.clear();
+ }
+
+ std::future<bool> MCPApprovalGate::requestApproval(const MCPApprovalRequest& req)
+ {
+ auto promise = std::make_shared<std::promise<bool>>();
+ auto future = promise->get_future();
+
+ const auto key = std::make_pair(req.connectionId, req.tool);
+
+ // Session cache hit?
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ auto it = sessionApprovals_.find(key);
+ if (it != sessionApprovals_.end())
+ {
+ const auto age = std::chrono::system_clock::now() - it->second;
+ if (age < kSessionTTL)
+ {
+ promise->set_value(true);
+ return future;
+ }
+ }
+ }
+
+ // No UI hookup yet (server in headless / pre-window state).
+ // Fail closed — deny rather than hang forever.
+ if (!dispatcher_ || !xamlRoot_)
+ {
+ promise->set_value(false);
+ return future;
+ }
+
+ // Copy winrt handles onto the stack before capturing.
+ auto dispatcher = *reinterpret_cast<mxd::DispatcherQueue*>(&dispatcher_);
+ auto xamlRoot = *reinterpret_cast<mux::XamlRoot*>(&xamlRoot_);
+
+ auto resolved = std::make_shared<std::atomic<bool>>(false);
+
+ auto self = this;
+ auto enqueued = dispatcher.TryEnqueue(
+ [self, req, xamlRoot, promise, resolved, key]()
+ {
+ try
+ {
+ mxc::ContentDialog dlg;
+ dlg.Title(winrt::box_value(winrt::hstring(
+ req.clientName + L" wants to:")));
+
+ const std::wstring body =
+ req.description + L"\n\n" +
+ req.details + L"\n\n" +
+ L"Connection: " + (req.connectionId.size() > 8
+ ? req.connectionId.substr(0, 8) + L"..."
+ : req.connectionId);
+
+ dlg.Content(winrt::box_value(winrt::hstring(body)));
+ dlg.CloseButtonText(L"Deny");
+ dlg.PrimaryButtonText(L"Approve Once");
+ dlg.SecondaryButtonText(L"Approve for Session");
+ dlg.DefaultButton(mxc::ContentDialogButton::Close);
+ dlg.XamlRoot(xamlRoot);
+
+ auto op = dlg.ShowAsync();
+ op.Completed(
+ [self, promise, resolved, key](
+ auto const& asyncOp,
+ winrt::Windows::Foundation::AsyncStatus status)
+ {
+ if (resolved->exchange(true)) return;
+
+ bool approved = false;
+ bool sessionApproval = false;
+ if (status == winrt::Windows::Foundation::AsyncStatus::Completed)
+ {
+ try
+ {
+ const auto r = asyncOp.GetResults();
+ if (r == mxc::ContentDialogResult::Primary)
+ approved = true;
+ else if (r == mxc::ContentDialogResult::Secondary)
+ {
+ approved = true;
+ sessionApproval = true;
+ }
+ }
+ catch (...) {}
+ }
+
+ if (sessionApproval)
+ {
+ std::lock_guard<std::mutex> lk(self->mtx_);
+ self->sessionApprovals_[key] =
+ std::chrono::system_clock::now();
+ }
+
+ promise->set_value(approved);
+ });
+ }
+ catch (...)
+ {
+ if (!resolved->exchange(true))
+ promise->set_value(false);
+ }
+ });
+
+ if (!enqueued)
+ {
+ // Dispatcher already shut down.
+ promise->set_value(false);
+ }
+ return future;
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPApprovalGate.h b/windows/Gridex/Services/MCP/Security/MCPApprovalGate.h
new file mode 100644
index 0000000..7515ba2
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPApprovalGate.h
@@ -0,0 +1,83 @@
+#pragma once
+//
+// MCPApprovalGate.h
+// Gridex
+//
+// Presents a ContentDialog on the MainWindow XAML root and returns
+// the user's verdict via std::future<bool>. Mirrors
+// macos/Services/MCP/Security/MCPApprovalGate.swift but uses Win32
+// threading primitives instead of Swift actors.
+//
+// The tool layer calls `requestApproval(...).get()` on a worker
+// thread (HTTP/stdio request handler). The dialog is marshalled
+// onto the UI thread via DispatcherQueue::TryEnqueue.
+
+#include <string>
+#include <future>
+#include <chrono>
+#include <mutex>
+#include <unordered_map>
+#include <utility>
+
+// Forward-declare winrt types so this header stays usable in
+// non-winrt TUs. Full types pulled in by the .cpp.
+namespace winrt::Microsoft::UI::Dispatching { struct DispatcherQueue; }
+namespace winrt::Microsoft::UI::Xaml { struct XamlRoot; }
+
+namespace DBModels
+{
+ struct MCPApprovalRequest
+ {
+ std::wstring tool; // tool name
+ std::wstring description; // "Insert 3 rows into 'users'"
+ std::wstring details; // multi-line body — SQL + row count
+ std::wstring connectionId;
+ std::wstring clientName; // shown as "<client> wants to:"
+ int timeoutSeconds = 60;
+ };
+
+ class MCPApprovalGate
+ {
+ public:
+ MCPApprovalGate() = default;
+
+ // Set once from MainWindow after the window is activated.
+ // Approvals requested before this is set auto-deny with a
+ // logged warning (the server may be running headless via
+ // --mcp-stdio CLI mode, in which case Tier 3 tools are
+ // expected to be unavailable — documented in Setup tab).
+ void setUIContext(void* dispatcherQueue, void* xamlRoot);
+
+ std::future<bool> requestApproval(const MCPApprovalRequest& req);
+
+ void revokeSessionApproval(const std::wstring& connectionId);
+ void revokeAllSessionApprovals();
+
+ private:
+ // Session cache key = (connectionId, tool). 30-minute TTL
+ // matches macOS.
+ using SessionKey = std::pair<std::wstring, std::wstring>;
+ struct SessionKeyHash
+ {
+ size_t operator()(const SessionKey& k) const noexcept
+ {
+ const auto h1 = std::hash<std::wstring>{}(k.first);
+ const auto h2 = std::hash<std::wstring>{}(k.second);
+ return h1 ^ (h2 << 1);
+ }
+ };
+
+ mutable std::mutex mtx_;
+ std::unordered_map<SessionKey,
+ std::chrono::system_clock::time_point,
+ SessionKeyHash> sessionApprovals_;
+
+ // UI thread hook — opaque void* here, winrt::com_ptr<...>
+ // on the impl side to avoid dragging winrt headers into
+ // every consumer.
+ void* dispatcher_ = nullptr;
+ void* xamlRoot_ = nullptr;
+
+ static constexpr std::chrono::seconds kSessionTTL{30 * 60};
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.cpp b/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.cpp
new file mode 100644
index 0000000..9767c93
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.cpp
@@ -0,0 +1,61 @@
+//
+// MCPIdentifierValidator.cpp
+//
+
+#include "MCPIdentifierValidator.h"
+#include "../../../Models/MCP/MCPToolError.h"
+
+namespace DBModels { namespace MCPIdentifierValidator {
+
+bool isValid(const std::string& identifier)
+{
+ if (identifier.empty() || identifier.size() > static_cast<size_t>(kMaxLength))
+ return false;
+
+ for (size_t i = 0; i < identifier.size(); ++i)
+ {
+ const unsigned char c = static_cast<unsigned char>(identifier[i]);
+ const bool isLetter = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_';
+ const bool isDigit = c >= '0' && c <= '9';
+ if (i == 0)
+ {
+ if (!isLetter) return false;
+ }
+ else
+ {
+ if (!isLetter && !isDigit) return false;
+ }
+ }
+ return true;
+}
+
+void validate(const std::string& identifier, const std::string& name)
+{
+ if (!isValid(identifier))
+ {
+ throw MCPToolError::invalidParameters(
+ name + " '" + identifier + "' contains invalid characters. "
+ "Allowed: letters, digits, underscore; must start with a letter or underscore; max "
+ + std::to_string(kMaxLength) + " chars.");
+ }
+}
+
+TableSchema extractTableAndSchema(const nlohmann::json& params)
+{
+ TableSchema ts;
+ if (!params.contains("table_name") || !params["table_name"].is_string())
+ throw MCPToolError::invalidParameters("table_name is required");
+
+ ts.table = params["table_name"].get<std::string>();
+ validate(ts.table, "table_name");
+
+ if (params.contains("schema") && params["schema"].is_string())
+ {
+ auto s = params["schema"].get<std::string>();
+ validate(s, "schema");
+ ts.schema = s;
+ }
+ return ts;
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.h b/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.h
new file mode 100644
index 0000000..80a8a2c
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.h
@@ -0,0 +1,39 @@
+#pragma once
+//
+// MCPIdentifierValidator.h
+// Gridex
+//
+// Allowlist check for SQL identifiers (table / column / schema
+// names) received from MCP clients. Defense-in-depth: even when
+// the identifier later hits `quoteSqlIdentifier`, anything outside
+// a strict ASCII shape is rejected before reaching a driver.
+//
+// Port of macos/Services/MCP/Security/MCPIdentifierValidator.swift.
+
+#include <string>
+#include <optional>
+#include <nlohmann/json.hpp>
+
+namespace DBModels
+{
+ namespace MCPIdentifierValidator
+ {
+ constexpr int kMaxLength = 128;
+
+ // ASCII: first char [A-Za-z_], rest [A-Za-z0-9_], length 1..128.
+ bool isValid(const std::string& identifier);
+
+ // Throws MCPToolError::InvalidParameters on failure.
+ void validate(const std::string& identifier, const std::string& name = "identifier");
+
+ // Shared extraction used by the write tools. Pulls
+ // `table_name` (required) and `schema` (optional) from the
+ // JSON params, validating both. Returns (table, schema_or_null).
+ struct TableSchema
+ {
+ std::string table;
+ std::optional<std::string> schema;
+ };
+ TableSchema extractTableAndSchema(const nlohmann::json& params);
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.cpp b/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.cpp
new file mode 100644
index 0000000..514534a
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.cpp
@@ -0,0 +1,200 @@
+//
+// MCPPermissionEngine.cpp
+//
+// Notes on porting from Swift:
+// * `actor` → `std::mutex`-guarded members.
+// * NSRegularExpression → `std::regex`. ECMAScript flavor accepts
+// `\b` word anchors; tested empirically on MSVC.
+// * Whitespace helpers use <cctype> isspace to avoid std::isspace
+// locale overloads that choke on char >= 0x80.
+
+#include "MCPPermissionEngine.h"
+#include "MCPSQLSanitizer.h"
+#include <regex>
+#include <algorithm>
+#include <cctype>
+#include <unordered_set>
+
+namespace DBModels
+{
+ // Static — these allocations happen once at first call.
+ namespace
+ {
+ const std::vector<std::string>& readOnlyPrefixes()
+ {
+ static const std::vector<std::string> v{
+ "SELECT", "SHOW", "EXPLAIN", "DESCRIBE", "DESC", "WITH"
+ };
+ return v;
+ }
+
+ // Must match mac's MCPPermissionEngine.dangerousKeywords exactly
+ // — drift here is a security bug.
+ const std::regex& dangerousKeywordRegex()
+ {
+ static const std::regex re(
+ R"(\b(INSERT|UPDATE|DELETE|MERGE|UPSERT|DROP|CREATE|ALTER|TRUNCATE|RENAME|)"
+ R"(GRANT|REVOKE|CALL|EXEC|EXECUTE|DO|NEXTVAL|SETVAL|LO_IMPORT|LO_EXPORT|)"
+ R"(PG_READ_SERVER_FILES|PG_WRITE_SERVER_FILES|PG_READ_BINARY_FILE|PG_LS_DIR|)"
+ R"(DBLINK|DBLINK_EXEC|COPY|VACUUM|ANALYZE|REINDEX|CLUSTER|REFRESH|LOCK|UNLOCK|)"
+ R"(SET|RESET|BEGIN|COMMIT|ROLLBACK|SAVEPOINT)\b)",
+ std::regex::icase | std::regex::ECMAScript);
+ return re;
+ }
+
+ std::string trim(const std::string& s)
+ {
+ size_t a = 0, b = s.size();
+ while (a < b && std::isspace(static_cast<unsigned char>(s[a]))) ++a;
+ while (b > a && std::isspace(static_cast<unsigned char>(s[b - 1]))) --b;
+ return s.substr(a, b - a);
+ }
+
+ std::string upper(std::string s)
+ {
+ std::transform(s.begin(), s.end(), s.begin(),
+ [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+ return s;
+ }
+
+ bool startsWith(const std::string& s, const std::string& prefix)
+ {
+ return s.size() >= prefix.size() &&
+ std::equal(prefix.begin(), prefix.end(), s.begin());
+ }
+ }
+
+ // ── Mode bookkeeping ─────────────────────────────────────
+
+ void MCPPermissionEngine::setMode(const std::wstring& id, MCPConnectionMode mode)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ modes_[id] = mode;
+ }
+
+ MCPConnectionMode MCPPermissionEngine::getMode(const std::wstring& id) const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ auto it = modes_.find(id);
+ return it != modes_.end() ? it->second : MCPConnectionMode::Locked;
+ }
+
+ void MCPPermissionEngine::removeMode(const std::wstring& id)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ modes_.erase(id);
+ }
+
+ // ── Permission check ─────────────────────────────────────
+
+ MCPPermissionResult MCPPermissionEngine::checkPermission(
+ MCPPermissionTier tier, const std::wstring& id) const
+ {
+ return checkPermission(tier, getMode(id));
+ }
+
+ MCPPermissionResult MCPPermissionEngine::checkPermission(
+ MCPPermissionTier tier, MCPConnectionMode mode) const
+ {
+ switch (tier)
+ {
+ case MCPPermissionTier::Schema:
+ return mcpAllowsTier1(mode)
+ ? MCPPermissionResult::allowed()
+ : MCPPermissionResult::denied("Connection is locked. MCP access is disabled.");
+
+ case MCPPermissionTier::Read:
+ return mcpAllowsTier2(mode)
+ ? MCPPermissionResult::allowed()
+ : MCPPermissionResult::denied("Connection is locked. MCP access is disabled.");
+
+ case MCPPermissionTier::Write:
+ if (!mcpAllowsTier3(mode))
+ return MCPPermissionResult::denied(
+ "This operation requires read-write mode. Ask the user to enable it in Connection Settings > MCP Access.");
+ return MCPPermissionResult::requiresApproval();
+
+ case MCPPermissionTier::DDL:
+ if (!mcpAllowsTier4(mode))
+ return MCPPermissionResult::denied(
+ "DDL operations require read-write mode. Ask the user to enable it in Connection Settings > MCP Access.");
+ return MCPPermissionResult::requiresApproval();
+
+ case MCPPermissionTier::Advanced:
+ return mcpAllowsTier5(mode)
+ ? MCPPermissionResult::allowed()
+ : MCPPermissionResult::denied("Connection is locked. MCP access is disabled.");
+ }
+ return MCPPermissionResult::denied("Unknown tier");
+ }
+
+ // ── Read-only SQL validator ──────────────────────────────
+
+ MCPPermissionResult MCPPermissionEngine::validateReadOnlyQuery(const std::string& sql) const
+ {
+ const std::string code = MCPSQLSanitizer::stripCommentsAndStrings(sql);
+ const std::string trimmedUpper = upper(trim(code));
+
+ std::string withoutTrailingSemi = trimmedUpper;
+ if (!withoutTrailingSemi.empty() && withoutTrailingSemi.back() == ';')
+ {
+ withoutTrailingSemi.pop_back();
+ withoutTrailingSemi = trim(withoutTrailingSemi);
+ }
+ if (withoutTrailingSemi.find(';') != std::string::npos)
+ return MCPPermissionResult::denied("Multiple statements are not allowed in read-only mode.");
+
+ bool ok = false;
+ for (const auto& p : readOnlyPrefixes())
+ if (startsWith(trimmedUpper, p)) { ok = true; break; }
+ if (!ok)
+ return MCPPermissionResult::denied("Only SELECT queries are allowed in read-only mode. This query appears to modify data.");
+
+ std::smatch m;
+ if (std::regex_search(code, m, dangerousKeywordRegex()))
+ {
+ const std::string hit = upper(m.str());
+ return MCPPermissionResult::denied(
+ "Query contains '" + hit + "' which is not allowed in read-only mode.");
+ }
+
+ return MCPPermissionResult::allowed();
+ }
+
+ // ── WHERE clause validator ───────────────────────────────
+
+ MCPPermissionResult MCPPermissionEngine::validateWhereClause(const std::string& whereClause) const
+ {
+ if (whereClause.empty())
+ return MCPPermissionResult::denied(
+ "WHERE clause is required for UPDATE/DELETE operations. Bare UPDATE/DELETE without WHERE is not allowed.");
+
+ const std::string trimmed = trim(whereClause);
+ if (trimmed.empty())
+ return MCPPermissionResult::denied("WHERE clause is required for UPDATE/DELETE operations.");
+
+ if (trimmed.find(';') != std::string::npos)
+ return MCPPermissionResult::denied("WHERE clause must not contain ';' — statement terminators are forbidden.");
+ if (trimmed.find("--") != std::string::npos)
+ return MCPPermissionResult::denied("WHERE clause must not contain '--' — SQL line comments are forbidden.");
+ if (trimmed.find("/*") != std::string::npos || trimmed.find("*/") != std::string::npos)
+ return MCPPermissionResult::denied("WHERE clause must not contain '/*' or '*/' — SQL block comments are forbidden.");
+
+ // Trivial predicate check: uppercase, strip ALL whitespace.
+ std::string compact;
+ compact.reserve(trimmed.size());
+ for (char c : trimmed)
+ if (!std::isspace(static_cast<unsigned char>(c)))
+ compact.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(c))));
+
+ static const std::unordered_set<std::string> trivial{
+ "1=1", "TRUE", "1", "'1'='1'",
+ "1<>0", "0=0", "2>1", "TRUE=TRUE", "NULLISNULL"
+ };
+ if (trivial.count(compact) != 0)
+ return MCPPermissionResult::denied(
+ "Trivial WHERE clause '" + trimmed + "' is not allowed. Provide a meaningful predicate.");
+
+ return MCPPermissionResult::allowed();
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.h b/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.h
new file mode 100644
index 0000000..caf628a
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPPermissionEngine.h
@@ -0,0 +1,56 @@
+#pragma once
+//
+// MCPPermissionEngine.h
+// Gridex
+//
+// Thread-safe per-connection permission gate. Mirrors
+// macos/Services/MCP/Security/MCPPermissionEngine.swift.
+//
+// Two primary responsibilities:
+// 1. Map connectionId → MCPConnectionMode, combined with tier to
+// emit Allowed | RequiresApproval | Denied.
+// 2. Syntactic validators for SELECT-only enforcement
+// (validateReadOnlyQuery) and UPDATE/DELETE WHERE clauses
+// (validateWhereClause).
+
+#include <string>
+#include <unordered_map>
+#include <mutex>
+#include "../../../Models/MCP/MCPConnectionMode.h"
+#include "../../../Models/MCP/MCPPermissionTier.h"
+#include "MCPPermissionResult.h"
+
+namespace DBModels
+{
+ class MCPPermissionEngine
+ {
+ public:
+ // Mode bookkeeping. `connectionId` is the same wstring id
+ // used by ConnectionConfig / ConnectionStore.
+ void setMode(const std::wstring& connectionId, MCPConnectionMode mode);
+ MCPConnectionMode getMode(const std::wstring& connectionId) const;
+ void removeMode(const std::wstring& connectionId);
+
+ // Core gate. Takes a snapshot of the mode and runs the
+ // Swift decision table.
+ MCPPermissionResult checkPermission(MCPPermissionTier tier,
+ const std::wstring& connectionId) const;
+ MCPPermissionResult checkPermission(MCPPermissionTier tier,
+ MCPConnectionMode mode) const;
+
+ // SELECT-only enforcement for Tier 2 queries in read-only
+ // mode. Runs MCPSQLSanitizer first, then:
+ // - rejects multi-statement (`;` anywhere except trailing)
+ // - requires prefix ∈ {SELECT, SHOW, EXPLAIN, DESCRIBE, DESC, WITH}
+ // - blocks 30+ dangerous keywords via regex
+ MCPPermissionResult validateReadOnlyQuery(const std::string& sql) const;
+
+ // Mandatory WHERE validator for Tier 3 write tools.
+ // Rejects bare clauses, `;`, SQL comments, and trivial tautologies.
+ MCPPermissionResult validateWhereClause(const std::string& whereClause) const;
+
+ private:
+ mutable std::mutex mtx_;
+ std::unordered_map<std::wstring, MCPConnectionMode> modes_;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPPermissionResult.h b/windows/Gridex/Services/MCP/Security/MCPPermissionResult.h
new file mode 100644
index 0000000..69e2bb1
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPPermissionResult.h
@@ -0,0 +1,40 @@
+#pragma once
+//
+// MCPPermissionResult.h
+// Gridex
+//
+// Tagged union returned by MCPPermissionEngine::checkPermission.
+// Mirrors macos enum MCPPermissionResult { .allowed, .requiresApproval, .denied(String) }.
+
+#include <string>
+
+namespace DBModels
+{
+ struct MCPPermissionResult
+ {
+ enum class Kind { Allowed, RequiresApproval, Denied };
+ Kind kind = Kind::Allowed;
+ std::string message; // populated only when kind == Denied
+
+ static MCPPermissionResult allowed()
+ {
+ return { Kind::Allowed, {} };
+ }
+ static MCPPermissionResult requiresApproval()
+ {
+ return { Kind::RequiresApproval, {} };
+ }
+ static MCPPermissionResult denied(std::string msg)
+ {
+ return { Kind::Denied, std::move(msg) };
+ }
+
+ bool isAllowed() const { return kind == Kind::Allowed; }
+ bool requiresUserApproval() const { return kind == Kind::RequiresApproval; }
+ // Returns nullptr when no error message (Allowed or RequiresApproval).
+ const std::string* errorMessage() const
+ {
+ return kind == Kind::Denied ? &message : nullptr;
+ }
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPRateLimiter.cpp b/windows/Gridex/Services/MCP/Security/MCPRateLimiter.cpp
new file mode 100644
index 0000000..84bd859
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPRateLimiter.cpp
@@ -0,0 +1,157 @@
+//
+// MCPRateLimiter.cpp
+//
+
+#include "MCPRateLimiter.h"
+#include <algorithm>
+
+namespace DBModels
+{
+ using TimePoint = std::chrono::system_clock::time_point;
+
+ // ── RateBucket ───────────────────────────────────────────
+
+ int MCPRateLimiter::RateBucket::countInWindow(TimePoint now, int windowSeconds) const
+ {
+ const auto cutoff = now - std::chrono::seconds(windowSeconds);
+ int n = 0;
+ for (const auto& t : stamps) if (t > cutoff) ++n;
+ return n;
+ }
+
+ TimePoint MCPRateLimiter::RateBucket::oldestInWindow(TimePoint now, int windowSeconds) const
+ {
+ const auto cutoff = now - std::chrono::seconds(windowSeconds);
+ TimePoint best{};
+ bool have = false;
+ for (const auto& t : stamps)
+ {
+ if (t > cutoff && (!have || t < best)) { best = t; have = true; }
+ }
+ return have ? best : now;
+ }
+
+ void MCPRateLimiter::RateBucket::cleanup(TimePoint now, int maxAgeSeconds)
+ {
+ const auto cutoff = now - std::chrono::seconds(maxAgeSeconds);
+ stamps.erase(
+ std::remove_if(stamps.begin(), stamps.end(),
+ [cutoff](const TimePoint& t) { return t <= cutoff; }),
+ stamps.end());
+ }
+
+ // ── Public API ───────────────────────────────────────────
+
+ void MCPRateLimiter::setConfig(const MCPRateLimiterConfig& c)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ cfg_ = c;
+ }
+
+ MCPRateLimitResult MCPRateLimiter::checkLimit(
+ MCPPermissionTier tier, const std::wstring& id)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ const auto now = std::chrono::system_clock::now();
+ switch (tier)
+ {
+ case MCPPermissionTier::Schema:
+ case MCPPermissionTier::Read:
+ case MCPPermissionTier::Advanced:
+ return checkQuery(id, now);
+ case MCPPermissionTier::Write:
+ return checkWrite(id, now);
+ case MCPPermissionTier::DDL:
+ return checkDDL(id, now);
+ }
+ return { true, 0 };
+ }
+
+ void MCPRateLimiter::recordUsage(MCPPermissionTier tier, const std::wstring& id)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ const auto now = std::chrono::system_clock::now();
+ auto record = [now](auto& map, const std::wstring& key, int maxAge)
+ {
+ auto& bucket = map[key];
+ bucket.record(now);
+ bucket.cleanup(now, maxAge);
+ };
+ switch (tier)
+ {
+ case MCPPermissionTier::Schema:
+ case MCPPermissionTier::Read:
+ case MCPPermissionTier::Advanced:
+ record(queryBuckets_, id, 3600); break;
+ case MCPPermissionTier::Write:
+ record(writeBuckets_, id, 60); break;
+ case MCPPermissionTier::DDL:
+ record(ddlBuckets_, id, 60); break;
+ }
+ }
+
+ void MCPRateLimiter::resetLimits(const std::wstring& id)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ queryBuckets_.erase(id);
+ writeBuckets_.erase(id);
+ ddlBuckets_.erase(id);
+ }
+
+ void MCPRateLimiter::resetAllLimits()
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ queryBuckets_.clear();
+ writeBuckets_.clear();
+ ddlBuckets_.clear();
+ }
+
+ // ── Internal: per-tier check ─────────────────────────────
+ // (callers hold mtx_)
+
+ MCPRateLimitResult MCPRateLimiter::checkQuery(const std::wstring& id, TimePoint now)
+ {
+ auto& b = queryBuckets_[id];
+ const int minuteCount = b.countInWindow(now, 60);
+ if (minuteCount >= cfg_.queriesPerMinute)
+ {
+ const auto oldest = b.oldestInWindow(now, 60);
+ const int retry = 60 - static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(now - oldest).count());
+ return { false, std::max(1, retry) };
+ }
+ const int hourCount = b.countInWindow(now, 3600);
+ if (hourCount >= cfg_.queriesPerHour)
+ {
+ const auto oldest = b.oldestInWindow(now, 3600);
+ const int retry = 3600 - static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(now - oldest).count());
+ return { false, std::max(1, retry) };
+ }
+ return { true, 0 };
+ }
+
+ MCPRateLimitResult MCPRateLimiter::checkWrite(const std::wstring& id, TimePoint now)
+ {
+ auto& b = writeBuckets_[id];
+ const int n = b.countInWindow(now, 60);
+ if (n >= cfg_.writesPerMinute)
+ {
+ const auto oldest = b.oldestInWindow(now, 60);
+ const int retry = 60 - static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(now - oldest).count());
+ return { false, std::max(1, retry) };
+ }
+ return { true, 0 };
+ }
+
+ MCPRateLimitResult MCPRateLimiter::checkDDL(const std::wstring& id, TimePoint now)
+ {
+ auto& b = ddlBuckets_[id];
+ const int n = b.countInWindow(now, 60);
+ if (n >= cfg_.ddlPerMinute)
+ {
+ const auto oldest = b.oldestInWindow(now, 60);
+ const int retry = 60 - static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(now - oldest).count());
+ return { false, std::max(1, retry) };
+ }
+ return { true, 0 };
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPRateLimiter.h b/windows/Gridex/Services/MCP/Security/MCPRateLimiter.h
new file mode 100644
index 0000000..6df2c4f
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPRateLimiter.h
@@ -0,0 +1,73 @@
+#pragma once
+//
+// MCPRateLimiter.h
+// Gridex
+//
+// Per-connection sliding-window rate limiter. Mirrors
+// macos/Services/MCP/Security/MCPRateLimiter.swift.
+//
+// Three independent buckets (query / write / DDL) keyed by
+// connection id. Limits are injected from AppSettings at
+// MCPServer startup (no runtime reconfiguration in v1).
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <mutex>
+#include <chrono>
+#include "../../../Models/MCP/MCPPermissionTier.h"
+
+namespace DBModels
+{
+ struct MCPRateLimitResult
+ {
+ bool allowed = true;
+ int retryAfterSeconds = 0;
+ };
+
+ struct MCPRateLimiterConfig
+ {
+ int queriesPerMinute = 60;
+ int queriesPerHour = 1000;
+ int writesPerMinute = 10;
+ int ddlPerMinute = 1;
+ };
+
+ class MCPRateLimiter
+ {
+ public:
+ explicit MCPRateLimiter(MCPRateLimiterConfig cfg = {}) : cfg_(cfg) {}
+
+ void setConfig(const MCPRateLimiterConfig& cfg);
+
+ MCPRateLimitResult checkLimit(MCPPermissionTier tier,
+ const std::wstring& connectionId);
+ void recordUsage(MCPPermissionTier tier,
+ const std::wstring& connectionId);
+
+ void resetLimits(const std::wstring& connectionId);
+ void resetAllLimits();
+
+ private:
+ using TimePoint = std::chrono::system_clock::time_point;
+
+ struct RateBucket
+ {
+ std::vector<TimePoint> stamps;
+ void record(TimePoint now) { stamps.push_back(now); }
+ int countInWindow(TimePoint now, int windowSeconds) const;
+ TimePoint oldestInWindow(TimePoint now, int windowSeconds) const;
+ void cleanup(TimePoint now, int maxAgeSeconds);
+ };
+
+ mutable std::mutex mtx_;
+ MCPRateLimiterConfig cfg_;
+ std::unordered_map<std::wstring, RateBucket> queryBuckets_;
+ std::unordered_map<std::wstring, RateBucket> writeBuckets_;
+ std::unordered_map<std::wstring, RateBucket> ddlBuckets_;
+
+ MCPRateLimitResult checkQuery(const std::wstring& id, TimePoint now);
+ MCPRateLimitResult checkWrite(const std::wstring& id, TimePoint now);
+ MCPRateLimitResult checkDDL(const std::wstring& id, TimePoint now);
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.cpp b/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.cpp
new file mode 100644
index 0000000..3696f9d
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.cpp
@@ -0,0 +1,49 @@
+//
+// MCPRowCountEstimator.cpp
+//
+
+#include "MCPRowCountEstimator.h"
+#include <stdexcept>
+
+namespace DBModels { namespace MCPRowCountEstimator {
+
+static bool isSQLDatabase(DatabaseType t)
+{
+ // Redis / MongoDB have no SQL COUNT(*) equivalent in this shape.
+ return t == DatabaseType::PostgreSQL ||
+ t == DatabaseType::MySQL ||
+ t == DatabaseType::SQLite ||
+ t == DatabaseType::MSSQLServer;
+}
+
+int estimate(const std::shared_ptr<DatabaseAdapter>& adapter,
+ const std::wstring& qualifiedTable,
+ const std::wstring& whereClause,
+ const ConnectionConfig& config)
+{
+ if (!adapter || !isSQLDatabase(config.databaseType))
+ return 0;
+
+ const std::wstring sql =
+ L"SELECT COUNT(*) AS cnt FROM " + qualifiedTable +
+ L" WHERE " + whereClause;
+
+ try
+ {
+ QueryResult r = adapter->execute(sql);
+ if (!r.success || r.rows.empty() || r.columnNames.empty())
+ return 0;
+ const auto& row = r.rows[0];
+ // Row is unordered_map<wstring,wstring> keyed by column name.
+ const auto it = row.find(r.columnNames[0]);
+ if (it == row.end()) return 0;
+ const std::wstring& val = it->second;
+ try { return std::stoi(val); } catch (...) { return 0; }
+ }
+ catch (...)
+ {
+ return 0;
+ }
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.h b/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.h
new file mode 100644
index 0000000..3515c55
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.h
@@ -0,0 +1,31 @@
+#pragma once
+//
+// MCPRowCountEstimator.h
+// Gridex
+//
+// Best-effort "SELECT COUNT(*) ..." estimate used by write tools
+// to show an affected-rows number in the approval dialog. Mirrors
+// macos/Services/MCP/Security/MCPRowCountEstimator.swift.
+//
+// Swallows every error and returns 0 — this is a UX aid, not a
+// correctness check. Callers MUST still validate the WHERE clause
+// via MCPPermissionEngine::validateWhereClause BEFORE calling.
+
+#include <string>
+#include <memory>
+#include "../../../Models/DatabaseAdapter.h"
+#include "../../../Models/ConnectionConfig.h"
+
+namespace DBModels
+{
+ namespace MCPRowCountEstimator
+ {
+ // `qualifiedTable` must already be quoted (caller used
+ // `adapter->quoteSqlIdentifier`). `whereClause` is untrusted
+ // but gated by validateWhereClause upstream.
+ int estimate(const std::shared_ptr<DatabaseAdapter>& adapter,
+ const std::wstring& qualifiedTable,
+ const std::wstring& whereClause,
+ const ConnectionConfig& config);
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.cpp b/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.cpp
new file mode 100644
index 0000000..f9627e2
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.cpp
@@ -0,0 +1,74 @@
+//
+// MCPSQLSanitizer.cpp
+//
+
+#include "MCPSQLSanitizer.h"
+
+namespace DBModels { namespace MCPSQLSanitizer {
+
+std::string stripCommentsAndStrings(const std::string& sql)
+{
+ std::string result;
+ result.reserve(sql.size());
+ const size_t n = sql.size();
+ size_t i = 0;
+
+ while (i < n)
+ {
+ const char c = sql[i];
+ const char next = (i + 1 < n) ? sql[i + 1] : '\0';
+
+ // -- line comment: consume until newline
+ if (c == '-' && next == '-')
+ {
+ while (i < n && sql[i] != '\n') ++i;
+ continue;
+ }
+
+ // /* block comment */
+ if (c == '/' && next == '*')
+ {
+ i += 2;
+ while (i < n)
+ {
+ if (sql[i] == '*' && i + 1 < n && sql[i + 1] == '/')
+ {
+ i += 2;
+ break;
+ }
+ ++i;
+ }
+ continue;
+ }
+
+ // 'single-quoted literal' with '' escape support
+ if (c == '\'')
+ {
+ ++i; // skip opening quote
+ while (i < n)
+ {
+ if (sql[i] == '\'')
+ {
+ if (i + 1 < n && sql[i + 1] == '\'')
+ {
+ // escaped '' inside literal — keep scanning
+ i += 2;
+ continue;
+ }
+ ++i; // consume closing quote
+ break;
+ }
+ ++i;
+ }
+ result.push_back(' ');
+ continue;
+ }
+
+ result.push_back(c);
+ ++i;
+ }
+
+ return result;
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.h b/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.h
new file mode 100644
index 0000000..7c9fc29
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.h
@@ -0,0 +1,27 @@
+#pragma once
+//
+// MCPSQLSanitizer.h
+// Gridex
+//
+// Strips SQL line comments, block comments, and string literals so
+// syntactic checks (prefix check, dangerous-keyword regex) operate
+// on code-only content. NEVER use the sanitized string for
+// execution — it is destructive (literals turned into single space).
+//
+// Port of macos/Services/MCP/Security/MCPSQLSanitizer.swift.
+
+#include <string>
+
+namespace DBModels
+{
+ namespace MCPSQLSanitizer
+ {
+ // Returns `sql` with:
+ // -- line comments removed
+ // /* block comments */ removed
+ // 'single-quoted literals' collapsed to a single space
+ //
+ // Handles escaped `''` inside a literal correctly.
+ std::string stripCommentsAndStrings(const std::string& sql);
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.cpp b/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.cpp
new file mode 100644
index 0000000..a8ebff1
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.cpp
@@ -0,0 +1,31 @@
+//
+// MCPBuiltinTools.cpp
+//
+// Phase 5 shipped tools. Remaining (list_schemas, list_relationships,
+// get_sample_rows, explain_query, search_across_tables, insert_rows,
+// update_rows, delete_rows, execute_write_query) land in later sprints.
+
+#include "MCPBuiltinTools.h"
+#include "Tier1/ListConnectionsTool.h"
+#include "Tier1/ListTablesTool.h"
+#include "Tier1/DescribeTableTool.h"
+#include "Tier2/QueryTool.h"
+
+namespace DBModels { namespace MCPBuiltinTools {
+
+void registerAll(MCPToolRegistry& r)
+{
+ // Tier 1 — schema introspection (always on for non-Locked).
+ r.registerTool(std::make_shared<ListConnectionsTool>());
+ r.registerTool(std::make_shared<ListTablesTool>());
+ r.registerTool(std::make_shared<DescribeTableTool>());
+
+ // Tier 2 — read queries (ReadOnly mode allowed, ReadWrite too).
+ r.registerTool(std::make_shared<QueryTool>());
+
+ // Tier 3 — write tools (TODO: insert_rows, update_rows,
+ // delete_rows, execute_write_query). Until they land Tier 3 is
+ // surfaced via the AI as unavailable.
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.h b/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.h
new file mode 100644
index 0000000..bc460df
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.h
@@ -0,0 +1,19 @@
+#pragma once
+//
+// MCPBuiltinTools.h
+// Gridex
+//
+// Single entry point that registers every shipped MCP tool into
+// an MCPToolRegistry. Keeps MCPServer.cpp free of per-tool
+// includes — when Phase 5 expands beyond 4 tools, just grow the
+// cpp here.
+
+#include "MCPToolRegistry.h"
+
+namespace DBModels
+{
+ namespace MCPBuiltinTools
+ {
+ void registerAll(MCPToolRegistry& registry);
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/MCPTool.cpp b/windows/Gridex/Services/MCP/Tools/MCPTool.cpp
new file mode 100644
index 0000000..8505848
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPTool.cpp
@@ -0,0 +1,64 @@
+//
+// MCPTool.cpp
+//
+
+#include "MCPTool.h"
+#include "../../../Models/ConnectionStore.h"
+#include "../../../Models/CredentialManager.h"
+#include "../../../Models/MCP/MCPAuditEntry.h"
+#include <algorithm>
+
+namespace DBModels
+{
+ std::wstring MCPTool::extractConnectionId(const nlohmann::json& params)
+ {
+ if (!params.contains("connection_id") || !params["connection_id"].is_string())
+ throw MCPToolError::invalidParameters("connection_id is required");
+ auto utf8 = params["connection_id"].get<std::string>();
+ return std::wstring(utf8.begin(), utf8.end()); // ASCII-only ids (UUIDs)
+ }
+
+ std::pair<std::shared_ptr<DatabaseAdapter>, ConnectionConfig>
+ MCPToolContext::getAdapter(const std::wstring& connectionId) const
+ {
+ // Look up the config from the connection store. Linear scan
+ // is fine — typical users have <50 connections.
+ auto configs = ConnectionStore::Load();
+ auto it = std::find_if(configs.begin(), configs.end(),
+ [&](const ConnectionConfig& c) { return c.id == connectionId; });
+ if (it == configs.end())
+ {
+ std::string narrow(connectionId.begin(), connectionId.end());
+ throw MCPToolError::connectionNotFound(narrow);
+ }
+
+ // Resolve password from Windows credential vault.
+ std::wstring pass = CredentialManager::Load(connectionId);
+
+ auto& ncPool = const_cast<MCPConnectionPool&>(pool);
+ auto adapter = ncPool.acquire(*it, pass);
+ return { adapter, *it };
+ }
+
+ bool MCPToolContext::requestApproval(
+ const std::wstring& toolName,
+ const std::wstring& description,
+ const std::wstring& details,
+ const std::wstring& connectionId,
+ const std::wstring& clientName,
+ int timeoutSeconds) const
+ {
+ MCPApprovalRequest req;
+ req.tool = toolName;
+ req.description = description;
+ req.details = details;
+ req.connectionId = connectionId;
+ req.clientName = clientName;
+ req.timeoutSeconds = timeoutSeconds;
+ auto& nc = const_cast<MCPApprovalGate&>(approvalGate);
+ auto future = nc.requestApproval(req);
+ // Block the worker thread — caller is on a stdio/http worker,
+ // not the UI thread, so this is safe.
+ return future.get();
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/MCPTool.h b/windows/Gridex/Services/MCP/Tools/MCPTool.h
new file mode 100644
index 0000000..f7a82df
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPTool.h
@@ -0,0 +1,88 @@
+#pragma once
+//
+// MCPTool.h
+// Gridex
+//
+// Tool interface + context bundle passed at execute() time. The
+// MCPServer builds one MCPToolContext per request and hands it to
+// the tool. Tools throw MCPToolError on failure; the server folds
+// them into MCPToolResult::error for the client.
+
+#include <string>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include "../../../Models/MCP/MCPToolDefinition.h"
+#include "../../../Models/MCP/MCPPermissionTier.h"
+#include "../../../Models/MCP/MCPToolError.h"
+#include "../../../Models/DatabaseAdapter.h"
+#include "../../../Models/ConnectionConfig.h"
+#include "../Security/MCPPermissionEngine.h"
+#include "../Security/MCPRateLimiter.h"
+#include "../Security/MCPApprovalGate.h"
+#include "../Audit/MCPAuditLogger.h"
+#include "../MCPConnectionPool.h"
+
+namespace DBModels
+{
+ // Forward-declared to break circularity with ConnectionStore.h.
+ // (Audit client is plain data.)
+ struct MCPAuditClient;
+
+ // Bundle of shared services made available to every tool.
+ // Members are non-owning references — the MCPServer owns them.
+ struct MCPToolContext
+ {
+ MCPConnectionPool& pool;
+ MCPPermissionEngine& permissionEngine;
+ MCPRateLimiter& rateLimiter;
+ MCPApprovalGate& approvalGate;
+ MCPAuditLogger& auditLogger;
+ MCPAuditClient client; // by-value; copied per-request
+
+ // Helper: looks up `connection_id` in JSON params, finds
+ // the matching ConnectionConfig, opens the adapter via the
+ // pool, returns (adapter, config).
+ // Throws MCPToolError::connectionNotFound if id is unknown.
+ std::pair<std::shared_ptr<DatabaseAdapter>, ConnectionConfig>
+ getAdapter(const std::wstring& connectionId) const;
+
+ MCPPermissionResult checkPermission(MCPPermissionTier tier,
+ const std::wstring& id) const
+ {
+ return permissionEngine.checkPermission(tier, id);
+ }
+
+ // Convenience — request approval and BLOCK the caller on
+ // the resulting future. Tools are invoked from worker
+ // threads, so blocking here is safe.
+ bool requestApproval(const std::wstring& tool,
+ const std::wstring& description,
+ const std::wstring& details,
+ const std::wstring& connectionId,
+ const std::wstring& clientName,
+ int timeoutSeconds = 60) const;
+ };
+
+ // Pure-virtual tool interface. All tool implementations inherit
+ // this + define name/description/tier/inputSchema + execute.
+ class MCPTool
+ {
+ public:
+ virtual ~MCPTool() = default;
+ virtual std::string name() const = 0;
+ virtual std::string description() const = 0;
+ virtual MCPPermissionTier tier() const = 0;
+ virtual nlohmann::json inputSchema() const = 0;
+ virtual MCPToolResult execute(const nlohmann::json& params,
+ MCPToolContext& context) = 0;
+
+ MCPToolDefinition definition() const
+ {
+ return { name(), description(), inputSchema() };
+ }
+
+ // Helper: extract `connection_id` from JSON params and
+ // return it as wstring (the store's native id type).
+ static std::wstring extractConnectionId(const nlohmann::json& params);
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Tools/MCPToolHelpers.h b/windows/Gridex/Services/MCP/Tools/MCPToolHelpers.h
new file mode 100644
index 0000000..2b3d9e7
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPToolHelpers.h
@@ -0,0 +1,33 @@
+#pragma once
+//
+// MCPToolHelpers.h
+// Gridex
+//
+// Inline helpers shared by every MCP tool implementation. Kept
+// header-only to avoid a separate TU for string conversion.
+
+#include <string>
+#include <windows.h>
+
+namespace DBModels { namespace MCPToolHelpers {
+
+inline std::string toUtf8(const std::wstring& w)
+{
+ if (w.empty()) return {};
+ int sz = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(),
+ nullptr, 0, nullptr, nullptr);
+ std::string out(sz, '\0');
+ WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(), &out[0], sz, nullptr, nullptr);
+ return out;
+}
+
+inline std::wstring fromUtf8(const std::string& s)
+{
+ if (s.empty()) return {};
+ int sz = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0);
+ std::wstring out(sz, L'\0');
+ MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &out[0], sz);
+ return out;
+}
+
+}} // namespace
diff --git a/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.cpp b/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.cpp
new file mode 100644
index 0000000..887376a
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.cpp
@@ -0,0 +1,38 @@
+//
+// MCPToolRegistry.cpp
+//
+
+#include "MCPToolRegistry.h"
+
+namespace DBModels
+{
+ MCPToolRegistry::MCPToolRegistry() = default;
+
+ void MCPToolRegistry::registerTool(std::shared_ptr<MCPTool> tool)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ if (tool) tools_[tool->name()] = std::move(tool);
+ }
+
+ void MCPToolRegistry::unregisterTool(const std::string& name)
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ tools_.erase(name);
+ }
+
+ std::shared_ptr<MCPTool> MCPToolRegistry::get(const std::string& name) const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ auto it = tools_.find(name);
+ return it != tools_.end() ? it->second : nullptr;
+ }
+
+ std::vector<MCPToolDefinition> MCPToolRegistry::definitions() const
+ {
+ std::lock_guard<std::mutex> lk(mtx_);
+ std::vector<MCPToolDefinition> out;
+ out.reserve(tools_.size());
+ for (const auto& [_, t] : tools_) out.push_back(t->definition());
+ return out;
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.h b/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.h
new file mode 100644
index 0000000..ad5de91
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.h
@@ -0,0 +1,37 @@
+#pragma once
+//
+// MCPToolRegistry.h
+// Gridex
+//
+// Name → MCPTool mapping, populated at MCPServer startup with
+// all 13 tools (6 schema / 3 read / 4 write). Mirrors
+// macos/Services/MCP/Tools/MCPToolRegistry.swift.
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <mutex>
+#include "MCPTool.h"
+
+namespace DBModels
+{
+ class MCPToolRegistry
+ {
+ public:
+ // Registers built-in tools (Phase 5 populates).
+ MCPToolRegistry();
+
+ void registerTool(std::shared_ptr<MCPTool> tool);
+ void unregisterTool(const std::string& name);
+
+ std::shared_ptr<MCPTool> get(const std::string& name) const;
+
+ // All tool definitions for tools/list response.
+ std::vector<MCPToolDefinition> definitions() const;
+
+ private:
+ mutable std::mutex mtx_;
+ std::unordered_map<std::string, std::shared_ptr<MCPTool>> tools_;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.cpp b/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.cpp
new file mode 100644
index 0000000..6b53c59
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.cpp
@@ -0,0 +1,86 @@
+//
+// DescribeTableTool.cpp
+//
+
+#include "DescribeTableTool.h"
+#include "../MCPToolHelpers.h"
+#include "../../Security/MCPIdentifierValidator.h"
+
+namespace DBModels
+{
+ MCPToolResult DescribeTableTool::execute(const nlohmann::json& params, MCPToolContext& ctx)
+ {
+ const auto connId = MCPTool::extractConnectionId(params);
+
+ const auto perm = ctx.checkPermission(tier(), connId);
+ if (const auto* msg = perm.errorMessage())
+ throw MCPToolError::permissionDenied(*msg);
+
+ auto ts = MCPIdentifierValidator::extractTableAndSchema(params);
+
+ const std::wstring table = MCPToolHelpers::fromUtf8(ts.table);
+ const std::wstring schema = ts.schema.has_value()
+ ? MCPToolHelpers::fromUtf8(*ts.schema) : std::wstring{};
+
+ auto [adapter, config] = ctx.getAdapter(connId);
+
+ auto columns = adapter->describeTable(table, schema);
+ auto indexes = adapter->listIndexes(table, schema);
+ auto foreignKeys= adapter->listForeignKeys(table, schema);
+
+ nlohmann::json result;
+ result["name"] = ts.table;
+ if (!schema.empty()) result["schema"] = *ts.schema;
+ result["database_type"] = MCPToolHelpers::toUtf8(
+ DatabaseTypeDisplayName(config.databaseType));
+
+ nlohmann::json cols = nlohmann::json::array();
+ nlohmann::json pkCols = nlohmann::json::array();
+ for (const auto& c : columns)
+ {
+ nlohmann::json cj = {
+ {"name", MCPToolHelpers::toUtf8(c.name)},
+ {"type", MCPToolHelpers::toUtf8(c.dataType)},
+ {"nullable", c.nullable}
+ };
+ if (c.isPrimaryKey) { cj["primary_key"] = true; pkCols.push_back(MCPToolHelpers::toUtf8(c.name)); }
+ if (!c.defaultValue.empty()) cj["default"] = MCPToolHelpers::toUtf8(c.defaultValue);
+ if (!c.comment.empty()) cj["comment"] = MCPToolHelpers::toUtf8(c.comment);
+ cols.push_back(std::move(cj));
+ }
+ result["columns"] = std::move(cols);
+ if (!pkCols.empty()) result["primary_key"] = std::move(pkCols);
+
+ if (!indexes.empty())
+ {
+ nlohmann::json idxs = nlohmann::json::array();
+ for (const auto& i : indexes)
+ {
+ idxs.push_back({
+ {"name", MCPToolHelpers::toUtf8(i.name)},
+ {"columns", MCPToolHelpers::toUtf8(i.columns)},
+ {"unique", i.isUnique},
+ {"type", MCPToolHelpers::toUtf8(i.algorithm.empty() ? L"btree" : i.algorithm)}
+ });
+ }
+ result["indexes"] = std::move(idxs);
+ }
+
+ if (!foreignKeys.empty())
+ {
+ nlohmann::json fks = nlohmann::json::array();
+ for (const auto& f : foreignKeys)
+ {
+ fks.push_back({
+ {"name", MCPToolHelpers::toUtf8(f.name)},
+ {"column", MCPToolHelpers::toUtf8(f.column)},
+ {"references_table", MCPToolHelpers::toUtf8(f.referencedTable)},
+ {"references_column", MCPToolHelpers::toUtf8(f.referencedColumn)}
+ });
+ }
+ result["foreign_keys"] = std::move(fks);
+ }
+
+ return MCPToolResult::text(result.dump(2));
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.h b/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.h
new file mode 100644
index 0000000..a6d69ed
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/DescribeTableTool.h
@@ -0,0 +1,38 @@
+#pragma once
+//
+// DescribeTableTool.h
+// Gridex
+//
+// Detailed table structure: columns, PK, FKs, indexes. Mirrors
+// macos DescribeTableTool.swift.
+
+#include "../MCPTool.h"
+
+namespace DBModels
+{
+ class DescribeTableTool : public MCPTool
+ {
+ public:
+ std::string name() const override { return "describe_table"; }
+ std::string description() const override
+ {
+ return "Get detailed structure of a table including columns, data "
+ "types, indexes, primary keys, foreign keys, and constraints.";
+ }
+ MCPPermissionTier tier() const override { return MCPPermissionTier::Schema; }
+ nlohmann::json inputSchema() const override
+ {
+ return {
+ {"type", "object"},
+ {"properties", {
+ {"connection_id", {{"type", "string"}, {"description", "Connection identifier"}}},
+ {"table_name", {{"type", "string"}, {"description", "Name of the table to describe"}}},
+ {"schema", {{"type", "string"}, {"description", "Optional schema name"}}}
+ }},
+ {"required", {"connection_id", "table_name"}}
+ };
+ }
+ MCPToolResult execute(const nlohmann::json& params,
+ MCPToolContext& ctx) override;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.cpp b/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.cpp
new file mode 100644
index 0000000..33f394b
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.cpp
@@ -0,0 +1,40 @@
+//
+// ListConnectionsTool.cpp
+//
+
+#include "ListConnectionsTool.h"
+#include "../MCPToolHelpers.h"
+#include "../../../../Models/ConnectionStore.h"
+
+namespace DBModels
+{
+ MCPToolResult ListConnectionsTool::execute(const nlohmann::json&, MCPToolContext& ctx)
+ {
+ const auto configs = ConnectionStore::Load();
+ nlohmann::json arr = nlohmann::json::array();
+
+ for (const auto& c : configs)
+ {
+ // Hide Locked rows entirely — mac parity.
+ const auto mode = ctx.permissionEngine.getMode(c.id);
+ if (mode == MCPConnectionMode::Locked) continue;
+
+ nlohmann::json entry = {
+ {"id", MCPToolHelpers::toUtf8(c.id)},
+ {"name", MCPToolHelpers::toUtf8(c.name)},
+ {"type", MCPToolHelpers::toUtf8(DatabaseTypeDisplayName(c.databaseType))},
+ {"host", MCPToolHelpers::toUtf8(c.host)},
+ {"database", MCPToolHelpers::toUtf8(c.database)},
+ {"mcp_mode", mcpRawString(mode)}
+ };
+ arr.push_back(std::move(entry));
+ }
+
+ if (arr.empty())
+ return MCPToolResult::text(
+ "No connections available for MCP access. All connections are "
+ "either locked or none exist.");
+
+ return MCPToolResult::text(arr.dump(2));
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.h b/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.h
new file mode 100644
index 0000000..ec23971
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/ListConnectionsTool.h
@@ -0,0 +1,34 @@
+#pragma once
+//
+// ListConnectionsTool.h
+// Gridex
+//
+// Returns every non-Locked connection visible to the AI client.
+// Mirrors macos Tier1/ListConnectionsTool.swift.
+
+#include "../MCPTool.h"
+
+namespace DBModels
+{
+ class ListConnectionsTool : public MCPTool
+ {
+ public:
+ std::string name() const override { return "list_connections"; }
+ std::string description() const override
+ {
+ return "List all configured database connections that MCP can access. "
+ "Locked connections are omitted. Returns id, name, type, host, "
+ "and per-connection mcp_mode.";
+ }
+ MCPPermissionTier tier() const override { return MCPPermissionTier::Schema; }
+ nlohmann::json inputSchema() const override
+ {
+ return {
+ {"type", "object"},
+ {"properties", nlohmann::json::object()}
+ };
+ }
+ MCPToolResult execute(const nlohmann::json& params,
+ MCPToolContext& ctx) override;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.cpp b/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.cpp
new file mode 100644
index 0000000..ec46903
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.cpp
@@ -0,0 +1,49 @@
+//
+// ListTablesTool.cpp
+//
+
+#include "ListTablesTool.h"
+#include "../MCPToolHelpers.h"
+
+namespace DBModels
+{
+ MCPToolResult ListTablesTool::execute(const nlohmann::json& params, MCPToolContext& ctx)
+ {
+ const auto connId = MCPTool::extractConnectionId(params);
+
+ const auto perm = ctx.checkPermission(tier(), connId);
+ if (const auto* msg = perm.errorMessage())
+ throw MCPToolError::permissionDenied(*msg);
+
+ std::wstring schema;
+ if (params.contains("schema") && params["schema"].is_string())
+ schema = MCPToolHelpers::fromUtf8(params["schema"].get<std::string>());
+
+ auto [adapter, config] = ctx.getAdapter(connId);
+ auto tables = adapter->listTables(schema);
+
+ nlohmann::json arr = nlohmann::json::array();
+ for (const auto& t : tables)
+ {
+ nlohmann::json e = {
+ {"name", MCPToolHelpers::toUtf8(t.name)},
+ {"type", MCPToolHelpers::toUtf8(t.type.empty() ? L"table" : t.type)}
+ };
+ if (!t.schema.empty())
+ e["schema"] = MCPToolHelpers::toUtf8(t.schema);
+ if (t.estimatedRows > 0)
+ e["estimated_rows"] = t.estimatedRows;
+ arr.push_back(std::move(e));
+ }
+
+ if (arr.empty())
+ {
+ std::string suffix = schema.empty()
+ ? ""
+ : " in schema '" + MCPToolHelpers::toUtf8(schema) + "'";
+ return MCPToolResult::text("No tables found" + suffix + ".");
+ }
+ return MCPToolResult::text(
+ "Found " + std::to_string(arr.size()) + " table(s):\n" + arr.dump(2));
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.h b/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.h
new file mode 100644
index 0000000..d4aa5f5
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier1/ListTablesTool.h
@@ -0,0 +1,37 @@
+#pragma once
+//
+// ListTablesTool.h
+// Gridex
+//
+// List tables in a connection's specified schema (or all schemas if
+// omitted). Mirrors macos ListTablesTool.swift.
+
+#include "../MCPTool.h"
+
+namespace DBModels
+{
+ class ListTablesTool : public MCPTool
+ {
+ public:
+ std::string name() const override { return "list_tables"; }
+ std::string description() const override
+ {
+ return "List all tables in a database connection. Returns table "
+ "names, schemas, and approximate row counts.";
+ }
+ MCPPermissionTier tier() const override { return MCPPermissionTier::Schema; }
+ nlohmann::json inputSchema() const override
+ {
+ return {
+ {"type", "object"},
+ {"properties", {
+ {"connection_id", {{"type", "string"}, {"description", "Connection identifier"}}},
+ {"schema", {{"type", "string"}, {"description", "Optional schema/database filter"}}}
+ }},
+ {"required", {"connection_id"}}
+ };
+ }
+ MCPToolResult execute(const nlohmann::json& params,
+ MCPToolContext& ctx) override;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.cpp b/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.cpp
new file mode 100644
index 0000000..819c5aa
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.cpp
@@ -0,0 +1,116 @@
+//
+// QueryTool.cpp
+//
+
+#include "QueryTool.h"
+#include "../MCPToolHelpers.h"
+#include <algorithm>
+
+namespace DBModels
+{
+ static bool isSQLType(DatabaseType t)
+ {
+ return t == DatabaseType::PostgreSQL ||
+ t == DatabaseType::MySQL ||
+ t == DatabaseType::SQLite ||
+ t == DatabaseType::MSSQLServer;
+ }
+
+ MCPToolResult QueryTool::execute(const nlohmann::json& params, MCPToolContext& ctx)
+ {
+ const auto connId = MCPTool::extractConnectionId(params);
+
+ if (!params.contains("sql") || !params["sql"].is_string())
+ throw MCPToolError::invalidParameters("sql is required");
+ const std::string sqlUtf8 = params["sql"].get<std::string>();
+
+ int rowLimit = 1000;
+ if (params.contains("row_limit") && params["row_limit"].is_number_integer())
+ rowLimit = std::clamp(params["row_limit"].get<int>(), 1, 10000);
+
+ // Base permission.
+ const auto perm = ctx.checkPermission(tier(), connId);
+ if (const auto* msg = perm.errorMessage())
+ throw MCPToolError::permissionDenied(*msg);
+
+ // Read-only SELECT check if mode == ReadOnly.
+ const auto mode = ctx.permissionEngine.getMode(connId);
+ if (mode == MCPConnectionMode::ReadOnly)
+ {
+ auto v = ctx.permissionEngine.validateReadOnlyQuery(sqlUtf8);
+ if (const auto* m = v.errorMessage())
+ throw MCPToolError::permissionDenied(*m);
+ }
+
+ auto [adapter, config] = ctx.getAdapter(connId);
+
+ // Append LIMIT if absent and target is SQL. Keep the raw
+ // sql untouched otherwise (Redis/Mongo adapters carry their
+ // own shape).
+ std::wstring sqlW = MCPToolHelpers::fromUtf8(sqlUtf8);
+ if (isSQLType(config.databaseType))
+ {
+ std::wstring upper = sqlW;
+ std::transform(upper.begin(), upper.end(), upper.begin(), ::towupper);
+ if (upper.find(L"LIMIT") == std::wstring::npos)
+ {
+ std::wstring trimmed = sqlW;
+ while (!trimmed.empty() && (trimmed.back() == L' ' ||
+ trimmed.back() == L';' || trimmed.back() == L'\n'))
+ trimmed.pop_back();
+ sqlW = trimmed + L" LIMIT " + std::to_wstring(rowLimit);
+ }
+ }
+
+ QueryResult r;
+ try { r = adapter->execute(sqlW); }
+ catch (const std::exception& e)
+ { throw MCPToolError::queryFailed(e.what()); }
+
+ if (!r.success)
+ throw MCPToolError::queryFailed(MCPToolHelpers::toUtf8(r.error));
+
+ nlohmann::json response;
+ response["success"] = true;
+ response["row_count"] = static_cast<int>(r.rows.size());
+ response["execution_time_ms"] = static_cast<int>(r.executionTimeMs);
+
+ nlohmann::json cols = nlohmann::json::array();
+ for (size_t i = 0; i < r.columnNames.size(); ++i)
+ {
+ nlohmann::json c{
+ {"name", MCPToolHelpers::toUtf8(r.columnNames[i])}
+ };
+ if (i < r.columnTypes.size())
+ c["type"] = MCPToolHelpers::toUtf8(r.columnTypes[i]);
+ cols.push_back(std::move(c));
+ }
+ response["columns"] = std::move(cols);
+
+ nlohmann::json rows = nlohmann::json::array();
+ // Parenthesize to defeat windows.h `min` macro in consumers.
+ const int cap = (std::min)(static_cast<int>(r.rows.size()), rowLimit);
+ for (int i = 0; i < cap; ++i)
+ {
+ nlohmann::json rj = nlohmann::json::object();
+ for (const auto& cname : r.columnNames)
+ {
+ auto it = r.rows[i].find(cname);
+ const std::wstring v = (it != r.rows[i].end()) ? it->second : L"";
+ rj[MCPToolHelpers::toUtf8(cname)] =
+ isNullCell(v) ? nlohmann::json(nullptr)
+ : nlohmann::json(MCPToolHelpers::toUtf8(v));
+ }
+ rows.push_back(std::move(rj));
+ }
+ response["rows"] = std::move(rows);
+
+ if (static_cast<int>(r.rows.size()) > rowLimit)
+ {
+ response["truncated"] = true;
+ response["message"] = "Results truncated to " + std::to_string(rowLimit) + " rows";
+ }
+
+ return MCPToolResult::text(response.dump(2));
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.h b/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.h
new file mode 100644
index 0000000..f0bb4dd
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Tools/Tier2/QueryTool.h
@@ -0,0 +1,44 @@
+#pragma once
+//
+// QueryTool.h
+// Gridex
+//
+// Execute a SQL query. In read-only mode, only SELECT is allowed —
+// enforced via MCPPermissionEngine::validateReadOnlyQuery. Mirrors
+// macos Tier2/QueryTool.swift.
+
+#include "../MCPTool.h"
+
+namespace DBModels
+{
+ class QueryTool : public MCPTool
+ {
+ public:
+ std::string name() const override { return "query"; }
+ std::string description() const override
+ {
+ return "Execute a SQL query. In read-only mode, only SELECT statements "
+ "are allowed. Returns rows with metadata (column types, row "
+ "count, execution time).";
+ }
+ MCPPermissionTier tier() const override { return MCPPermissionTier::Read; }
+ nlohmann::json inputSchema() const override
+ {
+ return {
+ {"type", "object"},
+ {"properties", {
+ {"connection_id", {{"type", "string"}, {"description", "Connection identifier"}}},
+ {"sql", {{"type", "string"}, {"description", "SQL query to execute"}}},
+ {"row_limit", {
+ {"type", "integer"},
+ {"description", "Maximum rows to return (default 1000, max 10000)"},
+ {"default", 1000}, {"maximum", 10000}
+ }}
+ }},
+ {"required", {"connection_id", "sql"}}
+ };
+ }
+ MCPToolResult execute(const nlohmann::json& params,
+ MCPToolContext& ctx) override;
+ };
+}
diff --git a/windows/Gridex/Services/MCP/Transport/StdioTransport.cpp b/windows/Gridex/Services/MCP/Transport/StdioTransport.cpp
new file mode 100644
index 0000000..174cddc
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Transport/StdioTransport.cpp
@@ -0,0 +1,93 @@
+//
+// StdioTransport.cpp
+//
+// Reading:
+// stdin is assumed to carry one JSON object per line (MCP
+// newline-delimited framing). Empty lines are skipped. Malformed
+// JSON triggers a parseError response with id=null.
+//
+// Writing:
+// A single mutex serializes stdout writes; flush after every
+// line so the client sees responses immediately.
+//
+// Threading:
+// Reader runs on a dedicated std::thread. The caller's
+// RequestHandler is invoked synchronously from that thread —
+// long-running handlers should dispatch to a worker pool to
+// avoid stalling the read loop.
+
+#include "StdioTransport.h"
+#include <iostream>
+#include <string>
+
+namespace DBModels
+{
+ StdioTransport::~StdioTransport()
+ {
+ stop();
+ if (reader_.joinable()) reader_.join();
+ }
+
+ void StdioTransport::start()
+ {
+ if (running_.exchange(true)) return;
+ reader_ = std::thread([this]() { readLoop(); });
+ }
+
+ void StdioTransport::stop()
+ {
+ running_.store(false);
+ }
+
+ void StdioTransport::readLoop()
+ {
+ std::string line;
+ while (running_.load() && std::getline(std::cin, line))
+ {
+ if (line.empty()) continue;
+ if (!line.empty() && line.back() == '\r') line.pop_back();
+
+ try
+ {
+ auto j = nlohmann::json::parse(line);
+ JSONRPCRequest req;
+ from_json(j, req);
+ if (handler_) handler_(req);
+ }
+ catch (const std::exception&)
+ {
+ // Parse error → reply with null id + -32700 per spec.
+ auto resp = JSONRPCResponse::fail(nullptr, JSONRPCError::parseError());
+ send(resp);
+ }
+ }
+ running_.store(false);
+ }
+
+ void StdioTransport::send(const JSONRPCResponse& response)
+ {
+ nlohmann::json j;
+ to_json(j, response);
+ const std::string line = j.dump() + "\n";
+
+ std::lock_guard<std::mutex> lk(writeMtx_);
+ std::cout.write(line.data(), static_cast<std::streamsize>(line.size()));
+ std::cout.flush();
+ }
+
+ void StdioTransport::sendNotification(const std::string& method,
+ const nlohmann::json& params)
+ {
+ JSONRPCRequest notif;
+ notif.method = method;
+ notif.params = params;
+ // notifications have no `id`.
+ nlohmann::json j;
+ to_json(j, notif);
+ const std::string line = j.dump() + "\n";
+
+ std::lock_guard<std::mutex> lk(writeMtx_);
+ std::cout.write(line.data(), static_cast<std::streamsize>(line.size()));
+ std::cout.flush();
+ }
+}
diff --git a/windows/Gridex/Services/MCP/Transport/StdioTransport.h b/windows/Gridex/Services/MCP/Transport/StdioTransport.h
new file mode 100644
index 0000000..1398c0a
--- /dev/null
+++ b/windows/Gridex/Services/MCP/Transport/StdioTransport.h
@@ -0,0 +1,59 @@
+#pragma once
+//
+// StdioTransport.h
+// Gridex
+//
+// Newline-delimited JSON-RPC over stdin/stdout for the
+// `--mcp-stdio` CLI mode. One request per line. Mirrors
+// macos/Services/MCP/Transport/StdioTransport.swift.
+//
+// Reads on a dedicated background thread and dispatches parsed
+// requests via a callback. Writes are serialized on a separate
+// mutex — call send() from any thread.
+
+#include <string>
+#include <atomic>
+#include <thread>
+#include <mutex>
+#include <functional>
+#include "../../../Models/MCP/MCPProtocol.h"
+
+namespace DBModels
+{
+ class StdioTransport
+ {
+ public:
+ // Callback invoked for each valid JSON-RPC request. Runs on
+ // the reader thread; the implementation is expected to
+ // handle its own synchronization (or dispatch to a worker).
+ using RequestHandler = std::function<void(const JSONRPCRequest&)>;
+
+ StdioTransport() = default;
+ ~StdioTransport();
+
+ void setRequestHandler(RequestHandler h) { handler_ = std::move(h); }
+
+ // Starts the reader thread. Returns immediately.
+ void start();
+
+ // Signals the reader to stop. The process exits naturally
+ // when stdin closes (EOF) so this is mainly for shutdown.
+ void stop();
+
+ // Thread-safe. Writes one JSON-RPC response + trailing
+ // newline to stdout and flushes.
+ void send(const JSONRPCResponse& response);
+
+ // Push a JSON-RPC notification (id=null) — e.g. progress.
+ void sendNotification(const std::string& method,
+ const nlohmann::json& params);
+
+ private:
+ std::atomic<bool> running_{false};
+ std::thread reader_;
+ std::mutex writeMtx_;
+ RequestHandler handler_;
+
+ void readLoop();
+ };
+}