#include "McpClient.hpp" #include #include #include #include #include #include using namespace tp; using namespace tp::taskboard; namespace { constexpr const char* kProtocolVersion = "2024-11-05"; std::string errorText(const std::string& context) { return context + ": " + std::strerror(errno); } bool writeAll(int descriptor, const std::string& data) { size_t written = 0; while (written < data.size()) { const ssize_t count = ::write(descriptor, data.data() + written, data.size() - written); if (count < 0 && errno == EINTR) continue; if (count <= 0) return false; written += size_t(count); } return true; } picojson::object clientInfo() { picojson::object info; info["name"] = picojson::value("taskboard"); info["version"] = picojson::value("1"); return info; } } McpClient::McpClient() = default; McpClient::~McpClient() { stop(); } bool McpClient::start(const McpServerCommand& command, std::string& error) { if (isRunning()) return true; if (!spawn(command, error)) return false; { std::lock_guard lock(mMutex); mRunning = true; } mReader = std::thread([this] { readLoop(); }); if (handshake(error)) return true; stop(); return false; } bool McpClient::spawn(const McpServerCommand& command, std::string& error) { int toChild[2]; int fromChild[2]; if (::pipe2(toChild, O_CLOEXEC) != 0 || ::pipe2(fromChild, O_CLOEXEC) != 0) { error = errorText("pipe"); return false; } const pid_t pid = ::fork(); if (pid < 0) { error = errorText("fork"); return false; } if (pid == 0) { ::dup2(toChild[0], STDIN_FILENO); ::dup2(fromChild[1], STDOUT_FILENO); if (!command.stderrPath.empty()) { const int log = ::open(command.stderrPath.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644); if (log >= 0) ::dup2(log, STDERR_FILENO); } for (const auto& [name, value] : command.environment) ::setenv(name.c_str(), value.c_str(), 1); std::vector argv; argv.push_back(const_cast(command.executable.c_str())); for (const std::string& argument : command.arguments) argv.push_back(const_cast(argument.c_str())); argv.push_back(nullptr); ::execvp(command.executable.c_str(), argv.data()); ::_exit(127); } ::close(toChild[0]); ::close(fromChild[1]); mPid = pid; mToServer = toChild[1]; mFromServer = fromChild[0]; return true; } bool McpClient::handshake(std::string& error) { picojson::object params; params["protocolVersion"] = picojson::value(kProtocolVersion); params["capabilities"] = picojson::value(picojson::object()); params["clientInfo"] = picojson::value(clientInfo()); bool done = false; McpToolResult outcome; const bool sent = request("initialize", params, [&](const McpToolResult& result) { outcome = result; done = true; }); if (!sent || !waitUntil([&] { return done; }) || !outcome.ok) { error = outcome.error.empty() ? "task server did not answer initialize" : outcome.error; return false; } picojson::object notification; notification["jsonrpc"] = picojson::value("2.0"); notification["method"] = picojson::value("notifications/initialized"); return send(notification); } bool McpClient::waitUntil(const std::function& finished) { while (true) { dispatchCompletions(); if (finished()) return true; std::unique_lock lock(mMutex); mResponded.wait(lock, [&] { return !mReady.empty() || !mRunning; }); if (mReady.empty() && !mRunning) { lock.unlock(); dispatchCompletions(); return finished(); } } } void McpClient::stop() { { std::lock_guard lock(mMutex); if (mPid < 0 && !mReader.joinable()) return; } if (mToServer >= 0) { ::close(mToServer); mToServer = -1; } if (mPid > 0) { int status = 0; ::waitpid(mPid, &status, 0); mPid = -1; } if (mReader.joinable()) mReader.join(); if (mFromServer >= 0) { ::close(mFromServer); mFromServer = -1; } failAll("server stopped"); } bool McpClient::isRunning() const { std::lock_guard lock(mMutex); return mRunning; } long McpClient::nextId() { std::lock_guard lock(mMutex); return mNextId++; } bool McpClient::send(const picojson::object& message) { if (mToServer < 0) return false; return writeAll(mToServer, picojson::value(message).serialize() + "\n"); } bool McpClient::request(const std::string& method, picojson::object params, Completion completion) { const long id = nextId(); { std::lock_guard lock(mMutex); if (!mRunning) return false; mPending[id] = { std::move(completion) }; } picojson::object message; message["jsonrpc"] = picojson::value("2.0"); message["id"] = picojson::value(double(id)); message["method"] = picojson::value(method); message["params"] = picojson::value(params); if (send(message)) return true; std::lock_guard lock(mMutex); mPending.erase(id); return false; } void McpClient::callTool(const std::string& name, picojson::object arguments, Completion completion) { picojson::object params; params["name"] = picojson::value(name); params["arguments"] = picojson::value(arguments); const bool sent = request("tools/call", params, [completion](const McpToolResult& raw) { if (completion) completion(raw.ok ? toolResult(raw.value) : raw); }); if (!sent && completion) deliver(completion, { false, {}, "task server is not running" }); } McpToolResult McpClient::callToolBlocking(const std::string& name, picojson::object arguments) { bool done = false; McpToolResult outcome; callTool(name, std::move(arguments), [&](const McpToolResult& result) { outcome = result; done = true; }); if (!waitUntil([&] { return done; })) return { false, {}, "task server stopped" }; return outcome; } void McpClient::readLoop() { std::string buffer; char chunk[4096]; while (true) { const ssize_t count = ::read(mFromServer, chunk, sizeof(chunk)); if (count < 0 && errno == EINTR) continue; if (count <= 0) break; buffer.append(chunk, size_t(count)); for (size_t newline = buffer.find('\n'); newline != std::string::npos; newline = buffer.find('\n')) { const std::string line = buffer.substr(0, newline); buffer.erase(0, newline + 1); if (!line.empty()) handleMessage(line); } } { std::lock_guard lock(mMutex); mRunning = false; } failAll("task server exited"); } void McpClient::handleMessage(const std::string& line) { picojson::value message; if (!picojson::parse(message, line).empty() || !message.is()) return; const picojson::object& object = message.get(); auto id = object.find("id"); if (id == object.end() || !id->second.is()) return; Completion completion; { std::lock_guard lock(mMutex); auto pending = mPending.find(long(id->second.get())); if (pending == mPending.end()) return; completion = std::move(pending->second.completion); mPending.erase(pending); } auto error = object.find("error"); if (error != object.end()) { deliver(completion, { false, {}, error->second.serialize() }); return; } auto result = object.find("result"); deliver(completion, { true, result == object.end() ? picojson::value() : result->second, {} }); } size_t McpClient::pendingCount() const { std::lock_guard lock(mMutex); return mPending.size() + mReady.size(); } void McpClient::waitForIdle() { waitUntil([this] { return pendingCount() == 0; }); } void McpClient::setOnResponse(std::function callback) { std::lock_guard lock(mMutex); mOnResponse = std::move(callback); } void McpClient::deliver(Completion completion, McpToolResult result) { std::function onResponse; { std::lock_guard lock(mMutex); mReady.emplace_back(std::move(completion), std::move(result)); onResponse = mOnResponse; mResponded.notify_all(); } if (onResponse) onResponse(); } void McpClient::failAll(const std::string& reason) { std::map pending; { std::lock_guard lock(mMutex); pending.swap(mPending); } for (auto& [id, entry] : pending) deliver(std::move(entry.completion), { false, {}, reason }); std::lock_guard lock(mMutex); mResponded.notify_all(); } void McpClient::dispatchCompletions() { std::deque> ready; { std::lock_guard lock(mMutex); ready.swap(mReady); } for (auto& [completion, result] : ready) { if (completion) completion(result); } } McpToolResult McpClient::toolResult(const picojson::value& response) { if (!response.is()) return { false, {}, "malformed tool response" }; const picojson::object& object = response.get(); auto isError = object.find("isError"); auto content = object.find("content"); std::string text; if ( content != object.end() && content->second.is() && !content->second.get().empty() ) { const picojson::value& first = content->second.get().front(); if (first.is() && first.get().count("text")) text = first.get().at("text").to_str(); } if (isError != object.end() && isError->second.evaluate_as_boolean()) return { false, {}, text }; auto structured = object.find("structuredContent"); if (structured != object.end() && structured->second.is()) { const picojson::object& wrapped = structured->second.get(); auto inner = wrapped.find("result"); return { true, inner == wrapped.end() ? structured->second : inner->second, {} }; } picojson::value parsed; if (!text.empty() && picojson::parse(parsed, text).empty()) return { true, parsed, {} }; return { true, picojson::value(text), {} }; }