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++
9.9 KB
Raw Blame
#pragma once

// MCP (Model Context Protocol) JSON-RPC 2.0 types + audit entry.
// Uses nlohmann::json for dynamic JSON (replaces Swift's hand-rolled JSONValue enum).

#include <chrono>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

#include <nlohmann/json.hpp>

#include "Core/Enums/DatabaseType.h"
#include "Core/Enums/MCPConnectionMode.h"
#include "Core/Enums/MCPPermissionTier.h"

namespace gridex::mcp {

using nlohmann::json;

// JSON-RPC 2.0 error codes
struct JSONRPCError {
    int code = 0;
    std::string message;
    std::optional<json> data;

    json toJson() const {
        json j = {{"code", code}, {"message", message}};
        if (data) j["data"] = *data;
        return j;
    }

    static JSONRPCError parseError()      { return {-32700, "Parse error",      std::nullopt}; }
    static JSONRPCError invalidRequest()  { return {-32600, "Invalid Request",  std::nullopt}; }
    static JSONRPCError methodNotFound()  { return {-32601, "Method not found", std::nullopt}; }
    static JSONRPCError invalidParams()   { return {-32602, "Invalid params",   std::nullopt}; }
    static JSONRPCError internalError()   { return {-32603, "Internal error",   std::nullopt}; }
};

// MCP-specific JSON-RPC error codes (negative, per spec "reserved for server use")
enum class MCPErrorCode : int {
    PermissionDenied   = -32001,
    ApprovalTimeout    = -32002,
    ApprovalDenied     = -32003,
    ConnectionError    = -32004,
    SyntaxError        = -32005,
    NotFound           = -32006,
    RateLimitExceeded  = -32007,
    ScopeDenied        = -32008,
    QueryTimeout       = -32009,
};

// JSON-RPC request. id may be a string, int, or absent (notification).
struct JSONRPCRequest {
    json id;              // null if notification
    std::string method;
    json params;          // object or null

    static JSONRPCRequest fromJson(const json& j) {
        JSONRPCRequest r;
        if (j.contains("id"))     r.id = j["id"];
        if (j.contains("method")) r.method = j.value("method", "");
        if (j.contains("params")) r.params = j["params"];
        return r;
    }
};

// JSON-RPC response.
struct JSONRPCResponse {
    json id;                              // echoes request id
    std::optional<json> result;
    std::optional<JSONRPCError> error;

    static JSONRPCResponse ok(const json& id, json result) {
        JSONRPCResponse r;
        r.id = id;
        r.result = std::move(result);
        return r;
    }

    static JSONRPCResponse err(const json& id, JSONRPCError error) {
        JSONRPCResponse r;
        r.id = id;
        r.error = std::move(error);
        return r;
    }

    json toJson() const {
        json j = {{"jsonrpc", "2.0"}};
        j["id"] = id;  // may be null
        if (result)    j["result"] = *result;
        else if (error) j["error"] = error->toJson();
        return j;
    }
};

// MCP tool content block (as returned from tools/call).
struct MCPContent {
    std::string type = "text";
    std::optional<std::string> text;
    std::optional<std::string> data;       // base64 for images
    std::optional<std::string> mimeType;

    json toJson() const {
        json j = {{"type", type}};
        if (text)     j["text"]     = *text;
        if (data)     j["data"]     = *data;
        if (mimeType) j["mimeType"] = *mimeType;
        return j;
    }
};

// MCP tool execution result.
struct MCPToolResult {
    std::vector<MCPContent> content;
    bool isError = false;

    static MCPToolResult textResult(std::string text, bool err = false) {
        MCPToolResult r;
        MCPContent c;
        c.type = "text";
        c.text = std::move(text);
        r.content.push_back(std::move(c));
        r.isError = err;
        return r;
    }

    static MCPToolResult errorResult(std::string msg) {
        return textResult(std::move(msg), true);
    }

    json toJson() const {
        json arr = json::array();
        for (const auto& c : content) arr.push_back(c.toJson());
        json j = {{"content", arr}};
        if (isError) j["isError"] = true;
        return j;
    }
};

// MCP tool static definition (advertised via tools/list).
struct MCPToolDefinition {
    std::string name;
    std::string description;
    json inputSchema;       // JSON Schema object

    json toJson() const {
        return {{"name", name}, {"description", description}, {"inputSchema", inputSchema}};
    }
};

// MCP client handshake info (learned during initialize).
struct MCPClientInfo {
    std::string name    = "unknown";
    std::string version = "0.0.0";
};

// Audit record written to JSONL log.

enum class MCPAuditStatus { Success, Error, Denied, Timeout };

inline std::string toString(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 "error";
}

struct MCPAuditClient {
    std::string name      = "unknown";
    std::string version   = "0.0.0";
    std::string transport = "stdio";
};

struct MCPAuditInput {
    std::optional<std::string> sqlPreview;
    std::optional<int>         paramsCount;
    std::optional<std::string> inputHash;

