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.cppindex 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.cppindex 1e9fcdb..80e9e99 100644--- a/windows/Gridex/AppSettings.cpp+++ b/windows/Gridex/AppSettings.cpp@@ -326,6 +326,41 @@ namespace DBModelss.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 DBModelsif (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.propsindex 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.cppindex 834c7cb..1ba1a67 100644--- a/windows/Gridex/HomePage.cpp+++ b/windows/Gridex/HomePage.cpp@@ -467,6 +467,29 @@ namespace winrt::Gridex::implementationframe.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.hindex befa32f..072b6f8 100644--- a/windows/Gridex/HomePage.h+++ b/windows/Gridex/HomePage.h@@ -20,6 +20,9 @@ namespace winrt::Gridex::implementationvoid 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.xamlindex 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="" 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.idlnew file mode 100644index 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.xamlnew file mode 100644index 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="" 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=""+ 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="" 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="" 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.hindex 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.hindex 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 DBModelsstd::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.hindex 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 DBModelsc.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 DBModelssqlite3_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 DBModelssqlite3_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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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();+ }+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/MCPServerHost.h b/windows/Gridex/Services/MCP/MCPServerHost.hnew file mode 100644index 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();++}} // namespacediff --git a/windows/Gridex/Services/MCP/Security/MCPApprovalGate.cpp b/windows/Gridex/Services/MCP/Security/MCPApprovalGate.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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;+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.h b/windows/Gridex/Services/MCP/Security/MCPIdentifierValidator.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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;+ }+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.h b/windows/Gridex/Services/MCP/Security/MCPRowCountEstimator.hnew file mode 100644index 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.cppnew file mode 100644index 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;+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.h b/windows/Gridex/Services/MCP/Security/MCPSQLSanitizer.hnew file mode 100644index 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.cppnew file mode 100644index 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.+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.h b/windows/Gridex/Services/MCP/Tools/MCPBuiltinTools.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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;+}++}} // namespacediff --git a/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.cpp b/windows/Gridex/Services/MCP/Tools/MCPToolRegistry.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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();+ };+}