Skip to content

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

C++
5.2 KB
Raw Blame
#include "Services/MCP/Security/SQLSanitizer.h"
#include "Services/MCP/Tools/MCPTool.h"
#include "Services/MCP/Tools/ToolHelpers.h"

namespace gridex::mcp {

namespace {

bool containsWordUpper(const std::string& s, std::string_view word) {
    auto isWord = [](unsigned char c) { return std::isalnum(c) || c == '_'; };
    const std::size_t n = s.size(), m = word.size();
    for (std::size_t i = 0; i + m <= n; ++i) {
        if (i > 0 && isWord(static_cast<unsigned char>(s[i - 1]))) continue;
        if (i + m < n && isWord(static_cast<unsigned char>(s[i + m]))) continue;
        bool eq = true;
        for (std::size_t k = 0; k < m; ++k) {
            if (s[i + k] != word[k]) { eq = false; break; }
        }
        if (eq) return true;
    }
    return false;
}

class ExecuteWriteQueryTool final : public MCPTool {
public:
    std::string name() const override { return "execute_write_query"; }
    std::string description() const override {
        return "Execute one write SQL statement (INSERT/UPDATE/DELETE). Requires user approval. "
               "Only available in read-write mode. Multi-statement input is rejected.";
    }
    // Tier::Ddl because this is the broadest write tool and hits rate-limit bucket accordingly.
    MCPPermissionTier tier() const override { return MCPPermissionTier::Ddl; }

    nlohmann::json inputSchema() const override {
        return {
            {"type", "object"},
            {"properties", {
                {"connection_id", {{"type", "string"}, {"description", "Connection identifier"}}},
                {"sql",           {{"type", "string"}, {"description", "A single SQL statement. Required unless 'query' is provided"}}},
                {"query",         {{"type", "string"}, {"description", "A single SQL statement (alias for 'sql')"}}},
                {"params",        {{"type", "array"},  {"description", "Parameters for placeholders"}}},
            }},
            {"required", nlohmann::json::array({"connection_id"})},
        };
    }

    MCPToolResult execute(const nlohmann::json& params, const MCPToolContext& ctx) override {
        const std::string connectionId = MCPTool::extractConnectionId(params);
        std::string sql;
        if (params.contains("sql") && params["sql"].is_string()) {
            sql = params["sql"].get<std::string>();
        } else if (params.contains("query") && params["query"].is_string()) {
            sql = params["query"].get<std::string>();
        } else {
            throw MCPToolError::invalidParameters("sql is required");
        }

        const std::string codeOnly = stripCommentsAndStrings(sql);
        std::string upper = toUpperAscii(trimSpaces(codeOnly));

        std::string noSemi = upper;
        if (!noSemi.empty() && noSemi.back() == ';') noSemi.pop_back();
        noSemi = trimSpaces(noSemi);
        if (noSemi.find(';') != std::string::npos) {
            throw MCPToolError::invalidParameters(
                "Multiple statements are not allowed. Send one statement at a time.");
        }

        auto perm = ctx.checkPermission(tier(), connectionId);
        if (perm.kind() == PermissionResult::Kind::Denied) {
            throw MCPToolError::permissionDenied(perm.errorMessage());
        }

        if (startsWith(upper, "SELECT") || startsWith(upper, "WITH")) {
            throw MCPToolError::invalidParameters(
                "Use the 'query' tool for SELECT / WITH statements. This tool is for write operations only.");
        }

        if (startsWith(upper, "UPDATE") || startsWith(upper, "DELETE")) {
            if (!containsWordUpper(upper, "WHERE")) {
                throw MCPToolError::permissionDenied(
                    "UPDATE/DELETE without WHERE clause is not allowed.");
            }
            auto pos = upper.find("WHERE");
            if (pos != std::string::npos) {
                std::string whereClause = trimSpaces(codeOnly.substr(pos + 5));
                auto wr = ctx.permissionEngine->validateWhereClause(whereClause);
                if (wr.kind() == PermissionResult::Kind::Denied) {
                    throw MCPToolError::permissionDenied(wr.errorMessage());
                }
            }
        }

        auto [adapter, config] = ctx.getAdapter(connectionId);

        if (perm.requiresUserApproval()) {
            bool approved = ctx.requestApproval(
                name(), "Execute write query", "SQL:\n" + sql, connectionId);
            if (!approved) throw MCPToolError::permissionDenied("User denied the operation.");
        }

        std::vector<RowValue> rowParams;
        if (params.contains("params") && params["params"].is_array()) {
            for (const auto& p : params["params"]) rowParams.push_back(jsonToRowValue(p));
        }

        QueryResult result = rowParams.empty()
            ? adapter->executeRaw(sql)
            : adapter->executeWithRowValues(sql, rowParams);

        ctx.recordUsage(tier(), connectionId);

        std::string msg = "Query executed successfully.";
        if (result.rowsAffected > 0) {
            msg += " " + std::to_string(result.rowsAffected) + " row(s) affected.";
        }
        return MCPToolResult::textResult(msg);
    }
};

}  // namespace

std::shared_ptr<MCPTool> makeExecuteWriteQueryTool() {
    return std::make_shared<ExecuteWriteQueryTool>();
}

}  // namespace gridex::mcp