    static MCPAuditInput fromSql(const std::optional<std::string>& sql, std::optional<int> pc) {
        MCPAuditInput i;
        i.paramsCount = pc;
        if (sql) {
            const auto& s = *sql;
            i.sqlPreview = s.size() > 200 ? (s.substr(0, 200) + "...") : s;
            i.inputHash  = "sha256:" + std::to_string(std::hash<std::string>{}(s));
        }
        return i;
    }
};

struct MCPAuditResult {
    MCPAuditStatus status = MCPAuditStatus::Success;
    std::optional<int> rowsAffected;
    std::optional<int> rowsReturned;
    int durationMs = 0;
    std::optional<int> bytesReturned;
};

struct MCPAuditSecurity {
    MCPConnectionMode mode = MCPConnectionMode::Locked;
    std::optional<bool> userApproved;
    std::optional<std::string> approvalSessionId;
    std::optional<std::vector<std::string>> scopesApplied;
};

struct MCPAuditEntry {
    std::string timestampIso8601;
    std::string eventId;
    MCPAuditClient client;
    std::string tool;
    int tier = 1;
    std::optional<std::string> connectionId;    // UUID string
    std::optional<std::string> connectionType;  // db type raw
    MCPAuditInput input;
    MCPAuditResult result;
    MCPAuditSecurity security;
    std::optional<std::string> error;

    json toJson() const {
        json clientJ = {{"name", client.name}, {"version", client.version}, {"transport", client.transport}};

        json inputJ = json::object();
        if (input.sqlPreview)  inputJ["sqlPreview"] = *input.sqlPreview;
        if (input.paramsCount) inputJ["paramsCount"] = *input.paramsCount;
        if (input.inputHash)   inputJ["inputHash"] = *input.inputHash;

        json resultJ = {{"status", toString(result.status)}, {"durationMs", result.durationMs}};
        if (result.rowsAffected)  resultJ["rowsAffected"]  = *result.rowsAffected;
        if (result.rowsReturned)  resultJ["rowsReturned"]  = *result.rowsReturned;
        if (result.bytesReturned) resultJ["bytesReturned"] = *result.bytesReturned;

        json securityJ = {{"permissionMode", std::string(rawValue(security.mode))}};
        if (security.userApproved)      securityJ["userApproved"]      = *security.userApproved;
        if (security.approvalSessionId) securityJ["approvalSessionId"] = *security.approvalSessionId;
        if (security.scopesApplied)     securityJ["scopesApplied"]     = *security.scopesApplied;

        json j = {
            {"timestamp", timestampIso8601},
            {"eventId",   eventId},
            {"client",    clientJ},
            {"tool",      tool},
            {"tier",      tier},
            {"input",     inputJ},
            {"result",    resultJ},
            {"security",  securityJ},
        };
        if (connectionId)   j["connectionId"]   = *connectionId;
        if (connectionType) j["connectionType"] = *connectionType;
        if (error)          j["error"]          = *error;
        return j;
    }

    static std::optional<MCPAuditEntry> fromJson(const json& j);
};

// MCP tool error — thrown from inside tool.execute() to be caught by MCPServer.
class MCPToolError : public std::runtime_error {
public:
    enum class Kind {
        ConnectionNotFound,
        ConnectionNotConnected,
        TableNotFound,
        InvalidParameters,
        PermissionDenied,
        QueryFailed,
        RateLimitExceeded,
    };

    MCPToolError(Kind k, std::string message, int retryAfter = 0)
        : std::runtime_error(std::move(message)), kind_(k), retryAfter_(retryAfter) {}

    Kind kind() const noexcept { return kind_; }
    int retryAfterSeconds() const noexcept { return retryAfter_; }

    static MCPToolError invalidParameters(std::string msg) {
        return {Kind::InvalidParameters, "Invalid parameters: " + msg};
    }
    static MCPToolError connectionNotFound(const std::string& id) {
        return {Kind::ConnectionNotFound,
                "Connection '" + id + "' not found. Use list_connections to see available connections."};
    }
    static MCPToolError connectionNotConnected(const std::string& id) {
        return {Kind::ConnectionNotConnected,
                "Connection '" + id + "' is not active. The user needs to connect first."};
    }
    static MCPToolError tableNotFound(const std::string& name) {
        return {Kind::TableNotFound, "Table '" + name + "' not found."};
    }
    static MCPToolError permissionDenied(std::string msg) {
        return {Kind::PermissionDenied, std::move(msg)};
    }
    static MCPToolError queryFailed(const std::string& msg) {
        return {Kind::QueryFailed, "Query failed: " + msg};
    }
    static MCPToolError rateLimitExceeded(int retryAfter) {
        return {Kind::RateLimitExceeded,
                "Rate limit exceeded. Retry after " + std::to_string(retryAfter) + " seconds.",
                retryAfter};
    }

private:
    Kind kind_;
    int retryAfter_ = 0;
};

}  // namespace gridex::mcp