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++
#include "Services/MCP/Audit/AuditLogger.h"
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
namespace gridex::mcp {
namespace fs = std::filesystem;
namespace {
std::string xdgDataHome() {
if (const char* x = std::getenv("XDG_DATA_HOME"); x && *x) return x;
if (const char* h = std::getenv("HOME"); h && *h) return std::string(h) + "/.local/share";
return ".";
}
std::string isoTimestamp(std::chrono::system_clock::time_point tp, bool fileSafe = false) {
std::time_t t = std::chrono::system_clock::to_time_t(tp);
std::tm tm{};
gmtime_r(&t, &tm);
char buf[32];
if (fileSafe) {
std::strftime(buf, sizeof(buf), "%Y-%m-%dT%H-%M-%SZ", &tm);
} else {
std::strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%SZ", &tm);
}
return buf;
}
} // namespace
AuditLogger::AuditLogger() {
fs::path dir = fs::path(xdgDataHome()) / "gridex";
std::error_code ec;
fs::create_directories(dir, ec);
filePath_ = (dir / "mcp-audit.jsonl").string();
}
AuditLogger::~AuditLogger() { close(); }
void AuditLogger::ensureOpen() {
if (out_.is_open()) return;
out_.open(filePath_, std::ios::app);
}
void AuditLogger::rotateIfNeeded() {
std::error_code ec;
if (!fs::exists(filePath_, ec)) return;
auto size = fs::file_size(filePath_, ec);
if (ec || static_cast<std::int64_t>(size) < maxFileSize_) return;
if (out_.is_open()) out_.close();
std::string stamp = isoTimestamp(std::chrono::system_clock::now(), true);
fs::path src(filePath_);
fs::path dst = src.parent_path() / ("mcp-audit-" + stamp + ".jsonl");
fs::rename(src, dst, ec);
}
void AuditLogger::log(const MCPAuditEntry& entry) {
std::lock_guard lk(mu_);
try {
rotateIfNeeded();
ensureOpen();
if (!out_.is_open()) return;
out_ << entry.toJson().dump() << '\n';
out_.flush();
} catch (const std::exception& e) {
std::cerr << "[MCP Audit] Failed to log entry: " << e.what() << '\n';
}
}
std::vector<MCPAuditEntry> AuditLogger::recentEntries(int limit) const {
std::lock_guard lk(mu_);
std::vector<MCPAuditEntry> out;
std::ifstream in(filePath_);
if (!in) return out;
std::vector<std::string> lines;
std::string line;
while (std::getline(in, line)) {
if (!line.empty()) lines.push_back(std::move(line));
}
int start = std::max<int>(0, static_cast<int>(lines.size()) - limit);
for (int i = static_cast<int>(lines.size()) - 1; i >= start; --i) {
try {
auto j = nlohmann::json::parse(lines[i]);
if (auto e = MCPAuditEntry::fromJson(j)) out.push_back(*e);
} catch (...) {}
}
return out;
}
void AuditLogger::clearAll() {
std::lock_guard lk(mu_);
if (out_.is_open()) out_.close();
std::error_code ec;
fs::remove(filePath_, ec);
}
void AuditLogger::close() {
std::lock_guard lk(mu_);
if (out_.is_open()) out_.close();
}
// MCPAuditEntry::fromJson definition — placed here to avoid header bloat.
std::optional<MCPAuditEntry> MCPAuditEntry::fromJson(const nlohmann::json& j) {
try {
MCPAuditEntry e;
e.timestampIso8601 = j.value("timestamp", "");
e.eventId = j.value("eventId", "");
e.tool = j.value("tool", "");
e.tier = j.value("tier", 1);
if (j.contains("connectionId")) e.connectionId = j["connectionId"].get<std::string>();
if (j.contains("connectionType")) e.connectionType = j["connectionType"].get<std::string>();
if (j.contains("error")) e.error = j["error"].get<std::string>();
if (j.contains("client")) {
e.client.name = j["client"].value("name", "unknown");
e.client.version = j["client"].value("version", "0.0.0");
e.client.transport = j["client"].value("transport", "stdio");
}
if (j.contains("input")) {
const auto& i = j["input"];
if (i.contains("sqlPreview")) e.input.sqlPreview = i["sqlPreview"].get<std::string>();
if (i.contains("paramsCount")) e.input.paramsCount = i["paramsCount"].get<int>();
if (i.contains("inputHash")) e.input.inputHash = i["inputHash"].get<std::string>();
}
if (j.contains("result")) {
const auto& r = j["result"];
std::string s = r.value("status", "success");
e.result.status = (s == "success") ? MCPAuditStatus::Success
: (s == "denied") ? MCPAuditStatus::Denied
: (s == "timeout") ? MCPAuditStatus::Timeout
: MCPAuditStatus::Error;
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 (r.contains("bytesReturned")) e.result.bytesReturned = r["bytesReturned"].get<int>();
}
if (j.contains("security")) {
const auto& s = j["security"];
std::string modeStr = s.value("permissionMode", "locked");
if (auto m = mcpConnectionModeFromRaw(modeStr)) e.security.mode = *m;
if (s.contains("userApproved")) e.security.userApproved = s["userApproved"].get<bool>();
if (s.contains("approvalSessionId")) e.security.approvalSessionId = s["approvalSessionId"].get<std::string>();
if (s.contains("scopesApplied")) e.security.scopesApplied = s["scopesApplied"].get<std::vector<std::string>>();
}
return e;
} catch (...) {
return std::nullopt;
}
}
} // namespace gridex::mcp